Springboot整个Quartz实现动态定时任务的示例代码

简介

Quartz是一款功能强大的任务调度器,可以实现较为复杂的调度功能,如每月一号执行、每天凌晨执行、每周五执行等等,还支持分布式调度。本文使用Springboot+Mybatis+Quartz实现对定时任务的增、删、改、查、启用、停用等功能。并把定时任务持久化到数据库以及支持集群。

Quartz的3个基本要素

  1. Scheduler:调度器。所有的调度都是由它控制。
  2. Trigger: 触发器。决定什么时候来执行任务。
  3. JobDetail & Job: JobDetail定义的是任务数据,而真正的执行逻辑是在Job中。使用JobDetail + Job而不是Job,这是因为任务是有可能并发执行,如果Scheduler直接使用Job,就会存在对同一个Job实例并发访问的问题。而JobDetail & Job 方式,sheduler每次执行,都会根据JobDetail创建一个新的Job实例,这样就可以规避并发访问的问题。

如何使用Quartz

1.添加依赖

<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.2.3</version>
</dependency>
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz-jobs</artifactId>
  <version>2.2.3</version>
</dependency>

2.创建配置文件

在maven项目的resource目录下创建quartz.properties

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

#线程池配置
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

#持久化配置
org.quartz.jobStore.misfireThreshold = 50000
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#支持集群
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.useProperties:true
org.quartz.jobStore.clusterCheckinInterval = 15000
#使用weblogic连接Oracle驱动
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.weblogic.WebLogicOracleDelegate
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.dataSource = qzDS
#数据源连接信息,quartz默认使用c3p0数据源可以被自定义数据源覆盖
org.quartz.dataSource.qzDS.driver = oracle.jdbc.driver.OracleDriver
org.quartz.dataSource.qzDS.URL = jdbc:oracle:thin:@localhost:1521/XE
org.quartz.dataSource.qzDS.user = root
org.quartz.dataSource.qzDS.password = 123456
org.quartz.dataSource.qzDS.maxConnections = 10

说明:在使用quartz做持久化的时候需要用到quartz的11张表,可以去quartz官网下载对应版本的quartz,解压打开docs/dbTables里面有对应数据库的建表语句。关于quartz.properties配置的详细解释可以查看quartz官网。另外新建一张表TB_APP_QUARTZ用于存放定时任务基本信息和描述等信息,定时任务的增、删、改、执行等功能与此表没有任何关系。
quartz的11张表:

//TB_APP_QUARTZ表的实体类
public class AppQuartz {
  private Integer quartzId; //id 主键
  private String jobName; //任务名称
  private String jobGroup; //任务分组
  private String startTime; //任务开始时间
  private String cronExpression; //corn表达式
  private String invokeParam;//需要传递的参数
  ...省略set get
}

3.Quartz配置

/**
 * 创建job 实例工厂,解决spring注入问题,如果使用默认会导致spring的@Autowired 无法注入问题
 * @author LLQ
 *
 */
@Component
public class JobFactory extends AdaptableJobFactory{
  @Autowired
  private AutowireCapableBeanFactory capableBeanFactory;

   @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
      //调用父类的方法
      Object jobInstance = super.createJobInstance(bundle);
      //进行注入
      capableBeanFactory.autowireBean(jobInstance);
      return jobInstance;
    }

}
@Configuration
public class SchedulerConfig implements ApplicationListener<ContextRefreshedEvent>{
  @Autowired
  private JobFactory jobFactory;
  @Autowired
  @Qualifier("dataSource")
  private DataSource primaryDataSource;

  @Override
   public void onApplicationEvent(ContextRefreshedEvent event) {
    System.out.println("任务已经启动..."+event.getSource());
  }

  @Bean
  public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
    //获取配置属性
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
    //在quartz.properties中的属性被读取并注入后再初始化对象
    propertiesFactoryBean.afterPropertiesSet();
    //创建SchedulerFactoryBean
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setQuartzProperties(propertiesFactoryBean.getObject());
    //使用数据源,自定义数据源
    factory.setDataSource(this.primaryDataSource);
    factory.setJobFactory(jobFactory);
    factory.setWaitForJobsToCompleteOnShutdown(true);//这样当spring关闭时,会等待所有已经启动的quartz job结束后spring才能完全shutdown。
    factory.setOverwriteExistingJobs(false);
    factory.setStartupDelay(1);
    return factory;
  }

  /*
   * 通过SchedulerFactoryBean获取Scheduler的实例
   */
  @Bean(name="scheduler")
  public Scheduler scheduler() throws IOException {
    return schedulerFactoryBean().getScheduler();
  }

  @Bean
  public QuartzInitializerListener executorListener() {
    return new QuartzInitializerListener();
  }
}

4.创建定时任务服务

@Service
public class JobUtil {
   @Autowired
   @Qualifier("scheduler")
   private Scheduler scheduler;

   /**
   * 新建一个任务
   *
   */
   public String addJob(AppQuartz appQuartz) throws Exception {

       SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date date=df.parse(appQuartz.getStartTime());

       if (!CronExpression.isValidExpression(appQuartz.getCronExpression())) {
        return "Illegal cron expression";  //表达式格式不正确
      }
      JobDetail jobDetail=null;
      //构建job信息
      if("JobOne".equals(appQuartz.getJobGroup())) {
         jobDetail = JobBuilder.newJob(JobOne.class).withIdentity(appQuartz.getJobName(), appQuartz.getJobGroup()).build();
      }
      if("JobTwo".equals(appQuartz.getJobGroup())) {
         jobDetail = JobBuilder.newJob(JobTwo.class).withIdentity(appQuartz.getJobName(), appQuartz.getJobGroup()).build();
      }

      //表达式调度构建器(即任务执行的时间,不立即执行)
      CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(appQuartz.getCronExpression()).withMisfireHandlingInstructionDoNothing();

      //按新的cronExpression表达式构建一个新的trigger
      CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(appQuartz.getJobName(), appQuartz.getJobGroup()).startAt(date)
          .withSchedule(scheduleBuilder).build();

      //传递参数
      if(appQuartz.getInvokeParam()!=null && !"".equals(appQuartz.getInvokeParam())) {
        trigger.getJobDataMap().put("invokeParam",appQuartz.getInvokeParam());
      }
      scheduler.scheduleJob(jobDetail, trigger);
      // pauseJob(appQuartz.getJobName(),appQuartz.getJobGroup());
      return "success";
    }
     /**
     * 获取Job状态
     * @param jobName
     * @param jobGroup
     * @return
     * @throws SchedulerException
     */
     public String getJobState(String jobName, String jobGroup) throws SchedulerException {
       TriggerKey triggerKey = new TriggerKey(jobName, jobGroup);
       return scheduler.getTriggerState(triggerKey).name();
      }

     //暂停所有任务
     public void pauseAllJob() throws SchedulerException {
       scheduler.pauseAll();
     }

    //暂停任务
    public String pauseJob(String jobName, String jobGroup) throws SchedulerException {
      JobKey jobKey = new JobKey(jobName, jobGroup);
      JobDetail jobDetail = scheduler.getJobDetail(jobKey);
      if (jobDetail == null) {
         return "fail";
      }else {
         scheduler.pauseJob(jobKey);
         return "success";
      }

    }

    //恢复所有任务
    public void resumeAllJob() throws SchedulerException {
      scheduler.resumeAll();
    }

    // 恢复某个任务
    public String resumeJob(String jobName, String jobGroup) throws SchedulerException {

      JobKey jobKey = new JobKey(jobName, jobGroup);
      JobDetail jobDetail = scheduler.getJobDetail(jobKey);
      if (jobDetail == null) {
        return "fail";
      }else {
        scheduler.resumeJob(jobKey);
        return "success";
      }
    }

    //删除某个任务
    public String deleteJob(AppQuartz appQuartz) throws SchedulerException {
      JobKey jobKey = new JobKey(appQuartz.getJobName(), appQuartz.getJobGroup());
      JobDetail jobDetail = scheduler.getJobDetail(jobKey);
      if (jobDetail == null ) {
         return "jobDetail is null";
      }else if(!scheduler.checkExists(jobKey)) {
        return "jobKey is not exists";
      }else {
         scheduler.deleteJob(jobKey);
         return "success";
      } 

    }

    //修改任务
    public String modifyJob(AppQuartz appQuartz) throws SchedulerException {
      if (!CronExpression.isValidExpression(appQuartz.getCronExpression())) {
        return "Illegal cron expression";
      }
      TriggerKey triggerKey = TriggerKey.triggerKey(appQuartz.getJobName(),appQuartz.getJobGroup());
      JobKey jobKey = new JobKey(appQuartz.getJobName(),appQuartz.getJobGroup());
      if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        //表达式调度构建器,不立即执行
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(appQuartz.getCronExpression()).withMisfireHandlingInstructionDoNothing();
        //按新的cronExpression表达式重新构建trigger
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
          .withSchedule(scheduleBuilder).build();
        //修改参数
        if(!trigger.getJobDataMap().get("invokeParam").equals(appQuartz.getInvokeParam())) {
          trigger.getJobDataMap().put("invokeParam",appQuartz.getInvokeParam());
        }
        //按新的trigger重新设置job执行
        scheduler.rescheduleJob(triggerKey, trigger);
        return "success";
      }else {
        return "job or trigger not exists";
      }  

    }

}
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
@Component
public class JonOne implements Job{
  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException{
    JobDataMap data=context.getTrigger().getJobDataMap();
    String invokeParam =(String) data.get("invokeParam");
    //在这里实现业务逻辑
    }
}
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
@Component
public class JobTwo implements Job{
  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException{
    JobDataMap data=context.getTrigger().getJobDataMap();
    String invokeParam =(String) data.get("invokeParam");
    //在这里实现业务逻辑
    }
}

说明:每个定时任务都必须有一个分组,名称和corn表达式,corn表达式也就是定时任务的触发时间,关于corn表达式格式以及含义可以参考一些网络资源。每个定时任务都有一个入口类在这里我把类名当成定时任务的分组名称,例如:只要创建定时任务的分组是JobOne的都会执行JobOne这个任务类里面的逻辑。如果定时任务需要额外的参数可以使用JobDataMap传递参数,当然也可以从数据库中获取需要的数据。@PersistJobDataAfterExecution和@DisallowConcurrentExecution注解是不让某个定时任务并发执行,只有等当前任务完成下一个任务才会去执行。

5.封装定时任务接口

@RestController
public class JobController {
  @Autowired
  private JobUtil jobUtil;
  @Autowired
  private AppQuartzService appQuartzService;

  //添加一个job
  @RequestMapping(value="/addJob",method=RequestMethod.POST)
  public ReturnMsg addjob(@RequestBody AppQuartz appQuartz) throws Exception {
    appQuartzService.insertAppQuartzSer(appQuartz);
    result=jobUtil.addJob(appQuartz);
  }

  //暂停job
  @RequestMapping(value="/pauseJob",method=RequestMethod.POST)
  public ReturnMsg pausejob(@RequestBody Integer[]quartzIds) throws Exception {
    AppQuartz appQuartz=null;
    if(quartzIds.length>0){
      for(Integer quartzId:quartzIds) {
        appQuartz=appQuartzService.selectAppQuartzByIdSer(quartzId).get(0);
        jobUtil.pauseJob(appQuartz.getJobName(), appQuartz.getJobGroup());
      }
      return new ReturnMsg("200","success pauseJob");
    }else {
      return new ReturnMsg("404","fail pauseJob");
    }
  }

  //恢复job
  @RequestMapping(value="/resumeJob",method=RequestMethod.POST)
  public ReturnMsg resumejob(@RequestBody Integer[]quartzIds) throws Exception {
    AppQuartz appQuartz=null;
    if(quartzIds.length>0) {
      for(Integer quartzId:quartzIds) {
        appQuartz=appQuartzService.selectAppQuartzByIdSer(quartzId).get(0);
        jobUtil.resumeJob(appQuartz.getJobName(), appQuartz.getJobGroup());
      }
      return new ReturnMsg("200","success resumeJob");
    }else {
      return new ReturnMsg("404","fail resumeJob");
    }
  } 

  //删除job
  @RequestMapping(value="/deletJob",method=RequestMethod.POST)
  public ReturnMsg deletjob(@RequestBody Integer[]quartzIds) throws Exception {
    AppQuartz appQuartz=null;
    for(Integer quartzId:quartzIds) {
      appQuartz=appQuartzService.selectAppQuartzByIdSer(quartzId).get(0);
      String ret=jobUtil.deleteJob(appQuartz);
      if("success".equals(ret)) {
        appQuartzService.deleteAppQuartzByIdSer(quartzId);
      }
    }
    return new ReturnMsg("200","success deleteJob");
  }

  //修改
  @RequestMapping(value="/updateJob",method=RequestMethod.POST)
  public ReturnMsg modifyJob(@RequestBody AppQuartz appQuartz) throws Exception {
    String ret= jobUtil.modifyJob(appQuartz);
    if("success".equals(ret)) {
      appQuartzService.updateAppQuartzSer(appQuartz);
      return new ReturnMsg("200","success updateJob",ret);
    }else {
      return new ReturnMsg("404","fail updateJob",ret);
    }
  }

  //暂停所有
  @RequestMapping(value="/pauseAll",method=RequestMethod.GET)
  public ReturnMsg pauseAllJob() throws Exception {
    jobUtil.pauseAllJob();
    return new ReturnMsg("200","success pauseAll");
  }

  //恢复所有
  @RequestMapping(value="/repauseAll",method=RequestMethod.GET)
  public ReturnMsg repauseAllJob() throws Exception {
    jobUtil.resumeAllJob();
    return new ReturnMsg("200","success repauseAll");
  }  

}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • SpringBoot实现动态定时任务

    项目情况: 在当前项目中需要一个定时任务来清除过期的校验码,如果使用数据库存储过程的话不方便维护.因此采用SpringBoot自带的方式来设置定时任务. 技术说明: SpringBoot自带的方式有两种可以实现: 一种是使用@Scheduled注解的方式,只需要在启动类或者它所在的类上添加@EnableScheduling注解允许执行定时任务,并且设置Schecduled注解的参数,诸如: 1.cron是设置定时执行的表达式,如 0 0/5 * * * ?每隔五分钟执行一次 2.zone表示执行

  • Spring Boot中配置定时任务、线程池与多线程池执行的方法

    配置基础的定时任务 最基本的配置方法,而且这样配置定时任务是单线程串行执行的,也就是说每次只能有一个定时任务可以执行,可以试着声明两个方法,在方法内写一个死循环,会发现一直卡在一个任务上不动,另一个也没有执行. 1.启动类 添加@EnableScheduling开启对定时任务的支持 @EnableScheduling @SpringBootApplication public class TestScheduledApplication extends SpringBootServletInit

  • spring-boot通过@Scheduled配置定时任务及定时任务@Scheduled注解的方法

    串行的定时任务 @Component public class ScheduledTimer { private Logger logger = Logger.getLogger(this.getClass()); /** * 定时任务,1分钟执行1次,更新潜在客户超时客户共享状态 */ @Scheduled(cron="0 0/1 8-20 * * ?") public void executeUpdateCuTask() { Thread current = Thread.curr

  • springboot schedule 解决定时任务不执行的问题

    @schedule 注解 是springboot 常用的定时任务注解,使用起来简单方便,但是如果定时任务非常多,或者有的任务很耗时,会影响到其他定时任务的执行,因为schedule 默认是单线程的,一个任务在执行时,其他任务是不能执行的.解决办法是重新配置schedule,改为多线程执行.只需要增加下面的配置类就可以了. import org.springframework.boot.autoconfigure.batch.BatchProperties; import org.springfr

  • 详解SpringBoot 创建定时任务(配合数据库动态执行)

    序言:创建定时任务非常简单,主要有两种创建方式:一.基于注解(@Scheduled) 二.基于接口(SchedulingConfigurer). 前者相信大家都很熟悉,但是实际使用中我们往往想从数据库中读取指定时间来动态执行定时任务,这时候基于接口的定时任务就大派用场了. 一.静态定时任务(基于注解) 基于注解来创建定时任务非常简单,只需几行代码便可完成. @Scheduled 除了支持灵活的参数表达式cron之外,还支持简单的延时操作,例如 fixedDelay ,fixedRate 填写相应

  • spring boot整合quartz实现多个定时任务的方法

    最近收到了很多封邮件,都是想知道spring boot整合quartz如何实现多个定时任务的,由于本人生产上并没有使用到多个定时任务,这里给个实现的思路. 1.新建两个定时任务,如下: public class ScheduledJob implements Job{ @Override public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("sched

  • springBoot 创建定时任务过程详解

    前言 好几天没写了,工作有点忙,最近工作刚好做一个定时任务统计的,所以就将springboot 如何创建定时任务整理了一下. 总的来说,springboot创建定时任务是非常简单的,不用像spring 或者springmvc 需要在xml 文件中配置,在项目启动的时候加载.spring boot 使用注解的方式就可以完全支持定时任务. 不过基础注解的话,可能有的需求定时任务的时间会经常变动,注解就不好修改,每次都得重新编译,所以想将定时时间存在数据库,然后项目读取数据库执行定时任务,所以就有了基

  • Springboot整个Quartz实现动态定时任务的示例代码

    简介 Quartz是一款功能强大的任务调度器,可以实现较为复杂的调度功能,如每月一号执行.每天凌晨执行.每周五执行等等,还支持分布式调度.本文使用Springboot+Mybatis+Quartz实现对定时任务的增.删.改.查.启用.停用等功能.并把定时任务持久化到数据库以及支持集群. Quartz的3个基本要素 Scheduler:调度器.所有的调度都是由它控制. Trigger: 触发器.决定什么时候来执行任务. JobDetail & Job: JobDetail定义的是任务数据,而真正的

  • SpringBoot实现动态定时任务的示例代码

    目录 前言 配置文件 定时任务核心类 提供修改cron表达式的controller 前言 之前在SpringBoot项目中简单使用定时任务,不过由于要借助cron表达式且都提前定义好放在配置文件里,不能在项目运行中动态修改任务执行时间,实在不太灵活.现在我们就来实现可以动态修改cron表达式的定时任务. 配置文件 application-task.yml,其余的配置 application.yml 等就按照springBoot正常配置即可 task: cron: 0/10 * * * * ? t

  • Spring整合Quartz实现动态定时器的示例代码

    一.版本说明 spring3.1以下的版本必须使用quartz1.x系列,3.1以上的版本才支持quartz 2.x,不然会出错. 原因:spring对于quartz的支持实现,org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger,在quartz1.x系列中org.quartz.CronTrigger是个类,而在quartz2.x系列中org.quartz.CronTrigger变成了接口,从

  • SpringBoot+Quartz实现动态定时任务

    本文实例为大家分享了springBoot+Quartz实现动态定时任务的具体代码,供大家参考,具体内容如下 目前常用的几种任务调度 Timer,简单无门槛,一般也没人用. spring @Scheduled注解,一般集成于项目中,小任务很方便. 开源工具 Quartz,分布式集群开源工具,以下两个分布式任务应该都是基于Quartz实现的,可以说是中小型公司必选,当然也视自身需求而定. 分布式任务 XXL-JOB,是一个轻量级分布式任务调度框架,支持通过 Web 页面对任务进行 CRUD 操作,支

  • SpringBoot Scheduling定时任务的示例代码

    目录 开启定时任务注解@EnableScheduling @Scheduled添加定时任务 Cron表达式 在线cron工具 适应场景 springBoot提供了定时任务的支持,通过注解简单快捷,对于日常定时任务可以使用. 开启定时任务注解@EnableScheduling @EnableScheduling @SpringBootApplication public class DockerApplication { public static void main (String[] args

  • springboot多数据源配置及切换的示例代码详解

    注:本文的多数据源配置及切换的实现方法是,在框架中封装,具体项目中配置及使用,也适用于多模块项目 配置文件数据源读取 通过springboot的Envioment和Binder对象进行读取,无需手动声明DataSource的Bean yml数据源配置格式如下: spring: datasource: master: type: com.alibaba.druid.pool.DruidDataSource driverClassName: com.mysql.cj.jdbc.Driver url:

  • Springboot整合Netty实现RPC服务器的示例代码

    一.什么是RPC? RPC(Remote Procedure Call)远程过程调用,是一种进程间的通信方式,其可以做到像调用本地方法那样调用位于远程的计算机的服务.其实现的原理过程如下: 本地的进程通过接口进行本地方法调用. RPC客户端将调用的接口名.接口方法.方法参数等信息利用网络通信发送给RPC服务器. RPC服务器对请求进行解析,根据接口名.接口方法.方法参数等信息找到对应的方法实现,并进行本地方法调用,然后将方法调用结果响应给RPC客户端. 二.实现RPC需要解决那些问题? 1. 约

  • SpringBoot项目中使用Groovy脚本的示例代码

    目录 1. 引入依赖 2. 使用脚本引擎运行groovy脚本 3.思考 SpringBoot+Groovy运行动态脚本 GroovyClassLoader方式 GroovyScriptEngine方式 变量绑定 最近项目中遇到了这样的需求:需要检查一个表的某些字段,是否为空,或者是否符合预期规则:比如大于0,或者在某个范围内.考虑将表名和字段名配置在数据库中,然后规则使用Groovy来写,比较灵活. 1. 引入依赖 <dependency> <groupId>org.codehau

  • SpringBoot+MyBatis+AOP实现读写分离的示例代码

    目录 一. MySQL 读写分离 1.1.如何实现 MySQL 的读写分离? 1.2.MySQL 主从复制原理? 1.3.MySQL 主从同步延时问题(精华) 二.SpringBoot+AOP+MyBatis实现MySQL读写分离 2.1.AbstractRoutingDataSource 2.2.如何切换数据源 2.3.如何选择数据源 三 .代码实现 3.0.工程目录结构 3.1.引入Maven依赖 3.2.编写配置文件,配置主从数据源 3.3.Enum类,定义主库从库 3.4.ThreadL

  • SpringBoot整合Redis实现访问量统计的示例代码

    目录 前言 Spring Boot 整合 Redis 引入依赖.增加配置 翠花!上代码 前言 之前开发系统的时候客户提到了一个需求:需要统计某些页面的访问量,记得当时还纠结了一阵子,不知道怎么去实现这个功能,后来还是在大佬的带领下借助 Redis 实现了这个功能.今天又回想起了这件事,正好和大家分享一下 Spring Boot 整合 Redis 实现访问量统计的全过程. 首先先解释一下为什么需要借助 Redis,其实原因也很简单,就是因为它非常快(每秒可执行大约110000次的 SET 操作,每

随机推荐