分布式调度Elastic-job

1. 概述

什么是任务调度

任务调度就是在某一天的某一时刻执行某个定时任务 , 在以前我们是使用Spring中的Spring Task进行任务的定时任务的执行

比如说 :

某电商平台需要每天上午10点，下午3点，晚上8点发放一批优惠券

某银行系统需要在信用卡到期还款日的前三天进行短信提醒

某财务系统需要在每天凌晨0:10分结算前一天的财务数据，统计汇总

这些应用场景都需要使用到定时任务的处理

总结 : 任务调度是为了自动完成特定任务 , 在约定的时刻去执行任务的过程

2. 为什么需要分布式调度

感觉Spring中的Spring Task定时器就可以完成任务调度的功能 , 好像已经可以完美的解决问题 ,为什么还要需要使用分布式 ?

当然在单节点项目的情况下是没有问题的 , 但是一旦用户量请求增多之后 , 一个服务就坚持不了 , 解决办法就是集群, 那么集群之后定时器存在什么问题 ?

如果定时器属于追加类型的业务,就会导致任务重复 ,导致数据重复增加

任务重复该怎么解决 ?

解决问题不要让任务重复执行 ,在有多个定时器的情况下 , 保证只运行一次就行了

方案1 : 机器启动的时候 , 有多个定时任务 , 使用分布式锁 ,多个节点抢这个锁, 谁抢到了, 就定义这台机器为leader节点 ,以后定时任务就在leader执行(要知道分布式锁是怎么实现的)  ,需要监控leader的存活状态 , 如果leader挂了 , 有其他机器继续执行任务的调度

方案2 : 定时任务相关的内容抽取出来 ,独立出来

方案2存在的问题 : 但是如果将定时任务相关内容抽取出来 ,就会存在单点故障问题 , 如果定时器任务所在的服务器宕机了, 定时任务也就没法执行了

方案1存在的问题 :

1. 现在有一个任务量很大的定时任务 ,1000个任务 ,每个任务耗时都非常长 ,消耗的资源很多

这1000个任务都在某一个机器上执行 , 需要执行很长时间 , 消耗该机器很多的资源

一台机器消耗很多资源在干活 , 集群中的另一个机器却是空闲的 , 能不能让另外一个机器也帮忙干一些活

如果我们在项目中使用Spring Task的定时器 , 会存在以下的几个问题 :

1. 单机处理极限 : 原本一分钟内需要处理1万的订单 , 但是现在需要1分钟内处理10万个订单 , 原来一个统计需要1小时 ,现在业务方10分种就统计出来了 , 你也许会说 ,你也可以多线程 ,单机多进程处理 ,的确 , 多线程并行处理可以提高单位时间的处理效率 ,但是单机能力处理有限(主要是CPU , 内存 , 磁盘) ,始终会有单机处理不过来的情况
2. 高可用：单机版的定时任务调度只能在一台机器上运行，如果程序或者系统出现异常就会导致功能不可用。虽然可以在单机程序实现的足够稳定，但始终有机会遇到非程序引起的故障，而这个对于一个系统的核心功能来说是不可接受的。
3. 防止重复执行: 在单机模式下，定时任务是没什么问题的。但当我们部署了多台服务，同时又每台服务又有定时任务时，若不进行合理的控制在同一时间，只有一个定时任务启动执行，这时，定时执行的结果就可能存在混乱和错误了

这个时候就需要分布式的任务调度来实现了

Elastic-Job介绍

Elastic - Job是一个分布式调度的解决方案 , 由当当网开源 , 它由两个相互独立的子项目Elastic-job-Lite和Elastic-Job-Cloud组成 ,使用Elastic-job可以快速实现分布式任务调度

Elastic-Job的github地址： https://github.com/elasticjob

功能列表 :

• 分布式调度协调
  • 在分布式中 ,任务能够按照指定的调度策略执行 , 并且能够避免同一任务多实例重复执行
• 丰富的调度策略
  • 基于成熟的定时任务作业框架Quartz cron表达式执行定时任务
• 弹性拓容缩容
  • 当集群中增加一个实例 , 它应当能够被选举被执行任务 , 当集群中减少一个实例时 ,他所执行的任务能够被转移到别的实例中执行
• 失效转移
  • 某实例在任务执行失败后 ,会被转移到其他实例执行
• 错过执行任务重触发
  • 若因某种原因导致作业错过执行 , 自动纪录错误执行的作业 , 并在下次作业完成后自动触发
• 支持并行调度
  • 支持任务分片 , 任务分片是将一个任务分成多个小任务在多个实例同时执行
• 作业分片一致性
  • 当任务分片后 ,保证同一分片在分布式环境中仅一个实例执行
• 支持作业声明周期操作
  • 可以动态对任务进行开启及停止操作
• 丰富的作业类型
  • 支持Simple ,DataFlow ,Script

系统架构图

zookeeper在ElasticJob中的作用

1. 多个分布式调度程序选择其中的leader选举 , 利用Zookeeper中分布锁的功能实现 ,谁能创建节点成功 , 就是leader负责任务调度
2. Elasticjob支持分片的功能 ,将大任务按照规则分成多份 , 究竟有几份 ? 需要依赖zookeeper的注册中心的功能
3. ElasticJob的任务信息 , 任务名 ,任务的调度Cron表达式 , 任务处理类 , 把这些信息存储到zookeeper中 , 管控台读取zookeeper中对应的任务调度的信息 , 可以在可视化界面给用户展示任务配置信息

Elastic-Job快速入门 (掌握)

1. 环境搭建

1.1 版本要求

• JDK 要求1.7以上保本
• Maven 要求3.0.4及以上版本
• Zookeeper 要求采取3.4.6以上版本

1.2  Zookeeper安装&运行

1.3 创建Maven项目

添加依赖 :

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

1.4 代码实现

1.4.1 任务类 :

public class MyElasticJob implements SimpleJob {
    public void execute(ShardingContext shardingContext) {
        System.out.println("定时任务开始====>"+new Date());
    }
}

1.4.2 配置类 ;

public class JobDemo {
    public static void main(String[] args) {
        new JobScheduler(createRegistryCenter(), createJobConfiguration()).init();
    }
    private static CoordinatorRegistryCenter createRegistryCenter() {
        //配置zk地址,调度任务的组名
     ZookeeperConfiguration zookeeperConfiguration = new ZookeeperConfiguration("localhost:2181", "elastic-job-demo");
        zookeeperConfiguration.setSessionTimeoutMilliseconds(100);
        CoordinatorRegistryCenter regCenter = new ZookeeperRegistryCenter(zookeeperConfiguration);
        regCenter.init();
    }

    private static LiteJobConfiguration createJobConfiguration() {
        // 定义作业核心配置
        JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder("demoSimpleJob","0/3 * * * * ?",1).build();
        // 定义SIMPLE类型配置
        SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, MyElasticJob.class.getCanonicalName());
        // 定义Lite作业根配置
        LiteJobConfiguration simpleJobRootConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).build();
        return simpleJobRootConfig;
    }
}

1.4.3 测试 :

• 运行单个程序，查看是否按照cron表达式的内容进行任务的调度
• 运行多个程序(集群)，查看是否只会有一个实例进行任务调度
• 运行多个程序后，把正在进行任务调度的进程关掉，查看其它进程是否能继续进行任务调度

SpringBoot集成Elastic-Job

1. 添加依赖

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>elastic-job-lite-spring</artifactId>
            <version>2.1.5</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

相关配置

因为配置中心的地址并不是固定的 , 所以我们应该把这个地址信息配置在配置文件中 ,所以在配置文件application.yml中添加配置如下:

zookeeper:
  url: localhost:2181
  namespace: elastic-job-boot

zk注册中心配置类:

@Configuration
public class ElasticJobConfig {
    @Value("${zookeeper.url}")
    private String url;
    @Value("${zookeeper.namespace}")
    private String namespace;
    @Autowired
    private DataSource dataSource;
    //将配置中心交给Spring管理
    @Bean
    public  CoordinatorRegistryCenter registryCenter() {
        /**
         * 第一个参数:zookeeper 地址信息
         * 第二个参数 : 保存到zookeeper中节点的信息
         */
        //设置会话超时时间
        ZookeeperConfiguration configuration = new ZookeeperConfiguration(url, namespace);
        configuration.setSessionTimeoutMilliseconds(100);
        CoordinatorRegistryCenter regCenter = new ZookeeperRegistryCenter(configuration);
        regCenter.init();
        return regCenter;
    }

任务调度配置类 :

@Configuration
public class ElasticJobConfig {
    @Autowired
    private MyElasticJob myElasticJob;
    @Autowired
    private CoordinatorRegistryCenter registryCenter;
    private static LiteJobConfiguration createJobConfiguration(final Class<? extends SimpleJob> jobClass,
                                                               final String cron,
                                                               final int shardingTotalCount,
                                                               final String shardingItemParameters) {
        // 定义作业核心配置
        JobCoreConfiguration.Builder jobCoreConfigurationBuilder = JobCoreConfiguration.newBuilder(jobClass.getSimpleName(), cron, shardingTotalCount);
        if(!StringUtils.isEmpty(shardingItemParameters)){
            jobCoreConfigurationBuilder.shardingItemParameters(shardingItemParameters);
        }
        // 定义SIMPLE类型配置
        SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(jobCoreConfigurationBuilder.build(), MyElasticJob.class.getCanonicalName());
        // 定义Lite作业根配置
        LiteJobConfiguration simpleJobRootConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();
        return simpleJobRootConfig;
    }
    @Bean(initMethod = "init")
    public SpringJobScheduler initSimpleElasticJob(){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(myElasticJob,registryCenter,createJobConfiguration(jobClass,"0/3 * * * * ?",1,null));
        return springJobScheduler;
    }
}

案例需求

需求:数据库中有一些列的数据，需要对这些数据进行模拟备份操作，备份完之后，修改数据的状态，标记已经备份了.

初始化数据

在数据库中新建一个库elastic-job-demo在数据库中导入elastic-job-demo.sql数据

添加依赖

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.2.0</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

添加配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/elastic-job-demo?serverTimezone=GMT%2B8
    driverClassName: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: admin

添加实体类

@Data
public class FileCustom {
    //唯一标识
    private Long id;
    //文件名
    private String name;
    //文件类型
    private String type;
    //文件内容
    private String content;
    //是否已备份
    private Boolean backedUp = false;
    public FileCustom(){}
    public FileCustom(Long id, String name, String type, String content){
        this.id = id;
        this.name = name;
        this.type = type;
        this.content = content;
    }
}

添加Mapper处理类

@Mapper
public interface FileCustomMapper {
    @Select("select * from t_file_custom where backedUp = 0")
    List<FileCustom> selectAll();
    @Update("update t_file_custom set backedUp = #{state} where id = #{id}")
    int changeState(@Param("id") Long id, @Param("state")int state);
}

业务功能实现

添加任务类

@Component
public class FileCustomElasticJob implements SimpleJob {
    @Autowired
    private FileCustomMapper fileCustomMapper;
    @Override
    public void execute(ShardingContext shardingContext) {
        doWork();
    }
    private void doWork(){
        List<FileCustom> fileList = fileCustomMapper.selectAll();
        System.out.println("需要备份文件个数:"+fileList.size());
        for(FileCustom fileCustom:fileList){
            backUpFile(fileCustom);
        }
    }
    private void backUpFile(FileCustom fileCustom){
        try {
            //模拟备份动作
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行文件备份====>"+fileCustom);
        fileCustomMapper.changeState(fileCustom.getId(),1);
    }
}

添加任务调度配置

@Bean(initMethod = "init")
    public SpringJobScheduler initFileCustomElasticJob(FileCustomElasticJob fileCustomElasticJob){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(fileCustomElasticJob,registryCenter,createJobConfiguration(FileCustomElasticJob.class,"0 0/1 * * * ?",1,null));
        return springJobScheduler;
    }

测试&问题

为了高可用，我们会对这个项目做集群的操作,可以保证其中一台挂了,另外一台可以继续工作.但是在集群的情况下,调度任务只在一台机器上运行，如果单个任务调度比较耗时，耗资源的情况下，对这台机器的消耗还是比较大的，

但是这个时候，其他机器却是空闲着的.如何合理的利用集群的其他机器且如何让任务执行得更快些呢？这时候Elastic-Job提供了任务调度分片的功能.

分片概念 (掌握)

1. ElasticJob提供leader选举的功能 , 保证在ElasticJob集群的情况下 ,任务只会被执行一次

     假设任务比较繁重(任务多 , 消耗资源多) 在ElasticJob集群的情况下 , 只有一台机器在干活 , 这台机器可能消耗的资源比较多 , 可能出现CPU100% ,内存100%的情况 , 在机器超负荷运行的情况下 , 执行任务的效率就变低了 ,但是这个时候集群中的其他机器却是空闲着的

是否可以让集群中的机器共同参加任务的执行(将任务按照一定的规则进行分配,保证任务是不被重复执行) , 这就是分片

把一个完整的任务 ,按照一定的规则划分多份 , 分配在不同的机器上执行

 分片项与业务处理解耦

Elastic-Job并不直接提供数据处理的功能,框架只会将分片项分配至各个运行中的作业服务器，开发者需要自行处理分片项与真实数据的对应关系

最大限度利用资源

将分片项设置大于服务器的数据，最好是大于服务器倍数的数量，作业将会合理利用分布式资源，动态的分配分片项.

例如: 3台服务器，分成10片，则分片项结果为服务器A=0,1,2;服务器B=3,4,5;服务器C=6,7,8,9.如果 服务器C奔溃，则分片项分配结果为服务器A=0,1,2,3,4;服务器B=5,6,7,8,9.在不丢失分片项的情况下，最大限度利用现有的资源提高吞吐量.

案例改造成任务分片

配置类修改

在任务配置类中增加分片个数以及分片参数.

@Bean(initMethod = "init")
    public SpringJobScheduler initFileCustomElasticJob(FileCustomElasticJob fileCustomElasticJob){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(
                fileCustomElasticJob,
                registryCenter,
                createJobConfiguration(FileCustomElasticJob.class,"0 0/1 * * * ?",4,"0=text,1=image,2=radio,3=vedio"));
        return springJobScheduler;
    }

新增作业分片逻辑

@Component
public class FileCustomElasticJob implements SimpleJob {
    @Autowired
    private FileCustomMapper fileCustomMapper;
    @Override
    public void execute(ShardingContext shardingContext) {
        doWork(shardingContext.getShardingParameter());
    }
    private void doWork(String fileType){
        List<FileCustom> fileList = fileCustomMapper.selecByType(fileType);
        System.out.println("类型为:"+fileType+",文件，需要备份个数:"+fileList.size());
        for(FileCustom fileCustom:fileList){
            backUpFile(fileCustom);
        }
    }
    private void backUpFile(FileCustom fileCustom){
        try {
            //模拟备份动作
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行文件备份====>"+fileCustom);
        fileCustomMapper.changeState(fileCustom.getId(),1);
    }
}

Mapper类修改

@Mapper
public interface FileCustomMapper {
    @Select("select * from t_file_custom where backedUp = 0")
    List<FileCustom> selectAll();
    @Select("select * from t_file_custom where backedUp = 0 and type=#{fileType}")
    List<FileCustom> selecByType(String fileType);
    @Update("update t_file_custom set backedUp = #{state} where id = #{id}")
    int changeState(@Param("id") Long id, @Param("state")int state);
}

测试

• 只有一台机器的情况下，任务分片是如何执行的
• 有多台机器的情况下，任务分片是如何执行的

Dataflow类型调度任务 (掌握)

Dataflow类型的定时任务需要实现Dataflowjob接口，该接口提供2个方法供覆盖，分别用于抓取（fetchData）和处理（processData）数据，我们继续对例子进行改造。

Dataflow类型用于处理数据流，他和SimpleJob不同，它以数据流的方式执行，调用fetchData抓取数据，知道抓取不到数据才停止作业。

为什么需要使用DataFlowJob任务调度

1. 假设任务数据非常多 , 使用SimpleJob需要查询所有的数据 ,然后依次执行 ,比如有200万的数据, 即使做了分片 ,分成四片 , 每一片都由50万的数据 ,这些数据占用提交还是很大的 ,导致可能存在内存溢出的情况
2. 有一个任务 , 零点执行 ,需要从某个数据库中查询数据 , 执行的过程中 , 可能会继续产生一部分的数据 , 持续多久不确定(发送的速率比处理的速率要快的) 如果使用SimpleJob ,只能在凌晨0:00定时任务查询一次 , 后面发送过来的数据就处理不了

任务类

@Component
public class FileDataflowJob implements DataflowJob<FileCustom> {
    @Autowired
    private FileCustomMapper fileCustomMapper;
    @Override
    public List<FileCustom> fetchData(ShardingContext shardingContext) {
        List<FileCustom> fileCustoms = fileCustomMapper.fetchData(2);
        System.out.println("抓取时间:"+new Date()+",个数"+fileCustoms.size());
        return fileCustoms;
    }
    @Override
    public void processData(ShardingContext shardingContext, List<FileCustom> data) {
        for(FileCustom fileCustom:data){
            backUpFile(fileCustom);
        }
    }
    private void backUpFile(FileCustom fileCustom){
        try {
            //模拟备份动作
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行文件备份====>"+fileCustom);
        fileCustomMapper.changeState(fileCustom.getId(),1);
    }
}

 配置类

@Configuration
public class ElasticJobConfig {
    @Autowired
    private MyElasticJob myElasticJob;
    @Autowired
    private CoordinatorRegistryCenter registryCenter;
    private static LiteJobConfiguration createJobConfiguration(final Class<? extends ElasticJob> jobClass,
                                                               final String cron,
                                                               final int shardingTotalCount,
                                                               final String shardingItemParameters,
                                                               boolean dataflowType) {
        // 定义作业核心配置
        JobCoreConfiguration.Builder jobCoreConfigurationBuilder = JobCoreConfiguration.newBuilder(jobClass.getSimpleName(), cron, shardingTotalCount);
        if(!StringUtils.isEmpty(shardingItemParameters)){
            jobCoreConfigurationBuilder.shardingItemParameters(shardingItemParameters);
        }
        JobTypeConfiguration jobConfig = null;
        if(dataflowType){
            jobConfig = new DataflowJobConfiguration(jobCoreConfigurationBuilder.build(),jobClass.getCanonicalName(),true);
        }else{
            // 定义SIMPLE类型配置
            jobConfig = new SimpleJobConfiguration(jobCoreConfigurationBuilder.build(), jobClass.getCanonicalName());
        }
        // 定义Lite作业根配置
        LiteJobConfiguration simpleJobRootConfig = LiteJobConfiguration.newBuilder(jobConfig).overwrite(true).build();
        return simpleJobRootConfig;
    }
    /*@Bean(initMethod = "init")
    public SpringJobScheduler initSimpleElasticJob(){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(myElasticJob,registryCenter,createJobConfiguration(MyElasticJob.class,"0/3 * * * * ?",1,null));
        return springJobScheduler;
    }*/
    /*@Bean(initMethod = "init")
    public SpringJobScheduler initFileCustomElasticJob(FileCustomElasticJob fileCustomElasticJob){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(
                fileCustomElasticJob,
                registryCenter,
                createJobConfiguration(FileCustomElasticJob.class,"0 0/1 * * * ?",4,"0=text,1=image,2=radio,3=vedio",false));
        return springJobScheduler;
    }*/
    @Bean(initMethod = "init")
    public SpringJobScheduler iniDataflowElasticJob(FileDataflowJob fileDataflowJob){
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(
                fileDataflowJob,
                registryCenter,
                createJobConfiguration(FileDataflowJob.class,"0 0/1 * * * ?",1,null,true));
        return springJobScheduler;
    }
}

运维管理 (了解)

事件追踪

Elastic-Job-Lite在配置中提供了JobEventConfiguration,支持数据库方式配置，会在数据库中自动创建JOB_EXECUTION_LOG和JOB_STATUS_TRACE_LOG两张表以及若干索引来近路作业的相关信息。

修改Elastic-Job配置类

在ElasticJobConfig配置类中注入DataSource

@Configuration
public class ElasticJobConfig {
    @Autowired
    private DataSource dataSource;
	......
}

在任务配置中增加事件追踪配置

@Bean(initMethod = "init")
    public SpringJobScheduler initFileCustomElasticJob(FileCustomElasticJob fileCustomElasticJob){
        //增加任务事件追踪配置
        JobEventConfiguration jobEventConfiguration = new JobEventRdbConfiguration(dataSource);
        SpringJobScheduler springJobScheduler = new SpringJobScheduler(
                fileCustomElasticJob,
                registryCenter,
                createJobConfiguration(FileCustomElasticJob.class,"0 0/1 * * * ?",4,"0=text,1=image,2=radio,3=vedio",false),
                jobEventConfiguration);
        return springJobScheduler;
    }

日志信息表

启动后会发现在elastic-job-demo数据库中新增以下两张表

job_execution_log

记录每次作业的执行历史，分为两个步骤：

1.作业开始执行时间向数据库插入数据.

2.作业完成执行时向数据库更新数据，更新is_success,complete_time和failure_cause(如果任务执行失败)

job_status_trace_log

 记录作业状态变更痕迹表，可通过每次作业运行的task_id查询作业状态变化的生命轨迹和运行轨迹.

运维控制台

elastic-job中提供了一个elastic-job-lite-console控制台

设计理念

1.本 控制台和Elastic-Job并无直接关系，是通过读取Elastic-Job的注册中心数据展示作业状态，或更新注册中心数据修改全局配置。

2.控制台只能控制任务本身是否运行，但不能控制作业进程的启停，因为控制台和作业本身服务器是完全分布式的，控制台并不能控制作业服务器。

主要功能:

1.查看作业以及服务器状态

2.快捷的修改以及删除作业配置

3.启用和禁用作业

4.跨注册中心查看作业

5.查看作业运行轨迹和运行状态

不支持项

1.添加作业，因为作业都是在首次运行时自动添加，使用控制台添加作业并无必要.直接在作业服务器启动包含Elasitc-Job的作业进程即可。

搭建步骤

• 解压缩elastic-job-lite-console-2.1.5.tar
• 进入bin目录，并执行:
• bin\start.bat

• 打开浏览器访问http://localhost:8899

  用户名: root 密码: root,进入之后界面如下:

  

 提供两种用户：管理员和访客，管理员拥有全部操作权限，访客仅拥有查看权限。默认管理员账号和面膜是root/root,访客用户名和密码是guest/guest,通过conf\auth.properties可以修改管理员以及访客用户名及密码

配置及使用

• 配置注册中心地址
  • 先启动zookeeper然后再注册中心配置界面，点添加
  • 

   点击提交后，然后点连接（zookeeper必须处于启动状态）

• 

  连接成功后，在作业纬度下可以显示该命名空间作业名称，分片数量及该作业的cron表达式等信息

  在服务器纬度可以查看到服务器ip,当前运行的是实例数，作业总数等信息。

• 

   添加数据库连接之后可以查看任务的执行结果

• 

   然后在作业历史中就可以看到任务执行历史了。

•