分布式任务调度

分布式任务调度(Quartz/Elastic-Job)

Quartz

  		<!--引入quartz相关jar包-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>

package com.lagou;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * @autor zixian
 * @date 2021/6/22
 */

public class QuartzDemo {
    public static void main(String[] args) throws SchedulerException {
        //创建任务调度器
        Scheduler scheduler = getScheduler();
        //创建任务
        JobDetail jobDetail = getJobDetail();
        //创建任务触发器
        Trigger trigger = getTrigger();
        //使⽤调度器按照时间触发器执⾏这个任务
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();
    }

    /**
     * 创建任务调度器
     * @return
     * @throws SchedulerException
     */
    private static Scheduler getScheduler() throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        return scheduler;
    }


    /**
     * 创建一个任务
     * @return
     */
    private static JobDetail getJobDetail() {
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("jobName").build();
        return jobDetail;
    }

    /**
     * 创建任务时间触发器
     * cron表达式由七个位置组成，空格分隔
     * 1、Seconds（秒） 0~59
     * 2、Minutes（分） 0~59
     * 3、Hours（⼩时） 0~23
     * 4、Day of Month（天）1~31,注意有的⽉份不⾜31天
     * 5、Month（⽉） 0~11,或者 JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
     * 6、Day of Week(周) 1~7,1=SUN或者 SUN,MON,TUE,WEB,THU,FRI,SAT定义⼀个job，需实现Job接⼝
     * 7、Year（年）1970~2099 可选项
     * 示例：
     * 0 0 11 * * ? 每天的11点触发执⾏⼀次
     * 0 30 10 1 * ? 每⽉1号上午10点半触发执⾏⼀次
     */
    private static Trigger getTrigger() {
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("triggerName")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
                .build();
        return trigger;
    }
}



package com.lagou;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @autor zixian
 * @date 2021/6/22
 */

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("开始干活了。。。");
    }
}

说明：如果想通过Quartz来实现分布式任务调度，则需要把Quartz部署成一个单独的任务调度服务器，然后调用对应服务器中的逻辑，比如调用集群中的restfull风格的接口，但是存在一个问题，调度服务器是单体的，存在一定的宕机风险

Elastic-Job

1、基本概念
elastic-job是当当网基于quartz进行的二次开发的分布式任务调度方案，有两个相对独立的子项目Elastic-Job-Lite和Elastic-Job-Cloud组成。本文主要分析 Elastic-Job-Lite，它定位为轻量级无中心化解决方案，使用jar包的形式提供分布式任务的协调服务，而Elastic-Job-Cloud子项目需要结合Mesos以及Docker在云环境下使用

2、elastic-job源码github下载地址： https://github.com/apache/shardingsphere-elasticjob

3、Elastic-Job-Lite应用
elastic-job依赖于Zookeeper进行分布式协调，需要安装Zookeeper，我这里安装的是zookeeper-3.4.10.tar.gz 版本，请自行安装。

    <dependencies>
        <!--引入quartz相关jar包-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>

        <!--elastic-job-lite核心包-->
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>elastic-job-lite-core</artifactId>
            <version>2.1.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
    </dependencies>

package com.lagou;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JdbcUtil {
    //url
    private static String url = "jdbc:mysql://10.60.131.17:3306/user?characterEncoding=utf8";
    //user
    private static String user = "root";
    //password
    private static String password = "123qweASD!@#";
    //驱动程序类
    private static String driver = "com.mysql.jdbc.Driver";

    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() {

        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;

    }

    public static void close(ResultSet rs, PreparedStatement ps, Connection con) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (ps != null) {
                    try {
                        ps.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    } finally {
                        if (con != null) {
                            try {
                                con.close();
                            } catch (SQLException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }


    /***
     * DML操作（增删改）
     * 1.获取连接数据库对象
     * 2.预处理
     * 3.执行更新操作
     * @param sql
     * @param obj
     */
    //调用者只需传入一个sql语句，和一个Object数组。该数组存储的是SQL语句中的占位符
    public static void executeUpdate(String sql,Object...obj) {
        Connection con = getConnection();//调用getConnection()方法连接数据库
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);//预处理
            for (int i = 0; i < obj.length; i++) {//预处理声明占位符
                ps.setObject(i + 1, obj[i]);
            }
            ps.executeUpdate();//执行更新操作
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(null, ps, con);//调用close()方法关闭资源
        }
    }



    /***
     * DQL查询
     * Result获取数据集
     *
     * @param sql
     * @param obj
     * @return
     */
    public static List<Map<String,Object>> executeQuery(String sql, Object...obj) {
        Connection con = getConnection();
        ResultSet rs = null;
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);
            for (int i = 0; i < obj.length; i++) {
                ps.setObject(i + 1, obj[i]);
            }
            rs = ps.executeQuery();
            //new 一个空的list集合用来存放查询结果
            List<Map<String, Object>> list = new ArrayList<>();
            //获取结果集的列数
            int count = rs.getMetaData().getColumnCount();
            //对结果集遍历每一条数据是一个Map集合，列是k,值是v
            while (rs.next()) {
                //一个空的map集合，用来存放每一行数据
                Map<String, Object> map = new HashMap<String, Object>();
                for (int i = 0; i < count; i++) {
                    Object ob = rs.getObject(i + 1);//获取值
                    String key = rs.getMetaData().getColumnName(i + 1);//获取k即列名
                    map.put(key, ob);
                }
                list.add(map);
            }
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

            close(rs, ps, con);
        }

        return null;
    }
}

package com.lagou;

import com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;

import java.util.List;
import java.util.Map;

/**
 * 数据归档job
 * @autor zixian
 * @date 2021/6/23
 */

public class ElasticMyJob implements SimpleJob {
    @Override
    public void execute(ShardingContext shardingContext) {
        int shardingItem = shardingContext.getShardingItem();
        Integer shardingParameter = Integer.valueOf(shardingContext.getShardingParameter());
        System.out.println("======>>>threadId=" + Thread.currentThread().getId() + " 当前分片:" + shardingItem);
        System.out.println("======>>>threadId=" + Thread.currentThread().getId() + " 当前分片参数:" + shardingParameter);
        //查询出需要处理的数据
        String sql = null;
        //根据分片传入的参数执行不同的sql
        if (shardingParameter.equals(1)) {
            sql = "select * from resume where state='未处理' and id%2=1 limit 1";
        } else {
            sql = "select * from resume where state='未处理' and id%2=0 limit 1";
        }
        List<Map<String, Object>> dataList = JdbcUtil.executeQuery(sql);
        if (dataList == null || dataList.size() == 0) {
            System.out.println("处理完成");
        }
        Map<String, Object> map = dataList.get(0);
        System.out.println("======>>>threadId=" + Thread.currentThread().getId() + " " + map.toString());
        Long id = (Long) map.get("id");
        String name = (String) map.get("name");
        String sex = (String) map.get("sex");
        String phone = (String) map.get("phone");
        String address = (String) map.get("address");
        String education = (String) map.get("education");

        //处理数据
        String updateStateSql = "update resume set state='已处理' where id=?";
        JdbcUtil.executeUpdate(updateStateSql, id);
        String insertResumeBakSql = "insert into resume_bak(name, sex, phone, address, education, state) values(?,?,?,?,?,?)";
        JdbcUtil.executeUpdate(insertResumeBakSql, name, sex, phone, address, education, "已处理");
    }
}

package com.lagou;

import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.reg.base.CoordinatorRegistryCenter;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;

/**
 * @autor zixian
 * @date 2021/6/22
 */

public class ElasticJobDemo {
    public static void main(String[] args) {
        //初始化zk
        ZookeeperConfiguration zkConfig = new ZookeeperConfiguration("10.60.131.17:2181", "data-sharding-job");
        CoordinatorRegistryCenter coordinatorRegistryCenter = new ZookeeperRegistryCenter(zkConfig);
        coordinatorRegistryCenter.init();

        //配置任务，将任务分成两个分片，根据id进行分片，奇数id一个分片任务，偶数id一个分片任务
        JobCoreConfiguration job = JobCoreConfiguration.newBuilder("sharding-job-1", "0/2 * * * * ?", 2)
                .shardingItemParameters("0=1,1=2")//1-奇数 2-偶数
                .build();
        SimpleJobConfiguration simpleJobConfiguration = new SimpleJobConfiguration(job, ElasticMyJob.class.getName());

        //启动任务
        new JobScheduler(coordinatorRegistryCenter, LiteJobConfiguration.newBuilder(simpleJobConfiguration).build()).init();
    }
}

测试结果：
1、启动了一个节点，两个分片都在改节点中运行

2、启动了两个节点，每个节点中运行一个分片

4、总结
当我们需要执行一个非常耗时的job时，我们可以使用Elastic-Job的横向扩展能力，将任务job分成若干个分片，每个分片执行什么逻辑由我们自己定制，每个分片交由一个机器实例来执行（一个机器实例也可以处理多个分片），当我们扩容或者缩容后，定时任务下次执行时，分片算法会重新执行，如果机器挂掉到只剩一个节点，所有分片都会指向剩下的一个节点，这也是Elastic-Job高可用的体现。