在项目中经常有定时任务的功能需求。Quartz是Java中比较成熟和常用的任务调度器。Spring框架对其提供了集成。Quartz非常容易使用。
一个任务调度器最基本的三个元素是
Job(or Task)：需要定时处理的事情
Trigger: 事件触发时间点(一次性的、固定周期性的、像Linux Cron Jobs 灵活配置的)
Scheduler: 调度器
Job与Trigger是一对一的关系，Scheduler与Trigger是一对多的关系。
先看一个Spring配置这三个元素的示例：
Cron表达式使用格式
Seconds
Minutes
Hours
DayofMonth
Month
DayofWeek
[Year]
秒
分
时
天
月
星期
[年]
每个符号代表的含义：
* ：匹配该域的任意值；如*用在分所在的域，表示每分钟都会触发事件。
? ：匹配该域的任意值。
– ：匹配一个特定的范围值；如时所在的域的值是10-12，表示10、11、12点的时候会触发事件。
, ：匹配多个指定的值；如周所在的域的值是2,4,6，表示在周一、周三、周五就会触发事件(1表示周日，2表示周一，3表示周二，以此类推，7表示周六)。
/ ：左边是开始触发时间，右边是每隔固定时间触发一次事件，如秒所在的域的值是5/15，表示5秒、20秒、35秒、50秒的时候都触发一次事件。
L ：last，最后的意思，如果是用在天这个域，表示月的最后一天，如果是用在周所在的域，如6L，表示某个月最后一个周五。(外国周日是星耀日，周一是月耀日，一周的开始是周日，所以1L=周日，6L=周五。)
W ：weekday，工作日的意思。如天所在的域的值是15W，表示本月15日最近的工作日，如果15日是周六，触发器将触发上14日周五。如果15日是周日，触发器将触发16日周一。如果15日不是周六或周日，而是周一至周五的某一个，那么它就在15日当天触发事件。
# ：用来指定每个月的第几个星期几，如6#3表示某个月的第三个星期五。
实用的例子
表达式
含义
“0 0 12 * * ?”
每天12:00触发事件
“0 15 10 ？ * *”
每天10:15触发事件
“0 15 10 * * ?”
每天10:15触发事件
“0 15 10 * * ? *”
每天10:15触发事件
“0 15 10 * * ? 2005”
2005年的每天10:15触发事件
“0 * 14 * * ?”
每天14点开始触发，每分钟触发一次，14:59分结束
“0 0/5 14 * * ?”
每天14点开始触发到14:59分结束的每5分钟触发一次事件
“0 0/5 14,18 * * ?”
每天14点开始到14:59期间和18点到18:59期间的每5分钟触发一次事件
“0 0-5 14 * * ?”
每天14点到14:05期间的每1分钟触发一次事件
“0 10,44 14 ? 3 WED”
每年3月的星期三的14:10和14:44触发一次事件
“0 15 10 ? * MON-FRI”
周一至周五的10:15触发一次事件
“0 15 10 15 * ?”
每月15日10:15触发一次事件
“0 15 10 L * ?”
每月最后一日的10:15触发一次事件
“0 15 10 ? * 6L”
每月的最后一个星期五10:15触发一次事件
“0 15 10 ? * 6L 2002-2005”
2002年至2005年的每月的最后一个星期五10:15触发一次事件
“0 15 10 ? * 6#3”
每月的第三个星期五10:15触发一次事件

          
/*
 * Timer类是一种线程设施，可以用来实现在某一个时间或某一段时间后安排某一个任务执行一次或定期重复执行.
 * Timer类的常用方法
 * 1>Timer()创建一个计时器，并启动该计时器
 * 2>cancel()取消计时器
 * 3>purge()将已取消的任务移除，用来释放内存空间
 * 4>schedule()安排一个任务执行
 * TimerTask类的常用方法
 * 1>cancel()
 * 2>run()
 * 3>scheduled Execution Time()
 */
package com.timer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class timer {
    public static void main(String[] args){
        myTast mytast = new myTast();
        Timer t = new Timer();
        t.schedule(mytast, 1000, 1000);
    }
}
/*
 * 设计时钟类
 */
class myTast extends TimerTask{
    private static int  time;
    public myTast(){
        this.time=0;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        if(this.time>2){
            this.cancel();  //执行两次后终止，第三次会执行完
        }else{
            this.time++;
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
            String time = sdf.format(new Date());
            System.out.println(time+"=>"+this.time);
        }
    }
      
}


				
转载于:https://blog.51cto.com/6846041/1355031

比较器(Comparable、Comparator)
Comparable接口

可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口。

Comparable接口定义如下：



[java] view
 plaincopyprint?






public interface Comparable<T>{  

   public int compareTo(T o);  

}  


从接口的定义格式上来看，可以发现如果想实现对象属性的排序功能，要实现Comparable接口，并且覆写compareTo(T o)方法。此方法返回的是一个int类型的数据，但是此int类型的数据只能是一下三种：

·1：表示大于

·-1：表示小于

·0：表示等于

看如下的实例：一个学生类，里面有三个属性姓名、年龄、成绩三个属性，要求按成绩由高到底排序，如果成绩相等，则按照年龄由底到高排序。



[java] view
 plaincopyprint?






class Student implements Comparable<Student>  //指定类型为Student  

{  

    private String name;  

    private int age;  

    private float score;  

    public Student(String name,int age,float score){  

        this.name=name;  

        this.age=age;  

        this.score=score;  

    }  

    public String toString(){  

        return name+"\t\t"+age+"\t\t"+score+"\t\t";  

    }  

    public int compareTo(Student stu){  //覆写compareTo方法，实现排序规则的应用  

        if(this.score<stu.score){  

            return -1;  

        }  

        if(this.score>stu.score){  

            return 1;  

        }  

        else{  

            if(this.age<stu.age){  

                return -1;  

            }  

            if(this.age>stu.age){  

                return 1;  

            }  

            else{  

                return 0;  

            }  

        }  

    }  

}  

public class ComparableDemo01  

{  

    public static void main(String args[]){  

        Student stu[]={  

            new Student("张三",20,89.1f),  

            new Student("李四",26,53.5f),  

            new Student("王五",30,79.0f),  

            new Student("赵六",20,66.0f),  

            new Student("孙七",25,66.0f)  

        };  

        java.util.Arrays.sort(stu); //进行排序操作  

        for(Student x:stu){ //循环输出  

            System.out.println(x);  

        }  

    }  

}  


注意：如果在此时Student类没有实现Comparable接口，则在执行的时候会出现一下异常：



[java] view
 plaincopyprint?






Exception in thread "main" java.lang.ClassCastException: Student cannot be cast  

to java.lang.Comparable  

另一种比较器Comparator

此比较器其实跟Comparable是非常类似的。如果现在已经完成了一个类的开发，但是并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这种问题，java又定义了另一个比较器的操作接口---Comparator。此接口在java.util包中，接口如下定义：



[java] view
 plaincopyprint?






pubic interface Comparator<T>{  

  public int compare(T o1,T o2);  

  boolena equals(Object obj);  

}  


代码如下：



[java] view
 plaincopyprint?






import java.util.*;  

class Student    {  

    private String name;  

    private int age;  

    private float score;  

    public Student(String name,int age,float score){  

        this.name=name;  

        this.age=age;  

        this.score=score;  

    }  

    public void setName(String name){  

        this.name=name;  

    }  

    public String getName(){  

        return name;  

    }  

    public void setAge(int age){  

        this.age=age;  

    }  

    public int getAge(){  

        return age;  

    }  

    public String toString(){  

        return name+"\t\t"+age+"\t\t"+score+"\t\t";  

    }  

}  

class StudentComparator implements Comparator<Student>  

{  

    //因为Object类中已经覆写过equals方法  

    public int compare(Student s1,Student s2){  

        if(s1.equals(s2)){  

            return 0;  

        }     

        else if(s1.getAge()<s2.getAge()){    //按照年龄进行比较  

            return 1;  

        }  

        else{  

            return -1;  

        }  

    }  

}  

public class ComparableDemo02  

{  

    public static void main(String args[]){  

        Student stu[]={  

            new Student("张三",20,89.1f),  

            new Student("李四",26,53.5f),  

            new Student("王五",30,79.0f),  

            new Student("赵六",20,66.0f),  

            new Student("孙七",25,66.0f)  

        };  

        java.util.Arrays.sort(stu,new StudentComparator()); //进行排序操作  

        for(Student x:stu){ //循环输出  

            System.out.println(x);  

        }  

    }  

}  


总结：在开发中尽量还是使用Comparable在需要排序的类上实现好此接口，而Comparator需要单独建立一个排序的类，这样如果有很多的话，则排序的规则类也就会很多，操作起来比较麻烦些。注意：在java中只要是对象排序，永远都是以Comparable接口为准的。
观察者设计模式
具体内容

所谓观察者设计模式，就是某一样东西被多个观察者观察，当这样东西发生变化，则会及时反馈到每个观察者的身上。如果要想实现观察者设计模式，则必须依靠java.util包中的Observable类和Observer接口。

例子：现在很多的购房者都在关注着房子的变化，每当房子价格变化的时候，所有的观察者都能够立即观察到



[java] view
 plaincopyprint?






import java.util.* ;  

class House extends Observable{ // 表示房子可以被观察  

    private float price ;// 价钱  

    public House(float price){  

        this.price = price ;  

    }  

    public float getPrice(){  

        return this.price ;  

    }  

    public void setPrice(float price){  

        // 每一次修改的时候都应该引起观察者的注意  

        super.setChanged() ;    // 设置变化点  

        super.notifyObservers(price) ;// 价格被改变  

        this.price = price ;  

    }  

    public String toString(){  

        return "房子价格为：" + this.price ;  

    }  

};   

class HousePriceObserver implements Observer{  

    private String name ;  

    public HousePriceObserver(String name){ // 设置每一个购房者的名字  

        this.name = name ;  

    }  

    public void update(Observable o,Object arg){  

        if(arg instanceof Float){  

            System.out.print(this.name + "观察到价格更改为：") ;  

            System.out.println(((Float)arg).floatValue()) ;  

        }  

    }  

};  

public class ObserDemo01{  

    public static void main(String args[]){  

        House h = new House(1000000) ;  

        HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  

        HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  

        HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  

        h.addObserver(hpo1) ;  

        h.addObserver(hpo2) ;  

        h.addObserver(hpo3) ;  

        System.out.println(h) ; // 输出房子价格  

        h.setPrice(666666) ;    // 修改房子价格  

        System.out.println(h) ; // 输出房子价格  

    }  

};  

正则表达式

正则表达式可以方便的对数据进行匹配，可以执行更加复杂的字符串验证、拆分、替换等功能。

例如：现在要求判断一个字符串是否由数字组成，有以下两种方式：

·不使用正则完成

·使用正则完成

第一种方式代码：



[java] view
 plaincopyprint?






public class RegexDemo01{  

    public static void main(String args[]){  

        String str = "1234567890" ;     // 此字符串由数字组成  

        boolean flag = true ;           // 定义一个标记变量  

        // 要先将字符串拆分成字符数组，之后依次判断  

        char c[] = str.toCharArray() ;  // 将字符串变为字符数组  

        for(int i=0;i<c.length;i++){ // 循环依次判断  

            if(c[i]<'0'||c[i]>'9'){       // 如果满足条件，则表示不是数字  

                flag = false ;          // 做个标记  

                break ;                 // 程序不再向下继续执行  

            }  

        }  

        if(flag){  

            System.out.println("是由数字组成！") ;  

        }else{  

            System.out.println("不是由数字组成！") ;  

        }  

    }  

};  


第二中方式代码：



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

public class RegexDemo02{  

    public static void main(String args[]){  

        String str = "1234567890" ;     // 此字符串由数字组成  

        if(Pattern.compile("[0-9]+").matcher(str).matches()){   // 使用正则  

            System.out.println("是由数字组成！") ;  

        }else{  

            System.out.println("不是由数字组成！") ;  

        }  

    }  

};  

Pattern、Matcher类

这两个类为正则的核心操作类，都是定义在java.util.regex包中。Pattern类主要是进行正则规范(如之前的操作“[0-9]“就属于正则规范)的编写，而Matcher类主要是执行规范，验证一个字符串是否符合规范。

常用正则规则：





·\d：表示数字， [0-9]

·\D：表示非数字，[^0-9]

·\w：表示字母、数字、下划线，[a-zA-Z0-9]

·\W：[^a-zA-Z0-9]

常用正则规范2：





以上的正则，如果要想驱动起来，则必须依靠Pattern和Matcher类。

Pattern主要是表示一个规则的意思，即：正则表达式的规则需要在Pattern类中使用。

Matcher类主要表示使用Pattern指定好的规则验证。

Pattern类的常用方法：







方法



描述





public static Pattern compile(String regex)



指定正则表达式规则





public Matcher matcher(CharSequence input)



返回Mather类的实例





public String[] split(CharSequence input)



字符串拆分







在Patter类中如果要想取得Pattern类的实例，则必须调用compile()方法。

本类中没有明确的构造方法可以使用，那么此类的构造方法肯定被私有化了，如果是这样的类，都可以通过本类中的一个静态方法获得该类的实例。

Matcher类中的常用方法：







方法



描述





Public Boolean matches()



执行验证





Public String replaceAll(String replacement)



字符串替换







实例操作：(验证日期是否合法)



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

import java.util.regex.Matcher ;  

public class RegexDemo03{  

    public static void main(String args[]){  

        String str = "1983-07-27" ;     // 指定好一个日期格式的字符串  

        String pat = "\\d{4}-\\d{2}-\\d{2}" ;   // 指定好正则表达式  

        Pattern p = Pattern.compile(pat) ;  // 实例化Pattern类  

        Matcher m = p.matcher(str) ;    // 实例化Matcher类  

        if(m.matches()){        // 进行验证的匹配，使用正则  

            System.out.println("日期格式合法！") ;  

        }else{  

            System.out.println("日期格式不合法！") ;  

        }  

    }  

};  


在Pattern类中也可以使用正则进行字符的拆分功能：



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

import java.util.regex.Matcher ;  

public class RegexDemo04{  

    public static void main(String args[]){  

        // 要求将里面的字符取出，也就是说按照数字拆分  

        String str = "A1B22C333D4444E55555F" ;  // 指定好一个字符串  

        String pat = "\\d+" ;   // 指定好正则表达式  

        Pattern p = Pattern.compile(pat) ;  // 实例化Pattern类  

        String s[] = p.split(str) ; // 执行拆分操作  

        for(int x=0;x<s.length;x++){  

            System.out.print(s[x] + "\t") ;  

        }  

    }  

};  


还可以使用Matcher类中的字符串替换功能：



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

import java.util.regex.Matcher ;  

public class RegexDemo05{  

    public static void main(String args[]){  

        // 要求将里面的字符取出，也就是说按照数字拆分  

        String str = "A1B22C333D4444E55555F" ;  // 指定好一个字符串  

        String pat = "\\d+" ;   // 指定好正则表达式  

        Pattern p = Pattern.compile(pat) ;  // 实例化Pattern类  

        Matcher m = p.matcher(str) ;    // 实例化Matcher类的对象  

        String newString = m.replaceAll("_") ;  

        System.out.println(newString) ;  

    }  

};  

String类对正则的支持

在String类中有以下三个方法是支持正则操作的：







方法



描述





public boolean matches(String regex)



字符串匹配





public String replaceAll(String regex,String replacement)



字符串替换





public String[] split(String regex)



字符串拆分







代码如下：



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

import java.util.regex.Matcher ;  

public class RegexDemo06{  

    public static void main(String args[]){  

        String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;  

        boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;  

        String s[] = "A1B22C333D4444E55555F".split("\\d+") ;  

        System.out.println("字符串替换操作：" + str1) ;  

        System.out.println("字符串验证：" + temp) ;  

        System.out.print("字符串的拆分：") ;  

        for(int x=0;x<s.length;x++){  

            System.out.print(s[x] + "\t") ;  

        }  

    }  

};  


但是，使用正则需要注意一点，看如下的代码：



[java] view
 plaincopyprint?






import java.util.regex.Pattern ;  

import java.util.regex.Matcher ;  

public class RegexDemo07{  

    public static void main(String args[]){  

        String info = "LXH:98|MLDN:90|LI:100" ;         // 定义一个字符串  

        // 拆分的形式：  

        /* 

            LXH -->  98 

            MLDN    -->  90 

            LI  -->  100 

        */  

        String s[] = info.split("\\|") ;  

        System.out.println("字符串的拆分：") ;  

        for(int x=0;x<s.length;x++){  

            String s2[] = s[x].split(":") ;  

            System.out.println(s2[0] + "\t" + s2[1]) ;  

        }  

    }  

};  


如果有时候发现一个字符串无法按照指定的字符拆分的话，则需要使用“\”转义，转义的时候连个“\”表示一个“\”。

总结：

1、  使用正则可以方便完成字符串的验证、拆分、替换等功能。

2、  在开发中一般会使用String类提供好的正则支持，很少使用Pattern或者是Matcher类。

3、  在使用一些正则的时候，对于一些敏感的字符要进行转义。
定时调度

定时调度：每隔一段时间，程序会自动执行，成为定时调度。

如果要使用定时调度，则必须保证程序运行这才可以，也就说是相当于定时调度在程序之外又启动了一个新的线程。使用Timer和TimerTask两个类完成定时调度。
Timer类

Timer类是一种线程设施，可以用来实现在某一个时间或某一段时间后，安排某一个任务执行一次，或定期重复执行。该功能要与TimerTask类配合使用。TimerTask类用来实现由Timer安排的一次或重复执行的某一个任务。

Timer类的常用方法：







方法



类型



描述





public Timer()



构造



用来创建一个计时器并启动





 

public void cancel()



普通

 



用来终止该计时器，并放弃所有已安排的任务，对当前正在执行的任务没有影响。





public int purge()



普通



将所有已经取消的任务移除，一般用来释放内存空间





public void schedule(TimerTask task,Date time)



普通

 



安排一个任务在指定的时间执行，如果已经超过该时间，则立即执行。





public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)



普通



安排一个任务在指定的时间执行，之后以近似固定的频率(单位：毫秒)重复执行







Schedule()与scheduleAtFixedRate()方法的区别：







两者的区别在于重复执行任务时，对于时间间隔出现延迟的情况处理：

·Schedule()方法的执行时间间隔永远是固定的，如果之前出现了延迟的情况，之后也会按照设定好的间隔时间执行。

·scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下一次间隔的执行时间。






TimerTask类

要想执行具体的任务，则必须使用TimerTask类。TimerTask是一个抽象类，如果要使用该类，需要建立一个子类继承该类，并实现其中的抽象方法。







方法



描述





 

public void cancle()

 



用来终止此任务，如果该任务只执行一次并且还没有执行，则永远不会再执行，如果为重复执行任务，则之后不会再执行(如果该任务正在执行，则执行完后不会再执行)





public void run()



该任务所要执行的具体操作，该方法为引入接口Runable中的方法，子类需要覆写。





 

public long scheduledExecutionTime()

 



返回最近一次执行任务的时间(如果正在运行，则返回该任务的执行安排时间)，一般在run()方法中调用，用来判断当前是否有足够的时间来执行完该任务。




代码示例：定时调度的程序，每隔2秒打印一次。






[java] view
 plaincopyprint?






//完成具体的任务操作  

import java.util.*;  

import java.text.SimpleDateFormat;  

class MyTask extends TimerTask  //任务调度类都要继承TimerTask  

{  

    public void run(){  

        SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");  

        System.out.println("当前系统时间为："+sd.format(new Date()));  

    }  

}  


完成的是一个具体的任务操作类，以后定时调度就是调度此类的操作，方法的主体就是run()方法。注意要继承TimerTask类，下面建立测试类，并执行任务调度：



[java] view
 plaincopyprint?






import java.util.*;  

public class TestTask  

{  

    public static void main(String args[]){  

        Timer t=new Timer();  

        MyTask mytask=new MyTask();  

        t.schedule(mytask,1000,2000);  

    }  

}  


总结：一般在web开发中此内容比较有用，因为要维护一个容器不关闭才可以一直定时调度下去。

在java中我们常用Timer和TimerTask实现定时功能，而在JavaEE项目中可以使用Spring整合Quartz定时器，非常的强大，能够实现所有想要的定时任务，包括Tomcat服务器开始启动，定时定点定周等等的任务，有关Quartz的介绍和时间配置网上有很多的资料，就不在累赘，下面主要介绍SpringMVC整合Quartz的实现步骤。

来源博客： http://blog.csdn.net/fengshizty

1、 导入quartz.jar包，或者pom.xml 配置对应的依赖：

 

            org.quartz-scheduler 

            quartz 

            1.8.6 


2、 在Web项目web.xml中配置quartz的配置文件加载路径：

 

        rest 

        org.springframework.web.servlet.DispatcherServlet 


            contextConfigLocation 


                /WEB-INF/classes/rest-servlet.xml,  

               /WEB-INF/classes/pyc-spring-quartz.xml 



        1 


3、写具体的定时调度的任务：

package andy.test.quartz.schedule;

/** 

 * @author Zhang,Tianyou 

 * @version：2014-12-11 下午12:00:24 

 *  

 *  一个测试的打印定时任务 

 */

public class MyPrintSchedule {

public void printSomething(){
    //内容就是打印一句话
    System.out.println("this is andy schedule");
}


} 

4、配置quartz的xml配置信息，名字可以随便，需和web.xml中的一致。

pyc-spring-quartz.xml配置信息如下：