java cron表达式依赖包 java的cron表达式

转载

mob64ca13f7ecc9 2023-08-27 10:51:12

文章标签 java cron表达式依赖包 java redis spring maven 文章分类 Java 后端开发

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可以采用集群方式，分布式部署到多台机器，分配执行定时任务

1. Quartz (入门案例)

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

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>com.ittest</groupId>
    <artifactId>quartzdemo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>
    </dependencies>

</project>

（2）自定义一个Job

package com.ittest.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 谁在什么时间来做什么事

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!-- 注册自定义Job -->
    <bean id="jobDemo" class="com.ittest.jobs.JobDemo"></bean>
    <!-- 注册JobDetail,作用是负责通过反射调用指定的Job -->
    <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">
        <!-- 注入JobDetail -->
        <property name="jobDetail" ref="jobDetail"/>
        <!-- 指定触发的时间，基于Cron表达式 -->
        <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.ittest;

import org.springframework.context.support.ClassPathXmlApplicationContext;

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

2. 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分运行。

3. Cron表达式在线生成器

cron表达式在线生成器来根据我们的需求生成表达式即可。
http://cron.qqe2.com/

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

4. 定时清理垃圾图片

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

<?xml version="1.0" encoding="UTF-8"?>

<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_parent</artifactId>
        <groupId>com.ittest</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>health_jobs</artifactId>
    <packaging>war</packaging>

    <name>health_jobs Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.ittest</groupId>
            <artifactId>health_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <!-- 指定端口 -->
                    <port>83</port>
                    <!-- 请求路径 -->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

（2）配置web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!-- 加载spring容器 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:applicationContext*.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-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

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!--Jedis连接池的相关配置-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal">
            <value>200</value>
        </property>
        <property name="maxIdle">
            <value>50</value>
        </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

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!--开启spring注解使用-->
    <context:annotation-config></context:annotation-config>
    <!--注册自定义Job-->
    <bean id="clearImgJob" class="com.ittest.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">
        <!-- 注入JobDetail -->
        <property name="jobDetail" ref="jobDetail"/>
        <!-- 指定触发的时间，基于Cron表达式 -->
        <property name="cronExpression">
            <!--
            <value>0 0 2 * * ?</value>
            -->
            <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删除图片

package com.ittest.jobs;
import com.ittest.constant.RedisConstant;
import com.ittest.utils.QiniuUtils;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.JedisPool;
import java.util.Set;
/**
 * 自定义Job，实现定时清理垃圾图片
 */
public class ClearImgJob {
    @Autowired
    private JedisPool jedisPool;
    public void clearImg(){
//根据Redis中保存的两个set集合进行差值计算，获得垃圾图片名称集合
        Set<String> set =
                jedisPool.getResource().sdiff(RedisConstant.SETMEAL_PIC_RESOURCES,
                        RedisConstant.SETMEAL_PIC_DB_RESOURCES);
        if(set != null){
            for (String picName : set) {
//删除七牛云服务器上的图片
                QiniuUtils.deleteFileFromQiniu(picName);
//从Redis集合中删除图片名称
                jedisPool.getResource().
                        srem(RedisConstant.SETMEAL_PIC_RESOURCES,picName);
            }
        }
    }
}

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.ittest.jobs;

import com.ittest.constant.RedisConstant;
import com.ittest.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);
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。