cpdiem
cpdiem

一个简单Quartz微服务————良好扩展性（springcloud,集群）

一、背景介绍

    项目早期为单体应用，近期因业务量上涨，架构逐渐转为springcloud+分布式集群。原先项目中的定时任务主要采用@Scheduled注解方式实现，并且因历史原因，分布散乱，管理不便。@Scheduled注解的定时任务无法直接应用于集群环境，并且服务重启或异常时，任务容易丢失。Quartz支持对数据的持久化，并且有misfire机制，任务不易丢失，同时支持集群设置，分离出的定时任务可独立为微服务应用，扩展性好。

二、代码实现

  1. 添加maven依赖 
    

   4.0.0

   com.cpdiem.demo
   quick-quartz
   0.0.1-SNAPSHOT
   jar

   quick-quartz
   Demo project for Spring Boot

   
      org.springframework.boot
      spring-boot-starter-parent
      2.1.1.RELEASE
       
   

   
      UTF-8
      UTF-8
      1.8
   

   
      
         org.springframework.boot
         spring-boot-starter
      

      
         org.springframework.boot
         spring-boot-starter-test
         test
      

      
         junit
         junit
         4.12
         test
      

      
      
         org.springframework.boot
         spring-boot-starter-data-jpa
      

      
      
         org.springframework.boot
         spring-boot-starter-web
      

      
      
         mysql
         mysql-connector-java
      

      
      
         org.springframework.boot
         spring-boot-starter-jdbc
      

      
      
         org.quartz-scheduler
         quartz
         2.3.0
      
      
         org.quartz-scheduler
         quartz-jobs
         2.3.0
      
      
         org.springframework
         spring-context-support
      

      
      
         com.alibaba
         druid
         1.1.3
      

      
      
         hikari-cp
         hikari-cp
         2.6.0
      

      
      
         org.springframework.boot
         spring-boot-starter-data-redis
         2.1.1.RELEASE
      

      
         com.alibaba
         fastjson
         1.2.47
      

   

   
      
         
            org.springframework.boot
            spring-boot-maven-plugin
  2. 执行Quartz相关表入数据库（quick-quartz\quartz-tables.log） 
    DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);


commit;
  3. 添加应用配置（quick-quartz\src\main\resources\application.yml） 
    server:
  port: 8088
spring:
  application:
    name: quick-quartz
    datasource:
#      type: com.zaxxer.hikari.HikariDataSource
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&userSSL=false&serverTimezone=GMT
      username: root
      password: root
      hikari:
        #
        minimum-idle: 5
        #
        idle-timeout: 180000
        #
        maximum-pool-size: 10
        aoto-commit: true
        pool-name: MyHikariCP
        connection-timeout: 30000


    jpa:
      hibernate:
        #ddl-auto: create 
        ddl-auto: update 
      show-sql: true

  redis:
    database: 0
    host: localhost
    port: 6379
    password:
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    timeout: 5000
  4. 添加Quartz配置文件（quick-quartz\src\main\resources\config\quartz.properties）                                                                 配置说明可参考官方文档 http://www.quartz-scheduler.org/documentation/quartz-2.2.x/configuration/                                   w3cschool亦有中文版翻译 https://www.w3cschool.cn/quartz_doc/quartz_doc-i7oc2d9l.html 
    org.quartz.scheduler.instanceName = quartzScheduler  
org.quartz.scheduler.instanceId = AUTO  


org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_  
org.quartz.jobStore.isClustered = true  
org.quartz.jobStore.useProperties = false
org.quartz.jobStore.clusterCheckinInterval = 20000    


org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool  
org.quartz.threadPool.threadCount = 10  
org.quartz.threadPool.threadPriority = 5  
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
  5. 添加触发器配置文件（quick-quartz\src\main\resources\config\timers.properties） 
    quartz.timer1=0/15 * * * * ?

quartz.timer2=0 0/2 * * * ?

quartz.timer3=0/30 * * * * ?
  6. 配置文件工具类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\utils\PropertiesUtils.java） 
    package com.cpdiem.demo.quickquartz.utils;

import com.alibaba.fastjson.util.TypeUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class PropertiesUtils extends PropertyPlaceholderConfigurer {

    private static Map ctxPropertiesMap;

    /**
     * 重写processProperties方法
     */
    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
            throws BeansException {
        super.processProperties(beanFactoryToProcess, props);
        ctxPropertiesMap = new HashMap();
        for (Object key : props.keySet()) {
            String keyStr = key.toString();
            String value = props.getProperty(keyStr);
            ctxPropertiesMap.put(keyStr, value);
        }
    }

    public static String getProperty(String key) {
        return TypeUtils.castToString(ctxPropertiesMap.get(key));
    }

    public static Object getObject(String key, Class clazz) {
        Object obj = getProperty(key);
        return TypeUtils.castToJavaBean(obj, clazz);
    }

    public static Boolean getBoolean(String key) {
        Object value = getProperty(key);
        if (value == null)
            return null;
        else
            return TypeUtils.castToBoolean(value);
    }

    public static byte[] getBytes(String key) {
        Object value = getProperty(key);
        if (value == null)
            return null;
        else
            return TypeUtils.castToBytes(value);
    }

    public static boolean getBooleanValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return false;
        else
            return TypeUtils.castToBoolean(value).booleanValue();
    }

    public static Byte getByte(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToByte(value);
    }

    public static byte getByteValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0;
        else
            return TypeUtils.castToByte(value).byteValue();
    }

    public static Short getShort(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToShort(value);
    }

    public static short getShortValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0;
        else
            return TypeUtils.castToShort(value).shortValue();
    }

    public static Integer getInteger(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToInt(value);
    }

    public static int getIntValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0;
        else
            return TypeUtils.castToInt(value).intValue();
    }

    public static Long getLong(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToLong(value);
    }

    public static long getLongValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0L;
        else
            return TypeUtils.castToLong(value).longValue();
    }

    public static Float getFloat(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToFloat(value);
    }

    public static float getFloatValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0.0F;
        else
            return TypeUtils.castToFloat(value).floatValue();
    }

    public static Double getDouble(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToDouble(value);
    }

    public static double getDoubleValue(String key) {
        Object value = getProperty(key);
        if (value == null)
            return 0.0D;
        else
            return TypeUtils.castToDouble(value).doubleValue();
    }

    public static BigDecimal getBigDecimal(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToBigDecimal(value);
    }

    public static BigInteger getBigInteger(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToBigInteger(value);
    }

    public static String getString(String key) {
        Object value = getProperty(key);
        if (value == null)
            return null;
        else
            return value.toString();
    }

    public static Date getDate(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToDate(value);
    }

    public static java.sql.Date getSqlDate(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToSqlDate(value);
    }

    public static Timestamp getTimestamp(String key) {
        Object value = getProperty(key);
        return TypeUtils.castToTimestamp(value);
    }


}
  7. redis工具类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\utils\RedisUtils.java） 
    package com.cpdiem.demo.quickquartz.utils;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.Set;

@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @param key 键
     * @return 移除的个数
     */
    public long setRemove(String key,Object... objects) {
        try {
            Long count = redisTemplate.opsForSet().remove(key,objects);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


}
 
      
   
  8. 任务实现类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\Jobs\Job1.java                                                     quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\Jobs\Job2.java） 
    
     
    
     
     
    package com.cpdiem.demo.quickquartz.Jobs;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定时调度任务Job1.
 *
 *
 */
@Component
public class Job1 extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
        System.out.println("@@@@@@@@@@@@        "+(new SimpleDateFormat("yyyy-mm-dd HH:mm:ss.SSSSSS")).format(new Date())+"         @@@@@@@@@@@");
        System.out.println("@@@@@@@@@@@@@@@@@@@@@@@        Job1         @@@@@@@@@@@@@@@@@@@@@@");
        System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
        System.out.println();
    }
}

     
     
    package com.cpdiem.demo.quickquartz.Jobs;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定时调度任务Job2.
 *
 */
public class Job2 extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("==================================================================");
        System.out.println("===========        "+(new SimpleDateFormat("yyyy-mm-dd HH:mm:ss.SSSSSS")).format(new Date())+"         ============");
        System.out.println("=======================        Job2         ======================");
        System.out.println("==================================================================");
        System.out.println();
    }
}

     
    
     
     
     
    9.  
   
  9. redis配置类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\config\RedisConfig.java） 
    
     
    
     
     
    package com.cpdiem.demo.quickquartz.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public class RedisConfig {


    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate template = new RedisTemplate();

        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式

        template.setKeySerializer(stringRedisSerializer);

        // hash的key也采用String的序列化方式

        template.setHashKeySerializer(stringRedisSerializer);

        // value序列化方式采用jackson

        template.setValueSerializer(jackson2JsonRedisSerializer);

        // hash的value序列化方式采用jackson

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;

    }
}

     
    
     
    10.  
   
  10. 任务调度类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\config\QuartzSchedulerConfig.java） 
    
     
    
     
     
    package com.cpdiem.demo.quickquartz.config;


import com.cpdiem.demo.quickquartz.Jobs.Job1;
import com.cpdiem.demo.quickquartz.Jobs.Job2;
import com.cpdiem.demo.quickquartz.utils.PropertiesUtils;
import com.cpdiem.demo.quickquartz.utils.RedisUtils;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;


import javax.sql.DataSource;
import java.io.IOException;
import java.util.Properties;

/**
 * Quartz调度配置类。
 *
 *
 */
@Configuration
public class QuartzSchedulerConfig {

    @Autowired
    private DataSource dataSource;
    @Autowired
    private RedisUtils redisUtils;

    private static final Logger Logger = LoggerFactory.getLogger(QuartzSchedulerConfig.class);
    private static final String QUARTZ_PROPERTIES_NAME = "/config/quartz.properties";

    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, Trigger[] triggers, JobDetail[]
            jobDetails) {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        try {
            factoryBean.setQuartzProperties(quartzProperties());
            factoryBean.setDataSource(dataSource);
            factoryBean.setJobFactory(jobFactory);
            factoryBean.setTriggers(triggers);
            factoryBean.setJobDetails(jobDetails);
            factoryBean.setOverwriteExistingJobs(true);
            factoryBean.setStartupDelay(10);
            factoryBean.setWaitForJobsToCompleteOnShutdown(true);
        } catch (Exception e) {
            Logger.error("加载 {} 配置文件失败.", QUARTZ_PROPERTIES_NAME, e);
            throw new RuntimeException("加载配置文件失败", e);
        }
        tempSetTriggers(triggers);
        return factoryBean;
    }

    void tempSetTriggers(Trigger[] triggers){
        if(triggers.length>0){
            for(Trigger trigger : triggers){
                redisUtils.sSet("Triggers",trigger.getKey().getName());
            }
        }
    }


    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource(QUARTZ_PROPERTIES_NAME));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

        private transient AutowireCapableBeanFactory beanFactory;

        @Override
        public void setApplicationContext(final ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }

        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle)
                throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    }

    @Bean(name = "job1Trigger")
    public CronTriggerFactoryBean job1Trigger(@Qualifier("job1Detail") JobDetail jobDetail) {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(jobDetail);
        cronTriggerFactoryBean.setCronExpression(PropertiesUtils.getProperty("quartz.timer1"));
        cronTriggerFactoryBean.setGroup("first");
        cronTriggerFactoryBean.setName("job1Trigger");
        return cronTriggerFactoryBean;
    }

    @Bean(name = "job1Detail")
    public JobDetailFactoryBean job1Detail() {
        JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
        jobDetailFactoryBean.setJobClass(Job1.class);
        jobDetailFactoryBean.setDurability(true);
        return jobDetailFactoryBean;
    }

    @Bean(name = "job2Trigger")
    public CronTriggerFactoryBean job2Trigger(@Qualifier("job2Detail") JobDetail jobDetail) {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(jobDetail);
        cronTriggerFactoryBean.setCronExpression(PropertiesUtils.getProperty("quartz.timer2"));
        return cronTriggerFactoryBean;
    }

    @Bean(name = "job2Detail")
    public JobDetailFactoryBean job2Detail() {
        JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
        jobDetailFactoryBean.setJobClass(Job2.class);
        jobDetailFactoryBean.setDurability(true);
        return jobDetailFactoryBean;
    }

//    @Bean(name = "job3Trigger")
//    public CronTriggerFactoryBean job3Trigger(@Qualifier("job1Detail") JobDetail jobDetail) {
//        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
//        cronTriggerFactoryBean.setJobDetail(jobDetail);
//        cronTriggerFactoryBean.setCronExpression(PropertiesUtils.getProperty("quartz.timer3"));
//        return cronTriggerFactoryBean;
//    }


}

     
    
     
    11.  
   
  
    任务辅助类（quick-quartz\src\main\java\com\cpdiem\demo\quickquartz\service\JobTaskService.java）
     
  
     
  
     
   
    package com.cpdiem.demo.quickquartz.service;

import com.cpdiem.demo.quickquartz.utils.RedisUtils;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Component
public class JobTaskService {

    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    @Autowired
    private RedisUtils redisUtils;

    @PostConstruct
    private void updateJobTaskBeforeStarting(){

        Set hashSet = new HashSet();
        Set set = redisUtils.sGet("Triggers");
        if(set!=null && set.size()>0){
            for(Object obj : set){
                hashSet.add((String)obj);
            }
        }

        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        Set jobKeySet = null;
        try {
            jobKeySet = scheduler.getJobKeys(GroupMatcher.anyGroup());
            if(jobKeySet != null && jobKeySet.size()>0) {
                for (JobKey jk : jobKeySet) {
                    List triggers = (List) scheduler.getTriggersOfJob(jk);
                    if (triggers != null && triggers.size() > 0) {
                        for (Trigger trigger : triggers) {
                            if(!hashSet.contains(trigger.getKey().getName())){
                                scheduler.unscheduleJob(trigger.getKey());
                            }

                        }
                    }
                }
            }
            redisUtils.setRemove("Triggers",hashSet.toArray());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

     
  
     
  
    启动类
     
  
     
   
    @SpringBootApplication
public class QuickQuartzApplication {

   public static void main(String[] args) {
      ConfigurableApplicationContext configurableApplicationContext =SpringApplication.run(QuickQuartzApplication.class, args);
      configurableApplicationContext.getEnvironment();
   }

   @Bean
   public PropertiesUtils PropertiesUtils(){
      PropertiesUtils propertiesUtils = new PropertiesUtils();
      propertiesUtils.setLocation(new ClassPathResource("/config/timers.properties"));
      return propertiesUtils;
   }
}
     
  
     
  
     
  
    三、简要说明
     
  
    factoryBean.setOverwriteExistingJobs(true);
     
  
    该参数默认值为false。当应用启动时，quartz不会更新相关数据库表中的数据（如cron表达式，任务下次执行时间等等），调度器将根据数据库原有数据信息执行任务。
     
  
    该参数设为true时，数据库数据会被重新设置。如果应用重启、宕机期间有任务错过，将不触发misfire。
     
  
    quartz在创建完scheduler时，会同时维护数据库及本次应用创建的任务，也就是说quartz只会进行新增、更新操作，不会执行删除操作。因此，对于不再使用的触发器，需自行手动删除（任务辅助类JobTaskService存在的意义，当然它可以做得更多）。
     
  
    factoryBean.setStartupDelay(10);
     
  
    设置调度中心在应用启动后n秒后开始运行。
     
  
    factoryBean.setWaitForJobsToCompleteOnShutdown(true);
     
  
    该参数用于设置当服务正常关闭时，会等所有任务执行完毕后再行关闭。但仍存在不正常关闭的bug。
     
  
     
     
  
    四、参考资料
     
  
       
   
    1. quartz API  http://www.quartz-scheduler.org/api/2.2.1/index.html
      2.  
   
    2. spring API  https://docs.spring.io/spring/docs/4.3.0.BUILD-SNAPSHOT/javadoc-api/
      3.  
   
    3. 简单 Quartz-Cluster 微服务  https://blog.csdn.net/ylimh_hmily/article/details/78825329#comments
      4.  
   
    4. quartz （从原理到应用）详解篇  https://my.oschina.net/songhongxu/blog/802574
      5.  
  
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(quartz)
    
        
    
            
    
                
      
                    
    • .NetCore里使用定时任务
                        AitTech
.netcorec#
                        
      在.NETCore中，实现定时任务可以通过多种方式，包括使用内置的System.Threading.Timer、System.Timers.Timer，或者更高级、更灵活的库，如Hangfire、Quartz.NET或.NETCore3.0及以上版本引入的IHostedService和BackgroundService。这里主要介绍IHostedService和BackgroundService的
      
                    
      • 
                    
    • Spring Task
                        Tdm_888
Springspringjava
                        
      1.简介SpringTask是Spring框架自带的任务调度工具，不需要引入额外的依赖包，可以直接在Spring项目中使用。它支持注解来定义定时任务，适用于任务调度较少的场景。2.特点轻量级：SpringTask是Spring框架自带的，不需要额外的依赖包，相比Quartz更加轻量级。简单易用：通过在方法上添加@Scheduled注解，即可实现定时任务的调度，非常简单易用。支持多种调度方式：Spr
      
                    
      • 
                    
    • Quartz.net-IJobFactory实现任务实例创建的依赖注入
                        tanzhenyuan
Quartz.net
                        
      在使用Quartz.net执行调度任务时，任务类必须实现IJob接口，如下`publicclassDLLExecutor:IJob{publicasyncTaskExecute(IJobExecutionContextcontext){//你的处理逻辑}}`具备如上任务类之后，需要做的就是与JobDetial、Trigger进行关联，为了精简，忽略JobDetial、Trigger相关属性设置,代
      
                    
      • 
                    
    • Quartz .Net 配置以及Job使用依赖注入
                        FuSh1
.NetCorec#
                        
      使用扩展函数的方式在“Util”中进行配置，在WebHost/Host中进行使用。Util中的配置操作在Host中进行使用Host中的DefaultJobFactory以及QuartzJobUtil中的配置操作publicstaticIServiceCollectionConfigureQuartz(thisIServiceCollectioncollection,Listjobs,IJobFac
      
                    
      • 
                    
    • Quartz.Net(2)——NetCore3.1整合Quartz.Net
                        contact97
.Net定时框架Quartz.NetNetCore
                        
      在上篇文章中Quartz.Net(1)已经介绍了Quartz.Net的基本运用，该篇文章中将主要介绍NetCore3.1如何整合Quartz.Net，在后台运行定时job，并运用到上篇文章讲到的介绍点。1导入Nuget包Quartz定时框架Quartz.Extensions.DependencyInjection用于在任务中导入其他的服务，整合使用NetCore的依赖注入框架Quartz.Exte
      
                    
      • 
                    
    • Quartz.Net_错过策略
                        Mudrock__
Quartz.Netquartz.net
                        
      SimpleTrigger的Misfire策略：FireNow：立即执行一次，然后按计划执行（忽略Misfire）IgnoreMisfirePolicy：忽略Misfire，按原计划继续执行RescheduleNowWithExistingRepeatCount：立即执行一次，然后根据当前时间、执行间隔、余下重复次数（含错过次数）重新安排后续的执行后续执行次数=原总次数-已执行次数总次数=原总次数
      
                    
      • 
                    
    • Quartz.Net_持久化
                        Mudrock__
Quartz.Net.netquartz.net
                        
      简述通常而言，Quartz.Net的数据默认是存储在运存中的，换言之：断电即失。所以在默认情况下，当系统重启后，原先的所有任务、触发器、调度器都会失效为避免上述情况的发生，可以对Quartz.Net进行持久化设置，令数据储存在DB中解决方式1.安装依赖（以MySQL为例）问：为什么需要同时安装MySql.Data与Pomelo.EntityFrameworkCore.MySql？答：因为我本人平时
      
                    
      • 
                    
    • Quartz.Net_侦听触发器
                        Mudrock__
Quartz.Net.netquartz.net
                        
      简述触发器执行任务时存在数个阶段，利用侦听器可以在对应的阶段执行一些代码如何侦听1.实现ITriggerListener接口，并实现其函数，具体说明见代码注释publicclassDeleteAfterCompleted:ITriggerListener{publicstringName=>"X";//触发时publicasyncTaskTriggerFired(ITriggertrigger,I
      
                    
      • 
                    
    • SpringBoot集成Quartz发布、修改、暂停、删除定时任务
                        缓慢移动的蜗牛

                        
      一、基本概念Quartz核心的概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节。scheduler任务调度：是最核心的概念，需要把JobDetail和Trigger注册到scheduler中，才可以执行。Job任务：其实Job是接口，其中只有一个execute方法：Trigger触发器a)作用:它是来执行工作任务，在什么条件下触发，什么时间执行，多久执
      
                    
      • 
                    
    • mysql创建quartz定时任务相关表sql
                        提高记忆力
mysqlsql
                        
      DROPTABLEIFEXISTSQRTZ_FIRED_TRIGGERS;DROPTABLEIFEXISTSQRTZ_PAUSED_TRIGGER_GRPS;DROPTABLEIFEXISTSQRTZ_SCHEDULER_STATE;DROPTABLEIFEXISTSQRTZ_LOCKS;DROPTABLEIFEXISTSQRTZ_SIMPLE_TRIGGERS;DROPTABLEIFEXISTS
      
                    
      • 
                    
    • 22条茶叶大数据告诉你：喝茶的重要性
                        议磊

                        
      但是，您知道茶与癌症的关系吗？这些都是真实的数据！喝茶前，务必看看这些震撼的事实吧！1、160个国家地区，30亿人爱喝茶目前全球有160多个国家与地区近30亿人喜欢饮茶，这意味着每经过四个国家就有三个国家喜欢饮茶，每认识5个人里面有2个人喝茶。2、中国年产茶200万吨，人均喝茶566g2019年，中国总产茶量超200万吨，是全球第一产茶大国，占全球产量39.4%。然并卵，Quartz网站统计中国人
      
                    
      • 
                    
    • 周期性任务线程池 - ScheduledThreadPoolExecutor & DelayedWorkQueue
                        weixin_44612246
java开发语言
                        
      今天要复习一下线程池，这同样是很久以前的一篇文章，格式不对所以看起来太难受，所有修改格式，重新发一下。ScheduledThreadPoolExecutor是ThreadPoolExecutor的扩展类，用来实现延迟执行的任务、或者周期性执行的任务。一般来讲，周期性任务或者定时任务包含两大组件：一个是执行任务的线程池，一个是存储任务的存储器。还记得Quartz吗？企业级定时任务框架，最重要的内容其
      
                    
      • 
                    
    • Springboot(-) Quartz定时任务cron表达式详解
                        charles_lun
Java菜鸟到老鸟的蜕变之路
                        
      目录前言正文1.cron表达式组成2.子表达式范围3.子表达式格式4.字符含义5.表达式例子结束语前言在做springboot整合Quartz的时候，看到指导手册里推荐用cron表达式，然后抱着试试看的态度，额，刚一上手，感觉又回到了正则表达式的恐惧之中，乱，晕，硬着头皮看，终于看完了，有了一定的理解，赶紧整理记录下来，方便自己查看，也方便新接触的同学理解。正文1.cron表达式组成cron表达式
      
                    
      • 
                    
    • Spring Boot 集成 Quartz 实现定时任务
                        猿泰山
springboot后端java
                        
      SpringBoot集成Quartz实现定时任务在SpringBoot应用中，我们经常需要执行一些定时任务，如每天发送报表、定时更新数据库等。虽然SpringFramework自带了一个简单的定时任务功能（@Scheduled），但在一些复杂场景下，我们可能需要更强大的定时任务框架，这时Quartz就是一个很好的选择。Quartz是一个开源的作业调度框架，它允许你以非常灵活的方式定义任务执行的时间
      
                    
      • 
                    
    • Springboot+Quartz集群配置
                        langzitianya
SpringBootJAVAquartz集群springboot
                        
      看了一些网上的文章，都不太合我意，集众家之长，来个自己的版本。原理和介绍就不搬来搬去了，直接上代码吧。目录一.POM文件二.application-quartz.properties三.java文件3.1Application3.2QuartzSchedulerConfig配置一下，类名自己随便改3.3StartApplicationListener应用启动时调用一下QuartzTasks添加定时
      
                    
      • 
                    
    • Springboot2.6整合Quartz2.3.2找不到数据源问题记录
                        lzh_me
知新springboot2.6quartz多数据源
                        
      PS：问题没有彻底解决，先记录一下。问题产生原因是springboot版本问题，具体原因需要再找。（或许是quartz的配置方式变了）版本：springboot2.6.0，quartz2.3.2用的都是默认配置，没什么改动。以下是pom.xml里面的，贴出来参考。org.springframework.bootspring-boot-starter-parent2.6.0org.springfra
      
                    
      • 
                    
    • Java中三种定时任务总结（schedule，quartz，xxl-job）
                        林隐w
javajava定时任务调度
                        
      目录1、Spring框架的定时任务2、QuartzQuartz的用法3、xxl-job3.1docker安装xxl-job3.2xxl-job编程测试补充：Java中自带的定时任务调度1.java.util.Timer和java.util.TimerTask2.java.util.concurrent.Executors和java.util.concurrent.ScheduledExecutor
      
                    
      • 
                    
    • Quartz---串行执行、JobDataMap持久化
                        杜小白也想的美
javaQuartz
                        
      1.Quartz串行执行在Quartz中，作业（Job）默认是以并行方式执行的，这意味着如果调度器（Scheduler）有多个线程可用，并且满足触发条件，那么多个作业可能会同时执行。然而，有时候我们可能希望作业以串行方式执行，即一个接一个地执行，而不是同时执行。实例记录每个任务执行间隔代码packagejob;importorg.quartz.Job;importorg.quartz.JobExe
      
                    
      • 
                    
    • Quartz---Springboot项目整合Quartz---实现内存、数据库持久化
                        杜小白也想的美
springbootjava后端Quartz
                        
      1.SpringBoot整合Quartz使用内存持久化1.1.什么是内存持久化Quartz的内存持久化是指Quartz框架在默认情况下将任务调度的运行信息保存在内存中。这种方式的优点是可以提供最佳的性能，因为内存中数据访问最快。然而，内存持久化的缺点是缺乏数据的持久性。当程序停止或系统崩溃时，所有运行的信息都会丢失。1.2.步骤如下1.2.1.添加依赖首先，在pom.xml文件中添加Quartz的
      
                    
      • 
                    
    • Quartz---JobDataMap使用的两种方式
                        杜小白也想的美
javaquartz
                        
      任务调度执行原理图：JobDataMap的使用JobDataMap是Quartz调度器中的一个重要组件，主要用于存储和传递与作业（Job）相关的数据。它是一个实现了JavaMap接口的对象，可以用来保存一系列的序列化的对象。这些对象在作业执行时可以被获取并使用。JobDataMap的主要特点包括：它可以存储任何可以序列化的数据对象。这意味着你可以将任何类型的对象（只要它们可以被序列化）放入JobD
      
                    
      • 
                    
    • Springboot整合第三方技术-任务(Quartz、Task)
                        程序员老茶
JAVA#SpringBootspringbootjava后端
                        
      作者简介：练习时长两年半的Javaup主个人主页：程序员老茶ps:点赞是免费的，却可以让写博客的作者开心好久好久系列专栏：Java全栈，计算机系列（火速更新中）格言：种一棵树最好的时间是十年前，其次是现在动动小手，点个关注不迷路，感谢宝子们一键三连目录课程名：Java内容/作用：知识点/设计/实验/作业/练习学习：Springboot整合第三方技术Springboot整合第三方技术-任务Quart
      
                    
      • 
                    
    • Quartz 概览
                        Rawburn

                        
      QuartzEnterpriseJobScheduler什么是Quartz作业调度库？Quartz是一个功能丰富的开源作业调度库，几乎可以集成在任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数十，数百甚至数万个作业;将任务定义为标准Java组件的作业，这些组件可以执行几乎任何可以编程的程序。QuartzScheduler包含许多企业
      
                    
      • 
                    
    • springboot @Scheduled实现定时任务，@EnableAsync，@Async异步任务
                        小哇666
#springboot
                        
      实现定时任务的方式有如下几种，本文使用的是每3种1、常见定时任务Java自带的java.util.Timer类timer:配置比较麻烦，时间延后问题timertask:不推荐2、Quartz框架配置更简单xml或者注解3、SpringBoot使用注解方式开启定时任务1）启动类里面@EnableScheduling开启定时任务，自动扫描2）定时任务业务类加注解@Component被容器扫描3）定时执
      
                    
      • 
                    
    • 领略Quartz源码架构之美——源码实弹之运行过程(四)
                        向光奔跑_

                        
      本章阅读收获:可了解Quartz框架中的正式开始运行部分源码继上节内容上面我们讲到了QuartzSchedulerThread中run方法的第一小部分，下面我们继续来进行分析。QuartzSchedulerThread中run方法后续分析if(triggers!=null&&!triggers.isEmpty()){now=System.currentTimeMillis();//这里为什么tri
      
                    
      • 
                    
    • SpringBoot-ElasticJob封装快速上手使用(分布式定时器)
                        Purgeyao

                        
      elastic-job-spring-bootqq交流群:8123213711简介Elastic-Job是一个分布式调度解决方案，由两个相互独立的子项目Elastic-Job-Lite和Elastic-Job-Cloud组成。Elastic-Job-Lite定位为轻量级无中心化解决方案，使用jar包的形式提供分布式任务的协调服务。基于quartz定时任务框架为基础的，因此具备quartz的大部分功
      
                    
      • 
                    
    • 一个好用的设置所有网页成暗黑背景的 Chrome 扩展
                        

                        
      图1是SAPFiori3.0时代的暗黑风格主题QuartzDark，图2是我写过的一篇如何在自己开发的SAPUI5应用里启用这个暗黑主题的文章。在实际使用过程中，很多朋友都希望将浏览器网页的背景也从默认的白色更改成黑色。这个需求无法通过Windows操作系统本身的系统设置来完成。我曾经在ChromeWebStore里试图找到一款能够设置网页背景色的扩展，发现这种扩展虽然不少，但有的效果不能让我满意
      
                    
      • 
                    
    • SpringBoot整合Quartz
                        #看心情
springbootjavaspring
                        
      添加依赖org.springframework.bootspring-boot-starter-quartz配置quartz属性spring.quartz.properties.org.quartz.scheduler.instanceName=mySchedulerspring.quartz.properties.org.quartz.scheduler.instanceId=AUTOsprin
      
                    
      • 
                    
    • quartznet任务调度和消息调度（JAVA与C#版对比）
                        管理大亨
技术
                        
      quartznet任务调度和消息调度1.作用自动执行任务。2.下载地址NET版本JAVA版本1下载http://quartznet.sourceforge.net/download.htmlhttp://opensymphony.com/quartz2工具VisualStudio2008/2010打开3概念调度器和作业调度器、任务和触发器1）作业是一个执行任务的简单.NET类。任务可以是任何C#\
      
                    
      • 
                    
    • RuoYi模块功能分析：第八章定时任务
                        真让人秃头呀
Java开发专栏java开发语言
                        
      系列文章目录文章目录系列文章目录引入依赖一、AbstractQuartzJob类二、QuartzJobExecution类三、QuartzDisallowConcurrentExecution类四、JobInvokeUtil类五、CronUtils类六、ScheduleUtils类引入依赖org.quartz-schedulerquartzcom.mchangec3p0一、AbstractQuar
      
                    
      • 
                    
    • 晶振工作原理详解
                        芒果520
硬件设计arm嵌入式硬件
                        
      晶振是石英晶体谐振器（quartzcrystaloscillator）的简称，也称有源晶振，它能够产生中央处理器（CPU）执行指令所必须的时钟频率信号，CPU一切指令的执行都是建立在这个基础上的，时钟信号频率越高，通常CPU的运行速度也就越快。只要是包含CPU的电子产品，都至少包含一个时钟源，就算外面看不到实际的振荡电路，也是在芯片内部被集成，它被称为电路系统的心脏。如下图所示的有源晶振，在外部施
      
                    
      • 
                                
    • JAVA基础
                                    灵静志远
位运算加载Date字符串池覆盖
                                    
      一、类的初始化顺序 
1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器 
 同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。 
 
二、String 
1 String a = "abc"; 
 JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
      
                                
      • 
                                
    • keepalived实现redis主从高可用
                                    bylijinnan
redis
                                    
      方案说明 
 
两台机器（称为A和B），以统一的VIP对外提供服务 
1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 
2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 
3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
      
                                
      • 
                                
    • java文件操作大全
                                    0624chenhong
java
                                    
      最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 
 
http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 
 
转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 
 
 
一.获得控制台用户输入的信息 
 
   &nbs
      
                                
      • 
                                
    • android学习任务
                                    不懂事的小屁孩
工作
                                    
      任务 
完成情况   搞清楚带箭头的pupupwindows和不带的使用 已完成   熟练使用pupupwindows和alertdialog，并搞清楚两者的区别 已完成   熟练使用android的线程handler,并敲示例代码 进行中   了解游戏2048的流程，并完成其代码工作 进行中-差几个actionbar   研究一下android的动画效果，写一个实例 已完成   复习fragem
      
                                
      • 
                                
    • zoom.js
                                    换个号韩国红果果
oom
                                    
      它的基于bootstrap 的 
https://raw.github.com/twbs/bootstrap/master/js/transition.js  transition.js模块引用顺序 
 

<link rel="stylesheet" href="style/zoom.css">
<script src=&q
      
                                
      • 
                                
    • 详解Oracle云操作系统Solaris 11.2
                                    蓝儿唯美
Solaris
                                    
      当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。  
      
                                
      • 
                                
    • spring学习——springmvc（一）
                                    a-john
springMVC
                                    
      Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。 
  
1，跟踪Spring MVC的请求 
请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
      
                                
      • 
                                
    • hdu4342 History repeat itself-------多校联合五
                                    aijuans
数论
                                    
      水题就不多说什么了。 
#include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){    int t;    ll n;    scanf("%d",&t);    while(t--)   
      
                                
      • 
                                
    • EJB和javabean的区别
                                    asia007
beanejb
                                    
      EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了 
  
1.EJB用于服务端应用开发, 而JavaBeans
      
                                
      • 
                                
    • Struts的action和Result总结
                                    百合不是茶
strutsAction配置Result配置
                                    
        
  
一:Action的配置详解: 
     下面是一个Struts中一个空的Struts.xml的配置文件 
    
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	&quo
      
                                
      • 
                                
    • 如何带好自已的团队
                                    bijian1013
项目管理团队管理团队
                                    
      在网上看到博客" 
怎么才能让团队成员好好干活"的评论，觉得写的比较好。   原文如下：   我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 
1.诚信 
        对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。   2.努力提
      
                                
      • 
                                
    • Java代码混淆工具
                                    sunjing
ProGuard
                                    
      Open Source Obfuscators 
ProGuard 
http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
      
                                
      • 
                                
    • 【Redis三】基于Redis sentinel的自动failover主从复制
                                    bit1129
redis
                                    
      在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。 
  什么是Sentine
      
                                
      • 
                                
    • 使用代理实现Hibernate Dao层自动事务
                                    白糖_
DAOspringAOP框架Hibernate
                                    
      都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 
public void save(Object obj){
		Session session = this.getSession();
		Transaction tran = session.beginTransaction();
		try 
      
                                
      • 
                                
    • maven3实战读书笔记
                                    braveCS
maven3
                                    
      Maven简介 
是什么？ 
Is a software project management and comprehension tool.项目管理工具 
是基于POM概念(工程对象模型) 
[设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] 
[与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区] 
  
  
功能： 
      
                                
      • 
                                
    • 编程之美-子数组的最大乘积
                                    bylijinnan
编程之美
                                    
      

public class MaxProduct {

	/**
	 * 编程之美 子数组的最大乘积
	 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。
	 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。
	 * 但按题目的意思，是要求得这个子数组，而不
      
                                
      • 
                                
    • 读书笔记-2
                                    chengxuyuancsdn
读书笔记
                                    
      1、反射 
2、oracle年-月-日 时-分-秒 
3、oracle创建有参、无参函数 
4、oracle行转列 
5、Struts2拦截器 
6、Filter过滤器(web.xml) 
 
 
1、反射
(1)检查类的结构
在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。
2、oracle年月日时分秒
s
      
                                
      • 
                                
    • [求学与房地产]慎重选择IT培训学校
                                    comsci
it
                                    
            关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题 
 
      培训学校的教学楼和宿舍的环境和稳定性问题 
 
      我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... 
 
&nb
      
                                
      • 
                                
    • RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系
                                    daizj
oraclermanfilespersetPARALLELISM
                                    
      RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 转 
 
PARALLELISM --- 
 
我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： 
RMAN > configure device type disk parallelism 3 ; 
表示启动三个通道，可以加快备份恢复的速度。 
      
                                
      • 
                                
    • 简单排序:冒泡排序
                                    dieslrae
冒泡排序
                                    
      
    public void bubbleSort(int[] array){
        for(int i=1;i<array.length;i++){
            for(int k=0;k<array.length-i;k++){
                if(array[k] > array[k+1]){
             
      
                                
      • 
                                
    • 初二上学期难记单词三
                                    dcj3sjt126com
sciet
                                    
      concert 音乐会 
tonight 今晚 
famous 有名的；著名的 
song 歌曲 
thousand 千 
accident 事故；灾难 
careless 粗心的，大意的 
break 折断；断裂；破碎 
heart 心（脏） 
happen  偶尔发生，碰巧 
tourist 旅游者；观光者 
science （自然）科学 
marry 结婚 
subject 题目；
      
                                
      • 
                                
    • I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码 收藏代码
                                    dcj3sjt126com
redis
                                    
      wget http://download.redis.io/redis-stable.tar.gz 
tar xvzf redis-stable.tar.gz 
cd redis-stable 
make 
  
前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。 
异常一： 
make[2]: cc: Command not found 
异常原因：没有安装g
      
                                
      • 
                                
    • 并发容器
                                    shuizhaosi888
并发容器
                                    
         通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。 
   并发容器ConcurrentHashMap 
      替代同步基于散列的Map，通过Lock控制。 
  &nb
      
                                
      • 
                                
    • Spring Security（12）——Remember-Me功能
                                    234390216
Spring SecurityRemember Me记住我
                                    
      Remember-Me功能 
  
目录 
  
1.1     概述 
1.2     基于简单加密token的方法 
1.3     基于持久化token的方法 
1.4     Remember-Me相关接口和实现
      
                                
      • 
                                
    • 位运算
                                    焦志广
位运算
                                    
      
一、位运算符Ｃ语言提供了六种位运算符： 
 
& 按位与 
| 按位或 
^ 按位异或 
~ 取反 
<< 左移 
>> 右移 
 
 

1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。 
 
例如：9&am
      
                                
      • 
                                
    • nodejs 数据库连接 mongodb mysql
                                    liguangsong
mongodbmysqlnode数据库连接
                                    
      1.mysql 连接 
   package.json中dependencies加入 
  
  
"mysql":"~2.7.0" 
   执行 npm install 
  
   在config 下创建文件 database.js 
    

      
                                
      • 
                                
    • java动态编译
                                    olive6615
javaHotSpotjvm动态编译
                                    
          在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。 
    HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
      
                                
      • 
                                
    • Storm0.9.5的集群部署配置优化
                                    roadrunners
优化storm.yaml
                                    
      nimbus结点配置（storm.yaml）信息： 
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional inf
      
                                
      • 
                                
    • 101个MySQL 的调节和优化的提示
                                    tomcat_oracle
mysql
                                    
      　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。   　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。   　　3. 使用电池供电的RAM（注：RAM即随机存储器）。   　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
      
                                
      • 
                                
    • zoj 3829 Known Notation(贪心)
                                    阿尔萨斯
ZOJ
                                    
       题目链接：zoj 3829 Known Notation 
 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。 
 解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1
      
                                
      •