But first I shall tell you a little about my use case and why I thought about cron jobs in the first place…..

Use case

My application was inserting data (let’s call it smash data for simplicity for now)in the database.Each smash data has a certain expiry period and after that expiry period, that data should no longer remain in the database.But the expiry period will be different for each smash data.

Example:

smash 1, expiryperiod :10mins

smash 2 ,expiryperiod :60mins

smash 3 ,expiryperiod :150mins . . . etc.

Now my first line of thinking ended up being cron jobs which led to me studying about cron jobs and scheduled in spring boot.To answer it simply I didn’t end up taking this route is because cron jobs or scheduled tasks are suited when we expect the task to execute at only a particular point of time or where we expect functionality to be executed at w particular time on an hourly/daily /weekly/monthly basis. I could get the cron job to delete the data but to delete WHICH data smash 1 or smash 2? That would mean I would have to check the DB. So the process would be something like:-

Fetch all rows from DB. Check timestamp of each row data against current timestamp and delete accordingly. I wanted to avoid writing the searching, comparing time logic (dates, in general, can be a pain sometimes).The logic which I did ended up going through was events in SQL since I’m using MySQL db for the use case

Mysql events are tasks that run according to a particular schedule …hence they can be called as scheduled events

When an event is created in MySQL, a named database object is created and this object consists of one or more SQL statements to be executed at some regular intervals.Using events,I didn’t have to retrieve and search the data (as I had to do in the spring boot controller ) . I could just write an event such as

Delete from table1 where
expiry period < NOW();

And schedule this to execute every minute. Which was would check for that expiryPeriod column in each row and compare with time NOW() So any rows whose expiryperiod has passed will be deleted from db.

The only thing to note I see in this approach, for now, is that this is database dependent so when I host this side project (a hopeful dream) I need to make sure events is configured for the same. So this was the use case now back to cron jobs!

Cron jobs or schedule tasks in spring boot.Permalink

When a situation arises where we expect the task to execute at only a particular point of time or where we expect functionality to be executed at a particular time on an hourly/daily /weekly/monthly basis. Cron jobs are suitable for this use case. In spring this sort of scheduled task can be achieved through @Scheduled annotation.

There are a few rules while using the @Scheduled annotation: 1. The method should typically have a void return type else the returned value will be ignored.

the method should not expect any parameters. First, to enable scheduling in the spring boot project, use @EnableScheduling in the main class.

public class Application {
 public static void main(String[] args) {
 SpringApplication.run(PasteBinApplication.class, args);
 }
}

Scheduling using CRON expressions

@Component
public class SchedulerService {
    @Scheduled(cron="*/15 * * * * ?")
    public void testScheduled()
    {
        System.out.println("Method executed at every 15 seconds. Current time is :: "+ new Date());
    }
}

A guide for cron jobs: cron Image source :Java Techonline

SEC  MIN   HOURS   DAY  MONTH  WEEKDAY
 *    *      *      *     *      *

Scheduling using initial delay,Fixed Delay or Fixed Rate

The main difference between Fixed Delay and Fixed Rate is : Fixed Delay : controls the next execution time when the last execution finishes. Fixed Rate : makes Spring run the task on periodic intervals even if the last invocation may be still running.

Fixed Delay

@Component
public class SchedulerService {
    @Scheduled(fixedDelay = 1000, initialDelay = 5000)
    public void testScheduled()
    {
        System.out.println("Method executed with fixed delay and initial delay . Current time is :: "+ new Date());
    }
}

Also Fixed Delay can take input in String and Integer. @Scheduled(fixedDelayString = “7000”) @Scheduled(fixedDelayString = 7000) Fixed Rate:

@Component
public class SchedulerService {
    @Scheduled(fixedRate = 1000)
    public void testScheduled()
    {
        System.out.println("Method executed with fixed rate . Current time is :: "+ new Date());
    }
}

That’s all folks.Learning about events and cron jobs and where could be applied was interesting to learn when applied on some small practical application.

In Java ,Polymorphism means multiple forms of an object. We shall divide this article into 3 sections.

1.Syntax

2.Calling a variable polymorphically.

3.Calling a method polymorphically.

1.SyntaxPermalink Now in polymorphism in Java, the thumb key rule to remember is

super = subPermalink Meaning the variable reference (LHS) must always be a super class reference and the object initialization(RHS) must a sub class.

For Example: class A{

} class B extends A{ } class C extends B{ } class D extends A{ }

So valid and invalid syntax according to the thumb rule will be

A a =new B();           //VALID
B b=new D();            //NOT VALID
C c=new A();           //VALID
A a1=new D();           //VALID

2.Calling a variable polymorphically.Permalink If a variable is called from a polymorphic object,we follow the reference i.e. the super class. And if the variable is not present in the super class ,it results in a COMPILE ERROR. EG:

class A{
int x=5;
}
class B extends A{
int x=10;
}
class App{
public static void main(String[]args){
A a=new B();
System.out.println(a.x);
//What do u think is the output class A x value (5)or class B x value(10)?Follow the rule.

}
}
OUTPUT:
5

Calling a method polymorphically.Permalink If a method is called from a polymorphic object ,we follow a 2 step procedure: 1.We got to the super class and check whther the method is present or not.

if(present)
 Goto to step 2
else
 COMPILE ERROR

2.Come to the sub class and check wther the method is overrided or not.

if(overrided)
 Call the sub-class version
else
 Call the super -class version.

Eg:

class A{
void m1(){
System.out.println("A");
}}
class B extends A{
void m1(){
System.out.println("B");
}}
class App{
public static void main(String[]args){
A a=new B();
a.m1();          //Follow the rule
B=new B();
b.m1();          //Normal sub class object method call
}}
OUTPUT:
B
B

So that’s all for polymorphism in java.

Happy Learning :)

A constructor is used to initialize instance variables

When an object of an class is created,JVM goes to the class and searches for that matching constructor.If Constructor is NOT PRESENT it gives a compile error.

By default every class has a constructor called default no argument constructor.

class A{
A(){ //default no arg constructor
}}

A programmer can have multiple constructors in a class provided their signatures are different this is called constructor overloading.

class A{
A(){
//some code
}

A(int x){
//some code
}

A(float x){
//some code
}

A(float x,int y){
//some code
}
A(int x,float y){
}
A(int z){}//THIS WILL GIVE COMPILE ERROR SInce its already defined on top.

}

A a=new A();
new A();//goes to first matching constructor

JVM always calls the matching constructor from the class.HOWEVER,a programmer can call other constructors of this class by using the the this() method.

class A{
A(){
System.out.println("A");    //I
A(int x){
this();                     //this will go to constructor A();
System.out.println("AA");   //II
}
}
class App{
public static void main(String[]args){
new A(5);
}}

OUTPUT:
A
AA

If a programmer desires it can call the constructor of the super class as well from its own constructor using the super() method.

class A{
A(){
System.out.println("A");    //I
}
}
class B extends A{
B(){
super();             //this is called implicitly refer next point also
System.out.println("B");
}}


class HelloWorld {
    public static void main(String[] args) {
        new B();
    }
}
OUTPUT:
A
B

Whenever a programmer creates a constructor ,JVM writes super() in every constructor implicitly as its first line.

Note:If a class does not extend any class it by default extends the Object class. Do Try this code in your ide to see it for yourself

class A{
A(){
//super will be called implicitly at the first line of this constructor and here since it does not extend any class it will extend the Object class
System.out.println("A");    //I
}

A(int x){
//super will be called implicitly at the first line of this constructor
System.out.println("AA");
}}


class HelloWorld {
    public static void main(String[] args) {
        new A(5);
    }
}
OUTPUT:
A
AA

That’s all for constructors in Java.

Happy Learning :)