目录

一、Quartz介绍

二、Quartz的组成

三、使用java实现一个简单的Quartz例子

四、使用Springboot整合Quartz定时任务框架

五、使用Springboot+mybatis整合Quartz定时任务框架实现定时向数据库插入一条数据

六、总结

七、参考资料

一、Quartz介绍

quartz是一种基于java实现的任务调度框架，可以定时自动的执行你想要执行的任何任务。

quartz官网：http://www.quartz-scheduler.org/

二、Quartz的组成

任务Job（你要做什么事？）

job就是你想要实现的任务类，每一个job必须实现org.quartz.job接口。

触发器Trigger（你什么时候去做？）

Trigger为你执行任务的触发器，比如你想每天定时3点发送一份统计邮件，Trigger将会设置3点进行执行该任务。

调度器Scheduler（你什么时候需要做什么事？）

Scheduler为任务的调度器，它会将任务job及触发器Trigger整合起来，负责基于Trigger设定的时间来执行Job。

三、使用java实现一个简单的Quartz例子

1、新建一个maven项目，并引入Quartz依赖    https://mvnrepository.com/search?q=quartz

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>org.example</groupId>

    <artifactId>Quartz</artifactId>

    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <!--核心包-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

            <version>2.3.2</version>

        </dependency>

        <!--工具-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz-jobs</artifactId>

            <version>2.3.2</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>1.7.7</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

</project>

2、编写一个Job类，用来编写定时任务要做什么

package quartz.job;

import javafx.scene.chart.PieChart;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class HelloJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //输出当前时间

        Date date=new Date();

        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String dateString=dateFormat.format(date);

        //工作内容

        System.out.println("执行定时任务，时间是："+dateString);

    }

}

3、编写触发器和调度器

package quartz.job;

import org.quartz.*;

import org.quartz.impl.StdSchedulerFactory;

public class HelloSchedulerDemo {

    public static void main(String[] args) throws Exception{

        //1、调度器(Schedular)，从工厂中获取调度实例（默认：实例化new StdSchedulerFactory();)

        Scheduler scheduler= StdSchedulerFactory.getDefaultScheduler();

        //2、任务实例（JobDetail）

        JobDetail jobDetail= JobBuilder.newJob(HelloJob.class) //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口

                .withIdentity("job1","group1") //参数1：任务的名称（唯一实例）；参数2：任务组的名称

               .build();

        //3、触发器（Trigger）

        Trigger trigger= TriggerBuilder.newTrigger()

                .withIdentity("trigger1","group1") //参数1：触发器的名称（唯一实例）；参数2：触发器组的名称

                .startNow() //马上启动触发器

                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5)) //每5秒执行一次

                .build();

        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务

        scheduler.scheduleJob(jobDetail,trigger);

        //启动

        scheduler.start();

    }

}

执行结果：

四、使用Springboot整合Quartz定时任务框架

1、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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.2.3.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.springboot</groupId>

    <artifactId>Quartz</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>erp</name>

    <description>Quartz for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--导入html依赖-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-thymeleaf</artifactId>

        </dependency>

        <!--核心包-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

            <version>2.3.2</version>

            <exclusions>

                <exclusion>

                    <artifactId>slf4j-api</artifactId>

                    <groupId>org.slf4j</groupId>

                </exclusion>

            </exclusions>

        </dependency>

        <!--工具-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz-jobs</artifactId>

            <version>2.3.2</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>1.7.7</version>

           <!-- <scope>compile</scope>-->

        </dependency>

        <!--添加Scheduled坐标-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

        </dependency>

        <!--Spring tx 坐标-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-tx</artifactId>

        </dependency>

    </dependencies>

</project>

2、 job类

package quartz.job;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import java.util.Date;

public class QuartzDemo implements Job {

    @Override

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        System.out.println("Execute..."+new Date());

    }

}

3、配置类，配置触发器与任务调度器

package quartz.job;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.quartz.JobDetailFactoryBean;

import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**

 * Quartz配置类

 */

@Configuration

public class QuartzConfig {

    /**

     * 1、创建Job对象

     */

    @Bean

    public JobDetailFactoryBean jobDetailFactoryBean(){

        JobDetailFactoryBean factoryBean=new JobDetailFactoryBean();

        //关联我们自己的Job类

        factoryBean.setJobClass(QuartzDemo.class);

        return factoryBean;

    }

    /**

     * 2、创建Trigger对象

     */

    @Bean

    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){

        SimpleTriggerFactoryBean factoryBean=new SimpleTriggerFactoryBean();

        //关联JobDetail对象

        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());

        //该参数表示一个执行的毫秒数

        factoryBean.setRepeatInterval(2000); //每隔2秒执行一次

        //重复次数

        factoryBean.setRepeatCount(5);

        return factoryBean;

    }

    /**

     * 3、创建Scheduler

     */

    @Bean

    public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){

        SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();

        //关联trigger

        factoryBean.setTriggers(simpleTriggerFactoryBean.getObject());

        return factoryBean;

    }

}

4、启动类

package quartz.job;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication

@EnableScheduling

public class QuartzApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {

        SpringApplication.run(QuartzApplication.class, args);

    }

}

执行结果：

每隔2秒执行一次执行5次

五、使用Springboot+mybatis整合Quartz定时任务框架实现定时向数据库插入一条数据

IDEA项目目录结构

 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.2.3.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <groupId>com.springboot</groupId>

    <artifactId>Quartz</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>erp</name>

    <description>Quartz for Spring Boot</description>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--导入html依赖-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-thymeleaf</artifactId>

        </dependency>

        <!--核心包-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

            <version>2.3.2</version>

            <exclusions>

                <exclusion>

                    <artifactId>slf4j-api</artifactId>

                    <groupId>org.slf4j</groupId>

                </exclusion>

            </exclusions>

        </dependency>

        <!--工具-->

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz-jobs</artifactId>

            <version>2.3.2</version>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>1.7.7</version>

           <!-- <scope>compile</scope>-->

        </dependency>

        <!--添加Scheduled坐标-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

        </dependency>

        <!--Spring tx 坐标-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-tx</artifactId>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.mybatis.spring.boot</groupId>

            <artifactId>mybatis-spring-boot-starter</artifactId>

            <version>2.1.1</version>

        </dependency>

    </dependencies>

</project>

application.yml

server:

  port: 8080

spring:

  datasource:

    name: mydb

    url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Hongkong

    username: root

    password: 123456

    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:

  mapper-locations: classpath:Mapper/*.xml #注意：一定要对应mapper映射xml文件的所在路径

  type-aliases-package: com.springboot.quartz.Entity # 注意：对应实体类的路径


QuartzDemoMapper类
package com.springboot.quartz.Mapper;

import com.springboot.quartz.Entity.QuartzDemo;

import org.apache.ibatis.annotations.Insert;

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Param;

import org.springframework.stereotype.Component;

@Mapper

@Component

public interface QuartzDemoMapper {

    @Insert("insert into QuartzDemo (op_time,operation) values (#{op_time},#{operation})")

    void insertQuartzDemo(java.sql.Timestamp op_time,String operation);

    @Insert("insert into QuartzDemo_1 (operation) values (#{operation})")

    void insertQuartzDemo_1(String operation);

   /* // @Param注解的作用是给参数命名,参数命名后就能根据名字得到参数值,正确的将参数传入sql语句中

    QuartzDemo insertQuartzDemo(@Param("o_ptime") java.sql.Timestamp op_time, @Param("operation") String operation);*/

}


QuartzDemoService类
package com.springboot.quartz.Service;

import com.springboot.quartz.Mapper.QuartzDemoMapper;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

@Service

public class QuartzDemoService {

    @Autowired

    private QuartzDemoMapper quartzDemoMapper;

    public void insertQuartzDemo(java.sql.Timestamp op_time,String operation){

        quartzDemoMapper.insertQuartzDemo(op_time,operation);

    }

    public void insertQuartzDemo_1(String operation){

        quartzDemoMapper.insertQuartzDemo_1(operation);

    }

}

Job类

package com.springboot.quartz.job;

import com.springboot.quartz.Service.QuartzDemoService;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

@Component

public class QuartzDemoJob implements Job {

    static int i = 0;

    @Autowired

    private QuartzDemoService quartzDemoService;

    public QuartzDemoJob() {

    }

    @Autowired   //这里不能直接注入，因为@Autowired注入是Spring的注入，要求注入对象与被注入对象都是在SpringIOC容器中存在，

    public QuartzDemoJob(QuartzDemoService quartzDemoService) {

        this.quartzDemoService = quartzDemoService;

    }

    @Override

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        String operation = "测试" + i++;

        Date current_time = new Date();

        String strDate = dateToStr(current_time, "yyyy-MM-dd HH:mm:ss");

        java.sql.Timestamp op_time = strToSqlDate(strDate, "yyyy-MM-dd HH:mm:ss");

        quartzDemoService.insertQuartzDemo(op_time, operation);

        System.out.println(op_time + "------" + operation);

    }

    public static String dateToStr(java.util.Date date, String strFormat) {

        SimpleDateFormat sf = new SimpleDateFormat(strFormat);

        String str = sf.format(date);

        return str;

    }

    public static java.sql.Timestamp strToSqlDate(String strDate, String dateFormat) {

        SimpleDateFormat sf = new SimpleDateFormat(dateFormat);

        java.util.Date date = null;

        try {

            date = sf.parse(strDate);

        } catch (ParseException e) {

            e.printStackTrace();

        }

        java.sql.Timestamp dateSQL = new java.sql.Timestamp(date.getTime());

        return dateSQL;

    }

}

编写Job类时要注意，Job类默认是通过AdaptableJobFactory类的createJobInstance通过newInstance()反射进行实例化的，因此没有经过Spring的处理。所以QuartzDemoJob默认是不在SpringIOC容器中的，因此@Autowired注解无法在QuartzDemoJob类中直接注入到SpringIOC容器中。

注意：QuartzDemoJob类中一定要有无参构造方法，否则Job配置类中getObject()这块会报错！

因此我们需要手动的把QuartzDemoJob类注入到SpringIOC容器中。

编写一个类MyAdaptableJobFactory继承AdaptableJobFactory，覆盖createJobInstance()方法。

MyAdaptableJobFactory类

package com.springboot.quartz.Config;

import org.quartz.spi.TriggerFiredBundle;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

import org.springframework.scheduling.quartz.AdaptableJobFactory;

import org.springframework.stereotype.Component;

@Component("myadaptableJobFactory")  //将该类实例化，使得可以直接用

public class MyadaptableJobFactory extends AdaptableJobFactory {

    //AutowireCapableBeanFactory可以将一个对象添加到Spring IOC容器中，并且完成该对象注入

    @Autowired

    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    //该方法将实例化的任务对象手动的添加到SpringIOC容器中并且完成对象的注入

    @Override

    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {

        Object object = super.createJobInstance(bundle);

        //将object对象添加到Spring IOC容器中并完成注入

        this.autowireCapableBeanFactory.autowireBean(object);

        return object;

    }

}


Quartz配置类
package com.springboot.quartz.Config;

import com.springboot.quartz.job.QuartzDemoJob;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.quartz.CronTriggerFactoryBean;

import org.springframework.scheduling.quartz.JobDetailFactoryBean;

import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**

 * Quartz配置类

 */

@Configuration

public class QuartzConfig {

    /**

     * 1、创建Job对象

     */

    @Bean

    public JobDetailFactoryBean jobDetailFactoryBean(){

        JobDetailFactoryBean factoryBean=new JobDetailFactoryBean();

        //关联我们自己的Job类

        factoryBean.setJobClass(QuartzDemoJob.class);  //QuartzDemoJob的实例化并没有经过Spring的处理，

        // Spring的注入是要求注入的对象和被注入的对象都要在Spring的IOC容器中

        return factoryBean;

    }

    /**

     * 2、创建Trigger对象

     * Cron Trigger

     */

    @Bean

    public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){

        CronTriggerFactoryBean factoryBean=new CronTriggerFactoryBean();

        //关联JobDetail对象

        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());

       //设置触发时间

        //factoryBean.setCronExpression("0/2 * * * * ?");  //每2秒触发一次， 分钟，小时，天，月，星期

        factoryBean.setCronExpression("0 0-59 0-22 * * ?");  //在每天0-22点期间的每1分钟触发

        return factoryBean;

    }

    /**

     * 3、创建Scheduler

     */

    @Bean

    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean, MyadaptableJobFactory myadaptableJobFactory){

        SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();

        //关联trigger

        factoryBean.setTriggers(cronTriggerFactoryBean.getObject());

        factoryBean.setJobFactory(myadaptableJobFactory);  //调用myadaptableJobFactory把对象注入到SpringIOC容器中

        return factoryBean;

    }

}

setCronExpression()方法可以设置定时器触发时间，具体设置规则可以参考下图

图片来源：https://blog.csdn.net/fxj8291247/article/details/52329946

启动类

package com.springboot.quartz;

import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling

@SpringBootApplication

/*@MapperScan("com.springboot.quartz.Mapper")*/

public class QuartzApplication extends SpringBootServletInitializer {

    public static void main(String[] args) {

        SpringApplication.run(QuartzApplication.class, args);

    }

}

执行结果：

写入的数据库

六、总结

quartz定时任务是由Job、Trigger和Scheduler三部分组成。Job里面写定时任务的具体做什么，Trigger设定定时任务的执行时间，Scheduler则负责整个定时任务的调度。java单一使用quartz框架比较简单。如果是Spring配置quartz则要注意Job的注入问题。因为默认Job是由AdaptableJobFactory类中的createJobInstance方法进行实例化因此不会在SpringIOC中的，所以需要覆盖AdaptableJobFactory类中的createJobInstance方法，手动将Job对象注入到SpringIOC容器中。

七、参考资料

https://www.bilibili.com/video/BV19t41127de?from=search&seid=2343824906917884403

https://www.bilibili.com/video/BV1mE411F7NJ?p=6

https://blog.csdn.net/fxj8291247/article/details/52329946

https://bbs.csdn.net/topics/360004856

https://blog.csdn.net/u012373815/article/details/86740625

https://blog.csdn.net/womeng2009/article/details/80328544

java定时任务Quartz整理的更多相关文章

  1. Java定时任务Quartz

    第一步:pom文件中添加依赖包 第二步:创建xml文件,名称为:spring-scheduler 路径如下图: 第三步:spring-scheduler配置详情 <!--创建任务--> & ...

  2. java定时任务Quartz Demo(2.X)

    直接上代码 public class HelloQuartz implements Job{ @Override public void execute(JobExecutionContext Jec ...

  3. atititt.java定时任务框架选型Spring Quartz 注解总结

    atititt.java定时任务框架选型Spring Quartz 总结 1. .Spring Quartz  (ati recomm) 1 2. Spring Quartz具体配置 2 2.1. 增 ...

  4. [转][JAVA]定时任务之-Quartz使用篇

    [BAT][JAVA]定时任务之-Quartz使用篇 定时任务之-Quartz使用篇 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与 ...

  5. Quartz实现JAVA定时任务的动态配置

    什么是动态配置定时任务? 首先说下这次主题,动态配置.没接触过定时任务的同学可以先看下此篇:JAVA定时任务实现的几种方式 定时任务实现方式千人千种,不过基础的无外乎 1.JDK 的Timer类 2. ...

  6. Java生鲜电商平台-定时器,定时任务quartz的设计与架构

    Java生鲜电商平台-定时器,定时任务quartz的设计与架构 说明:任何业务有时候需要系统在某个定点的时刻执行某些任务,比如:凌晨2点统计昨天的报表,早上6点抽取用户下单的佣金. 对于Java开源生 ...

  7. Java 定时任务的几种实现方式

    JAVA实现定时任务的几种方式 @(JAVA)[spring|quartz|定时器]  近期项目开发中需要动态的添加定时任务,比如在某个活动结束时,自动生成获奖名单,导出excel等,此类任务由于活动 ...

  8. java 多线程——quartz 定时调度的例子

    java 多线程 目录: Java 多线程——基础知识 Java 多线程 —— synchronized关键字 java 多线程——一个定时调度的例子 java 多线程——quartz 定时调度的例子 ...

  9. spring学习总结(mybatis，事务，测试JUnit4，日志log4j&slf4j，定时任务quartz&spring-task，jetty，Restful-jersey等)

    在实战中学习,模仿博客园的部分功能.包括用户的注册,登陆:发表新随笔,阅读随笔:发表评论,以及定时任务等.Entity层设计3张表,分别为user表(用户),essay表(随笔)以及comment表( ...

  10. 这是一套Java菜鸟到大牛的学习路线之高级教程，由工作了10年的资深Java架构师整理。

    这是一套Java菜鸟到大牛的学习路线之高级教程,由工作了10年的资深Java架构师整理.        01-java高级架构师设计-基础深入        J2SE深入讲解        Java多 ...

随机推荐

  1. 文件管理工具“三剑客” #Everything #SpaceSniffer #Clover

    前言: 本文收集了我日常使用的三个文件管理工具: 文件搜索神器--Everything 磁盘文件占用分析工具--SpaceSniffer 文件资源管理器--Clover 下面我从工具解决的痛点和使用技 ...

  2. 洛谷P1036 [NOIP2002 普及组] 选数 （搜索）

    n个数中选取k个数,判断这k个数的和是否为质数. 在dfs函数中的状态有:选了几个数,选的数的和,上一个选的数的位置: 试除法判断素数即可: 1 #include<bits/stdc++.h&g ...

  3. leetcode刷题记录之25（集合实现）

    题目描述: 给你链表的头节点 head ,每 k 个节点一组进行翻转,请你返回修改后的链表. k 是一个正整数,它的值小于或等于链表的长度.如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原 ...

  4. jsp页面重定向后地址栏controller名重复而导致报404错误

    今天做ssm项目时遇到了这种错误 看看代码: 无关代码省略... 22 <body> 23 <div id="container"> 24 <ifra ...

  5. java集合框架复习----（4）Map、List、set

    文章目录 五.Map集合[重要] 1.hashMap 六.Collections工具类 总结 集合的概念 List集合 set集合: Map集合 Collection 五.Map集合[重要] 特点: ...

  6. LcdTools如何实现PX01读取SD中BIN文件并通过端口发出去

    在实际应用中我们会碰到需要下载很大容量固件,比如TP固件几百K大小BIN文件,这种情况下用LcdTools写初始化代码的方式实现就不大现实:此时我们可以通过PX01 SD来实现. 首先,把需要操作的B ...

  7. loguru库使用

    参考: https://github.com/Delgan/loguru https://loguru.readthedocs.io/en/stable/overview.html https://b ...

  8. Crond服务+Shell实现秒级任务

    服务 [root@19-v1-centos-6 ~]# chkconfig --list | grep crond crond 0:off 1:off 2:on 3:on 4:on 5:on 6:of ...

  9. C温故补缺(十二):预编译器与头文件

    预编译器 预编译器就是之前学的预编译指令的执行者 gcc -E test.c -o test.i 生成预编译文件就是翻译#指令 比如#include<stdio.h>就是把整个stdio. ...

  10. PP视频(PPTV聚力)web接口分析

    前言 前几天我想看一个番剧, 正好搜索到了 PP视频,我才知道PP视频就是PPTV聚力,我想把番剧下载下来,结果发现视频竟然不是m3u8格式,而是多段mp4,所以简单的写了个脚本,可以在不登录的情况下 ...