定时任务Quatrz

概念

Quartz是Job scheduling（作业调度）领域的一个开源项目，Quartz既可以单独使用也
可以跟spring框架整合使用，在实际开发中一般会使用后者。使用Quartz可以开发一个
或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、
每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。
官网：http://www.quartz-scheduler.org/
maven坐标：

<dependency>
<groupId>org.quartz‐schedulergroupId>
<artifactId>quartzartifactId>
<version>2.2.1version>
dependency>
<dependency>
<groupId>org.quartz‐schedulergroupId>
<artifactId>quartz‐jobsartifactId>
<version>2.2.1version>
dependency>

拓展：

Quartz

• 默认多线程异步执行
  单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度。业务繁忙时，一个任务会有多个调度，可能导致数据处理异常。
  多个任务时，任务之间没有直接影响，多任务执行的快慢取决于CPU的性能
• 触发方式
  SimpleTrigger：value=2000 每隔两秒触发
  CronTrigger：value=”0 0 12 * * ?” 每天中午12点触发
  需要在配置文件中实现配置Job
• 能被集群实例化，支持分布式部署
• 使用JobStoreCMT（JDBCJobStore的子类），Quartz 能参与JTA事务；Quartz 能管理JTA事务(开始和提交)在执行任务之间，这样，任务做的事就可以发生在JTA事务里。

Spring Task

• 默认单线程同步执行
  单个任务时，当前次的调度完成后，再执行下一次任务调度
  多个任务时，一个任务执行完成后才会执行下一个任务。若需要任务能够并发执行，需手动设置线程池
• 触发方式：
  与Quartz的CronTrigger的表达式类似
  可以使用注解标注定时任务

比较：

• 实现，Task注解实现方式，比较简单。Quartz需要手动配置Jobs。

• 任务执行，Task默认单线程串行执行任务，多任务时若某个任务执行时间过长，后续任务会无法及时执行。

  Quartz采用多线程，无这个问题。

• 调度，Task采用顺序执行，若当前调度占用时间过长，下一个调度无法及时执行；

  Quartz采用异步，下一个调度时间到达时，会另一个线程执行调度，不会发生阻塞问题，但调度过多时可能导致数据处理异常

• 部署，Quartz可以采用集群方式，分布式部署到多台机器，分配执行定时任务

26-定时任务组件Quartz（入门案例） 11:49

（1）创建maven工程quartzdemo，导入Quartz和spring相关坐标，pom.xml文件如下

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>quartzdemoartifactId>
    <version>1.0-SNAPSHOTversion>
    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-context-supportartifactId>
            <version>5.0.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-txartifactId>
            <version>5.0.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.quartz-schedulergroupId>
            <artifactId>quartzartifactId>
            <version>2.2.1version>
        dependency>
        <dependency>
            <groupId>org.quartz-schedulergroupId>
            <artifactId>quartz-jobsartifactId>
            <version>2.2.1version>
        dependency>
    dependencies>

project>

（2）自定义一个Job

package com.itheima.jobs;

import java.util.Date;

/**
 * 自定义Job
 */
public class JobDemo {
    public void run(){
        System.out.println("自定义Job执行了。。。" + new Date());
    }
}

（3）提供Spring配置文件spring-jobs.xml，配置自定义Job、任务描述、触发器、调度
工厂等

WHO WHEN WHAT 谁在什么时间来做什么事

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/context
						http://www.springframework.org/schema/context/spring-context.xsd">
    
    <bean id="jobDemo" class="com.itheima.jobs.JobDemo">bean>
    
    <bean id="jobDetail"
          class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        
        <property name="targetObject" ref="jobDemo"/>
        
        <property name="targetMethod" value="run"/>
    bean>
    
    <bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        
        <property name="jobDetail" ref="jobDetail"/>
        
        <property name="cronExpression">
            <value>0/10 * * * * ?value>
        property>
    bean>

    
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        
        <property name="triggers">
            <list>
                <ref bean="myTrigger"/>
            list>
        property>
    bean>
beans>

1.先注入我们需要执行方法的bean

2.注入MethodInvokingJobDetailFactoryBean，同时targetObject指定步骤1中的bean id,targetMethod指定步骤1中的bean的方法

3.注入org.springframework.scheduling.quartz.CronTriggerFactoryBean触发器，指定任务触发的时间。property中的jobDetail指定步骤2的bean id。cronExpression指定cron表达式

4.注入org.springframework.scheduling.quartz.SchedulerFactoryBean指定触发器调度工厂，触发器指定为步骤3的bean id

总结：调度工厂->触发器->job定义->job执行bean

(4)main方法进行测试

package com.itheima;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        new ClassPathXmlApplicationContext("spring-jobs.xml");
    }
}

27-定时任务组件Quartz（Cron表达式语法） 13：58

上面的入门案例中我们指定了一个表达式：0/10 * * * * ?
这种表达式称为cron表达式，通过cron表达式可以灵活的定义出符合要求的程序执行的
时间。本小节我们就来学习一下cron表达式的使用方法。如下图：

位置	时间域名	允许值	允许的特殊字符
1	秒	0-59	, - * /
2	分钟	0-59	, - * /
3	小时	0-23	, - * /
4	日期	1-31	, - * ? / L W C
5	月份	1-12	, - * /
6	星期	1-7 1代表周日	, - * ? / L C #
7	年(可选)	空值1970-2099	, - * /

cron表达式分为七个域，之间使用空格分隔。其中最后一个域（年）可以为空。每个域
都有自己允许的值和一些特殊字符构成。使用这些特殊字符可以使我们定义的表达式更
加灵活。

下面是对这些特殊字符的介绍：

5/10 * * * * ? 2020

逗号（,）：指定一个值列表，例如使用在月域上1,4,5,7表示1月、4月、5月和7月
横杠（-）：指定一个范围，例如在时域上3-6表示3点到6点（即3点、4点、5点、6点）
星号（*）：表示这个域上包含所有合法的值。例如，在月份域上使用星号意味着每个月
都会触发
斜线（/）：表示递增，例如使用在秒域上0/15表示每15秒
问号（?）：只能用在日和周域上，但是不能在这两个域上同时使用。表示不指定，问号(?)就是用来对日期和星期字段做互斥的。cronExpression对日期和星期字段的处理规则是它们必须互斥，即只能且必须有一个字段有特定的值，另一个字段必须是‘没有特定的值’。
井号（#）：只能使用在周域上，用于指定月份中的第几周的哪一天，例如6#3，意思是
某月的第三个周五 (6=星期五，3意味着月份中的第三周)
L：某域上允许的最后一个值。只能使用在日和周域上。当用在日域上，表示的是在月域
上指定的月份的最后一天。用于周域上时，表示周的最后一天，就是星期六
W：W 字符代表着工作日 (星期一到星期五)，只能用在日域上，它用来指定离指定日的
最近的一个工作日

练习：

表示式	说明
"0 0 12 * * ？ "	每天12点运行
“0 15 10 ? * *”	每天10:15运行
“0 15 10 * * ?”	每天10:15运行
“0 15 10 * * ? *”	每天10:15运行
“0 15 10 * * ? 2008”	在2008年的每天10：15运行
“0 * 14 * * ?”	每天14点到15点之间每分钟运行一次，开始于14:00，结束于14:59。
“0 0/5 14 * * ?”	每天14点到15点每5分钟运行一次，开始于14:00，结束于14:55。
“0 0/5 14,18 * * ?”	每天14点到15点每5分钟运行一次，此外每天18点到19点每5钟也运行一次。
“0 0-5 14 * * ?”	每天14:00点到14:05，每分钟运行一次。
“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 2007-2009”	在2007,2008,2009年每个月的最后一个星期五的10:15分运行。
“0 15 10 ? * 6#3”	每月第三个星期五的10:15分运行。

28-定时任务组件Quartz（Cron表达式在线生成器） 06:02

前面介绍了cron表达式，但是自己编写表达式还是有一些困难的，我们可以借助一些
cron表达式在线生成器来根据我们的需求生成表达式即可。
http://cron.qqe2.com/

http://www.bejson.com/othertools/cron/

29-定时清理垃圾图片（代码实现） 20:55

（1）创建maven工程health_jobs，打包方式为war，导入Quartz等相关坐标

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>health_parentartifactId>
        <groupId>com.itheimagroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>health_jobsartifactId>
    <packaging>warpackaging>

    <name>health_jobs Maven Webappname>
    
    <url>http://www.example.comurl>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
    properties>
    <dependencies>
        <dependency>
            <groupId>com.itheimagroupId>
            <artifactId>health_interfaceartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        <dependency>
            <groupId>org.quartz-schedulergroupId>
            <artifactId>quartzartifactId>
        dependency>
        <dependency>
            <groupId>org.quartz-schedulergroupId>
            <artifactId>quartz-jobsartifactId>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.mavengroupId>
                <artifactId>tomcat7-maven-pluginartifactId>
                <configuration>
                    
                    <port>83port>
                    
                    <path>/path>
                configuration>
            plugin>
        plugins>
    build>
project>

（2）配置web.xml

<web-app>
  <display-name>Archetype Created Web Applicationdisplay-name>
  
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath*:applicationContext*.xmlparam-value>
  context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>
web-app>

（3）配置log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:\\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=debug, stdout

（4）配置applicationContext-redis.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                         http://www.springframework.org/schema/beans/spring-beans.xsd
        				http://www.springframework.org/schema/mvc
                          http://www.springframework.org/schema/mvc/spring-mvc.xsd
        				http://code.alibabatech.com/schema/dubbo
                          http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        				http://www.springframework.org/schema/context
                          http://www.springframework.org/schema/context/spring-context.xsd">

    
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal">
            <value>200value>
        property>
        <property name="maxIdle">
            <value>50value>
        property>
        <property name="testOnBorrow" value="true"/>
        <property name="testOnReturn" value="true"/>
    bean>
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
        <constructor-arg name="host" value="127.0.0.1" />
        <constructor-arg name="port" value="6379" type="int" />
        <constructor-arg name="timeout" value="30000" type="int" />
    bean>
beans>

最大空闲数

（5）配置applicationContext-jobs.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
							http://www.springframework.org/schema/beans/spring-beans.xsd
							http://www.springframework.org/schema/mvc
							http://www.springframework.org/schema/mvc/spring-mvc.xsd
							http://code.alibabatech.com/schema/dubbo
							http://code.alibabatech.com/schema/dubbo/dubbo.xsd
							http://www.springframework.org/schema/context
							http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:annotation-config>context:annotation-config>
    
    <bean id="clearImgJob" class="com.itheima.jobs.ClearImgJob">bean>

    <bean id="jobDetail"
          class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        
        <property name="targetObject" ref="clearImgJob"/>
        
        <property name="targetMethod" value="clearImg"/>
    bean>
    
    <bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        
        <property name="jobDetail" ref="jobDetail"/>
        
        <property name="cronExpression">
            
            <value>0/10 * * * * ?value>
        property>
    bean>
    
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        
        <property name="triggers">
            <list>
                <ref bean="myTrigger"/>
            list>
        property>
    bean>
beans>

（6）创建ClearImgJob定时任务类

set1 :包含了已经上传图片

set2:包含了存储到数据库的图片

set1 - set2获取集合，遍历这个集合，调用七牛云的API删除图片

Redis Sdiff 命令返回给定集合之间的差集。不存在的集合 key 将视为空集。

差集的结果来自前面的 FIRST_KEY ,而不是后面的 OTHER_KEY1，也不是整个 FIRST_KEY OTHER_KEY1…OTHER_KEYN 的差集。

实例:

key1 = {a,b,c,d}
key2 = {c}
key3 = {a,c,e}
key4 = {b}
SDIFF key1 key2 key3 key4 = {d}

package com.itheima.jobs;

import com.itheima.constant.RedisConstant;
import com.itheima.utils.QiniuUtils;
import com.qiniu.common.QiniuException;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.JedisPool;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

/**
 * 自定义Job，实现定时清理垃圾图片
 */
public class ClearImgJob2 {
    @Autowired
    private JedisPool jedisPool;

    public void clearImg() {
        //根据Redis中保存的两个set集合进行差值计算，获得垃圾图片名称集合
        //SET里面既包含了真正的垃圾图片，也包含了用户将来可能会提交的图片
        Set<String> set = jedisPool.getResource().sdiff(RedisConstant.SETMEAL_PIC_RESOURCES,
                RedisConstant.SETMEAL_PIC_DB_RESOURCES);

        //将来要去删除的内容
        Set<String> delete = new HashSet<>();

        //遍历所有的已经上传的图片
        Set<String> smembers =
                jedisPool.getResource().smembers(RedisConstant.SETMEAL_PIC_RESOURCES);

        //所有超过8个小时的图片都干掉，不管你是不是垃圾图片
        //视频老师的代码有个BUG，随着数据库里面的数据增多，redis数据越来越多（包括数据库已经录入的，不是垃圾图片的数据）
        for (String str : smembers) {
            //获取每个时间，判断是否超过8小时
            String filename_hash = jedisPool.getResource().hget("filename_hash", str);
            //获取到每一个上传了的图片的上传时间
            Long time = Long.valueOf(filename_hash);
            Long current = System.currentTimeMillis();
            if ((current - time) > 1000L * 60L * 60L * 1) {
                //超过8小时的，可以删除
                delete.add(str);
            }
        }

        if(!delete.isEmpty()){
            for(String picName : delete){
                if(set.contains(picName)){
                    //垃圾图片
                    QiniuUtils.deleteFileFromQiniu(picName);
                }else{
                    //不是垃圾图片，db set中有这个数据
                    jedisPool.getResource().srem(RedisConstant.SETMEAL_PIC_DB_RESOURCES, picName);
                }

                jedisPool.getResource().srem(RedisConstant.SETMEAL_PIC_RESOURCES, picName);
                jedisPool.getResource().hdel("filename_hash",picName);
                System.out.println(picName);
            }
        }

    }
}

backend上传接口：

@RequestMapping("/upload")
    public Result upload(@RequestParam("imgFile") MultipartFile imgFile){
        System.out.println(imgFile);
        String originalFilename = imgFile.getOriginalFilename();//原始文件名 3bd90d2c-4e82-42a1-a401-882c88b06a1a2.jpg
        int index = originalFilename.lastIndexOf(".");
        String extention = originalFilename.substring(index);//.jpg
        String fileName = UUID.randomUUID().toString() + extention;//	FuM1Sa5TtL_ekLsdkYWcf5pyjKGu.jpg
        try {
            //将文件上传到七牛云服务器
            QiniuUtils.upload2Qiniu(imgFile.getBytes(),fileName);
            jedisPool.getResource().sadd(RedisConstant.SETMEAL_PIC_RESOURCES,fileName);
            jedisPool.getResource().hset("filename_hash",fileName,String.valueOf(System.currentTimeMillis()));
        } catch (IOException e) {
            e.printStackTrace();
            return new Result(false, MessageConstant.PIC_UPLOAD_FAIL);
        }
        return new Result(true, MessageConstant.PIC_UPLOAD_SUCCESS,fileName);
    }

//字符串 set get

//set集合

sadd添加

srem删除

sdiff set1 set2 set3 做多个set差集

smembers 列出所有set中的数据

//hash

hset(key,field,value) 给key名的hash,添加键值对(field,value)

//lpush lpop rpush rpop队列

//lpush rpop队列

//lpush lpop栈

//zset sorted set 有评分的列表

//排行榜

//布隆过滤器 hyperLogLog

//redis 离你最近的人 geo

//模块化