第一步：首先在applicationContext.xml中配置入口（触发器），启动服务加载

第二步：在类中初始化

第三步：编写实体类

第四步：编写带有main方法的入口类

Elastic-Job

Elastic-Job有什么用

Elastic-job解决以下问题，我们开发定时任务一般都是使用quartz或者spring-task，无论是使用quartz还是spring-task，我们都会至少遇到两个痛点：

• 不敢轻易跟着应用服务多节点部署，可能会重复多次执行而引发系统逻辑的错误。
• quartz的集群仅仅只是用来HA，节点数量的增加并不能给我们的每次执行效率带来提升，即不能实现水平扩展。

简单来说也就是在当下分布式、集群盛行的背景下解决多台机器重复执行定时任务或需求修改配置指定单独固定的定时任务执行机器的烦恼，同时避免如果特定的某台定时任务执行机器宕机导致定时任务无法执行的尴尬场面。

废话不多说我想大家在其他地方都能看到这些介绍，我们直接上干货！

一、Mavne依赖

<dependency>
	<groupId>com.dangdang</groupId>
	<artifactId>elastic-job-lite-core</artifactId>
	<version>2.1.3</version>
</dependency>
<dependency>
	<groupId>com.dangdang</groupId>
	<artifactId>elastic-job-lite-spring</artifactId>
	<version>2.1.3</version>
</dependency>

二、创建定时作业业务类

package com.zhibo.elastic.job;

import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @author zhibo.lv
 * @title: TestJob
 * @description: Test定时任务
 * @date 2019/12/2 14:15
 */
@Slf4j
@Component
public class TestJob implements SimpleJob {
    @Override
    public void execute(ShardingContext shardingContext) {
        log.info("[elastic job TestJob] begin----------------");
        //如有设置分片获取当前任务的分片编号
        int shardingItem = shardingContext.getShardingItem();
        System.out.println("Job 分片处理：" + shardingItem);
        //自行添加业务代码 ----
        log.info("[elastic job TestJob] end----------------");
    }
}

三、配置elasticJob.xml

digest="$zookeeper.username:${zookeeper.password}" 这个配置一般用不上 下文会有介绍

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:reg="http://www.dangdang.com/schema/ddframe/reg"
       xmlns:job="http://www.dangdang.com/schema/ddframe/job"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.dangdang.com/schema/ddframe/reg
                        http://www.dangdang.com/schema/ddframe/reg/reg.xsd
                        http://www.dangdang.com/schema/ddframe/job
                        http://www.dangdang.com/schema/ddframe/job/job.xsd">

     <reg:zookeeper id="regCenter" server-lists="${job.registry.address}" namespace="zhibo-elastic-job"
                    base-sleep-time-milliseconds="10000" max-retries="3" max-sleep-time-milliseconds="30000"
                    digest="${zookeeper.username}:${zookeeper.password}"/>

     <job:simple id="activeAdminInfoJob" class="com.zhibo.elastic.job.TestJob"
                 registry-center-ref="regCenter"
                 sharding-total-count="1"
                 cron="0 * * * * ? "
                 sharding-item-parameters="0=0"
                 monitor-execution="false"
                 monitor-port="9888"
                 failover="true"
                 description="Test Job"
                 disabled="false"
                 overwrite="true"/>
</beans>

别忘了在applicationContext.xml里面引入elasticJob.xml

reg:zookeeper 命名空间属性详细说明

job:simple 命名空间属性详细说明

Elastic-job解决的问题

        Elastic-job解决以下问题，我们开发定时任务一般都是使用quartz或者spring-task（ScheduledExecutorService），无论是使用quartz还是spring-task，我们都会至少遇到两个痛点：

1. 不敢轻易跟着应用服务多节点部署，可能会重复多次执行而引发系统逻辑的错误。
2. quartz的集群仅仅只是用来HA，节点数量的增加并不能给我们的每次执行效率带来提升，即不能实现水平扩展。

Elastic-job的主要包括以下功能。

1. 定时任务：基于成熟的定时任务作业框架Quartz cron表达式执行定时任务。
2. 作业注册中心：基于Zookeeper和其客户端Curator实现的全局作业注册控制中心。用于注册，控制和协调分布式作业执行。
3. 作业分片：将一个任务分片成为多个小任务项在多服务器上同时执行。
4. 弹性扩容缩容：运行中的作业服务器崩溃，或新增加n台作业服务器，作业框架将在下次作业执行前重新分片，不影响当前作业执行。
5. 支持多种作业执行模式：支持OneOff（类似Quartz原生作业），Perpetual（类似TbSchedule作业）和SequencePerpetual（类似TbSchedule和kafka的合并，但处理时维持分片顺序）三种作业模式。
6. 失效转移：运行中的作业服务器崩溃不会导致重新分片，只会在下次作业启动时分片。启用失效转移功能可以在本次作业执行过程中，监测其他作业服务器空闲，抓取未完成的孤儿分片项执行。
7. 运行时状态收集：监控作业运行时状态，统计最近一段时间处理的数据成功和失败数量，记录作业上次运行开始时间，结束时间和下次运行时间。
8. 作业停止，恢复和禁用：用于操作作业启停，并可以禁止某作业运行（上线时常用）。
9. 被错过执行的作业重触发：自动记录错过执行的作业，并在上次作业完成后自动触发。可参考Quartz的misfire。
10. 多线程快速处理数据：使用多线程处理抓取到的数据，提升吞吐量。
11. 幂等性：重复作业任务项判定，不重复执行已运行的作业任务项。由于开启幂等性需要监听作业运行状态，对瞬时反复运行的作业对性能有较大影响。
12. 容错处理：作业服务器与Zookeeper服务器通信失败则立即停止作业运行，防止作业注册中心将失效的分片分项配给其他作业服务器，而当前作业服务器仍在执行任务，导致重复执行。
13. Spring支持：支持spring容器，自定义命名空间，支持占位符。
14. 运维平台：提供运维界面，可以管理作业和注册中心。

运用实例 

     1.引入依赖   (基于gradle)

compile('com.dangdang:elastic-job-core:1.0.6')
compile('com.dangdang:elastic-job-spring:1.0.6')

     2.xml文件的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:reg="http://www.dangdang.com/schema/ddframe/reg"
       xmlns:job="http://www.dangdang.com/schema/ddframe/job"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.dangdang.com/schema/ddframe/reg
                    http://www.dangdang.com/schema/ddframe/reg/reg.xsd
                    http://www.dangdang.com/schema/ddframe/job
                    http://www.dangdang.com/schema/ddframe/job/job.xsd">

        <!--配置作业注册中心 
          serverLists:注册中心地址(zookeeper或者其他的)
          maxRetries:最大重试次数
        -->
        <reg:zookeeper id="regCenter" serverLists="${acw.zookeeper.address}" namespace="duiba-job"
                       baseSleepTimeMilliseconds="1000" maxSleepTimeMilliseconds="3000" maxRetries="3" overwrite="true"/>


        <!-- 配置定时任务
            shardingTotalCount:分几个片段执行
        -->
    <job:bean id="aMonthlyScheduleTaskJob" class="cn.com.duiba.manager.web.biz.job.impl.AMonthlyScheduleTaskJob"
              regCenter="regCenter" cron="0 0 1 1 * ?" shardingTotalCount="1" overwrite="true"/>

    3.JAVA代码

import cn.com.duiba.manager.web.common.tools.Environment;
import com.dangdang.ddframe.job.api.JobExecutionMultipleShardingContext;
import com.dangdang.ddframe.job.plugin.job.type.simple.AbstractSimpleElasticJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;


public abstract class AbstractManagerJob extends AbstractSimpleElasticJob {
    private static final Logger LOG = LoggerFactory.getLogger(AbstractManagerJob.class);
    @Value("${duiba.job.skip:false}")
    private boolean skipJob;

    public void process(final JobExecutionMultipleShardingContext shardingContext) {
        if (Environment.isPrepub() || skipJob) {
            return;
        }
        try {
            doProcess(shardingContext);
        } catch (Exception e) {
            LOG.error("", e);
        }

    }

    public abstract void doProcess(final JobExecutionMultipleShardingContext shardingContext);
}

import cn.com.duiba.manager.web.biz.job.AbstractManagerJob;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import cn.com.duiba.developer.center.api.remoteservice.RemoteAppService;

import com.dangdang.ddframe.job.api.JobExecutionMultipleShardingContext;


@Component
public class AMonthlyScheduleTaskJob extends AbstractManagerJob {

	@Autowired
	private RemoteAppService remoteAppServiceNew;


	@Override
	public void doProcess(JobExecutionMultipleShardingContext shardingContext) {
		aMonthlySchedule();
	}

	private void aMonthlySchedule() {
		remoteAppServiceNew.updatBudgetRemain();
	}
}