輕量級分布式任務調度框架(二、LTS編譯、打包、部署)

接上文......

(7) 項目編譯打包

項目主要采用maven進行構建，目前提供shell腳本的打包。環境依賴：Java(jdk1.6+) Maven

使用一般分為兩種：

(7.1) Maven構建

可以通過maven命令將lts的jar包上傳到本地倉庫中。在父pom.xml中添加相應的repository，並用deploy命令上傳即可。具體引用方式可以參考lts中的例子即可。

(7.2) 直接Jar引用

需要將lts的各個模塊打包成單獨的jar包，並且將所有lts依賴包引入。具體引用哪些jar包可以參考lts中的例子即可。

(8) JobTracker和LTS-Admin部署

提供(cmd)windows和(shell)linux兩種版本腳本來進行編譯和部署:

(1) 運行根目錄下的sh build.sh或build.cmd腳本，會在dist目錄下生成lts-{version}-bin文件夾

(2) 下面是其目錄結構，其中bin目錄主要是JobTracker和LTS-Admin的啟動腳本。jobtracker 中是 JobTracker的配置文件和需要使用到的jar包，lts-admin是LTS-Admin相關的war包和配置文件。

lts-{version}-bin的文件結構

-- lts-${version}-bin
    |-- bin
    |   |-- jobtracker.cmd
    |   |-- jobtracker.sh
    |   |-- lts-admin.cmd
    |   |-- lts-admin.sh
    |   |-- lts-monitor.cmd
    |   |-- lts-monitor.sh
    |   |-- tasktracker.sh
    |-- conf
    |   |-- log4j.properties
    |   |-- lts-admin.cfg
    |   |-- lts-monitor.cfg
    |   |-- readme.txt
    |   |-- tasktracker.cfg
    |   |-- zoo
    |       |-- jobtracker.cfg
    |       |-- log4j.properties
    |       |-- lts-monitor.cfg
    |-- lib
    |   |-- *.jar
    |-- war
        |-- jetty
        |   |-- lib
        |       |-- *.jar
        |-- lts-admin.war

(3) JobTracker啟動。如果你想啟動一個節點，直接修改下conf/zoo下的配置文件，然后運行 sh jobtracker.sh zoo start即可，如果你想啟動兩個JobTracker節點，那么你需要拷貝一份zoo,譬如命名為zoo2,修改下zoo2下的配置文件，然后運行sh jobtracker.sh zoo2 start即可。logs文件夾下生成jobtracker-zoo.out日志。
(4) LTS-Admin啟動,修改conf/lts-monitor.cfg和conf/lts-admin.cfg下的配置，然后運行bin下的sh lts-admin.sh或lts-admin.cmd腳本即可。logs文件夾下會生成lts-admin.out日志，啟動成功在日志中會打印出訪問地址，用戶可以通過這個訪問地址訪問了。

(9) JobClient（部署）使用

需要引入lts的jar包有lts-jobclient-{version}.jar，lts-core-{version}.jar 及其它第三方依賴jar。

(9.1) API方式啟動

JobClient jobClient = new RetryJobClient();
jobClient.setNodeGroup("test_jobClient");
jobClient.setClusterName("test_cluster");
jobClient.setRegistryAddress("zookeeper://127.0.0.1:2181");
jobClient.start();

// 提交任務
Job job = new Job();
job.setTaskId("3213213123");
job.setParam("shopId", "11111");
job.setTaskTrackerNodeGroup("test_trade_TaskTracker");
// job.setCronExpression("0 0/1 * * * ?");  // 支持 cronExpression表達式
// job.setTriggerTime(new Date()); // 支持指定時間執行
Response response = jobClient.submitJob(job);

(9.2) Spring XML方式啟動

<bean id="jobClient" class="com.github.ltsopensource.spring.JobClientFactoryBean">
    <property name="clusterName" value="test_cluster"/>
    <property name="registryAddress" value="zookeeper://127.0.0.1:2181"/>
    <property name="nodeGroup" value="test_jobClient"/>
    <property name="masterChangeListeners">
        <list>
            <bean class="com.github.ltsopensource.example.support.MasterChangeListenerImpl"/>
        </list>
    </property>
    <property name="jobFinishedHandler">
        <bean class="com.github.ltsopensource.example.support.JobFinishedHandlerImpl"/>
    </property>
    <property name="configs">
        <props>
            <!-- 參數 -->
            <prop key="job.fail.store">leveldb</prop>
        </props>
    </property>
</bean>

(9.3) Spring 全注解方式

@Configuration
public class LTSSpringConfig {

    @Bean(name = "jobClient")
    public JobClient getJobClient() throws Exception {
        JobClientFactoryBean factoryBean = new JobClientFactoryBean();
        factoryBean.setClusterName("test_cluster");
        factoryBean.setRegistryAddress("zookeeper://127.0.0.1:2181");
        factoryBean.setNodeGroup("test_jobClient");
        factoryBean.setMasterChangeListeners(new MasterChangeListener[]{
                new MasterChangeListenerImpl()
        });
        Properties configs = new Properties();
        configs.setProperty("job.fail.store", "leveldb");
        factoryBean.setConfigs(configs);
        factoryBean.afterPropertiesSet();
        return factoryBean.getObject();
    }
}

(10)TaskTracker(部署使用)

需要引入lts的jar包有lts-tasktracker-{version}.jar，lts-core-{version}.jar 及其它第三方依賴jar。

(10.1)定義自己的任務執行類

public class MyJobRunner implements JobRunner {
    @Override
    public Result run(JobContext jobContext) throws Throwable {
        try {
            // TODO 業務邏輯
            // 會發送到 LTS (JobTracker上)
            jobContext.getBizLogger().info("測試，業務日志啊啊啊啊啊");

        } catch (Exception e) {
            return new Result(Action.EXECUTE_FAILED, e.getMessage());
        }
        return new Result(Action.EXECUTE_SUCCESS, "執行成功了，哈哈");
    }
}

(10.2) API方式啟動

TaskTracker taskTracker = new TaskTracker();
taskTracker.setJobRunnerClass(MyJobRunner.class);
taskTracker.setRegistryAddress("zookeeper://127.0.0.1:2181");
taskTracker.setNodeGroup("test_trade_TaskTracker");
taskTracker.setClusterName("test_cluster");
taskTracker.setWorkThreads(20);
taskTracker.start();

(10.3) Spring XML方式啟動

<bean id="taskTracker" class="com.github.ltsopensource.spring.TaskTrackerAnnotationFactoryBean" init-method="start">
    <property name="jobRunnerClass" value="com.github.ltsopensource.example.support.MyJobRunner"/>
    <property name="bizLoggerLevel" value="INFO"/>
    <property name="clusterName" value="test_cluster"/>
    <property name="registryAddress" value="zookeeper://127.0.0.1:2181"/>
    <property name="nodeGroup" value="test_trade_TaskTracker"/>
    <property name="workThreads" value="20"/>
    <property name="masterChangeListeners">
        <list>
            <bean class="com.github.ltsopensource.example.support.MasterChangeListenerImpl"/>
        </list>
    </property>
    <property name="configs">
        <props>
            <prop key="job.fail.store">leveldb</prop>
        </props>
    </property>
</bean>

(10.4) Spring注解方式啟動

@Configuration
public class LTSSpringConfig implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
	@Bean(name = "taskTracker")
    public TaskTracker getTaskTracker() throws Exception {
        TaskTrackerAnnotationFactoryBean factoryBean = new TaskTrackerAnnotationFactoryBean();
        factoryBean.setApplicationContext(applicationContext);
        factoryBean.setClusterName("test_cluster");
        factoryBean.setJobRunnerClass(MyJobRunner.class);
        factoryBean.setNodeGroup("test_trade_TaskTracker");
        factoryBean.setBizLoggerLevel("INFO");
        factoryBean.setRegistryAddress("zookeeper://127.0.0.1:2181");
        factoryBean.setMasterChangeListeners(new MasterChangeListener[]{
                new MasterChangeListenerImpl()
        });
        factoryBean.setWorkThreads(20);
        Properties configs = new Properties();
        configs.setProperty("job.fail.store", "leveldb");
        factoryBean.setConfigs(configs);

        factoryBean.afterPropertiesSet();
//        factoryBean.start();
        return factoryBean.getObject();
    }
}

(11) 參數說明

參數說明

(12) 使用建議

一般在一個JVM中只需要一個JobClient實例即可，不要為每種任務都新建一個JobClient實例，這樣會大大的浪費資源，因為一個JobClient可以提交多種任務。相同的一個JVM一般也盡量保持只有一個TaskTracker實例即可，多了就可能造成資源浪費。當遇到一個TaskTracker要運行多種任務的時候，請參考下面的 "一個TaskTracker執行多種任務"。

(12.1) 一個TaskTracker執行多種任務

有的時候，業務場景需要執行多種任務，有些人會問，是不是要每種任務類型都要一個TaskTracker去執行。我的答案是否定的，如果在一個JVM中，最好使用一個TaskTracker去運行多種任務，因為一個JVM中使用多個TaskTracker實例比較浪費資源（當然當你某種任務量比較多的時候，可以將這個任務單獨使用一個TaskTracker節點來執行）。那么怎么才能實現一個TaskTracker執行多種任務呢。下面是我給出來的參考例子。

/**
 * 總入口，在 taskTracker.setJobRunnerClass(JobRunnerDispatcher.class)
 * JobClient 提交 任務時指定 Job 類型  job.setParam("type", "aType")
 */
public class JobRunnerDispatcher implements JobRunner {

    private static final ConcurrentHashMap<String/*type*/, JobRunner>
            JOB_RUNNER_MAP = new ConcurrentHashMap<String, JobRunner>();

    static {
        JOB_RUNNER_MAP.put("aType", new JobRunnerA()); // 也可以從Spring中拿
        JOB_RUNNER_MAP.put("bType", new JobRunnerB());
    }

    @Override
    public Result run(JobContext jobContext) throws Throwable {
        Job job = jobContext.getJob();
        String type = job.getParam("type");
        return JOB_RUNNER_MAP.get(type).run(job);
    }
}

class JobRunnerA implements JobRunner {
    @Override
    public Result run(JobContext jobContext) throws Throwable {
        //  TODO A類型Job的邏輯
        return null;
    }
}

class JobRunnerB implements JobRunner {
    @Override
    public Result run(JobContext jobContext) throws Throwable {
        // TODO B類型Job的邏輯
        return null;
    }
}

(12.2) TaskTracker的JobRunner測試

一般在編寫TaskTracker的時候，只需要測試JobRunner的實現邏輯是否正確，又不想啟動LTS進行遠程測試。為了方便測試，LTS提供了JobRunner的快捷測試方法。自己的測試類集成com.github.ltsopensource.tasktracker.runner.JobRunnerTester即可，並實現initContext和newJobRunner方法即可。如lts-examples中的例子：

public class TestJobRunnerTester extends JobRunnerTester {

    public static void main(String[] args) throws Throwable {
        //  Mock Job 數據
        Job job = new Job();
        job.setTaskId("2313213");

        JobContext jobContext = new JobContext();
        jobContext.setJob(job);

        JobExtInfo jobExtInfo = new JobExtInfo();
        jobExtInfo.setRetry(false);

        jobContext.setJobExtInfo(jobExtInfo);

        // 運行測試
        TestJobRunnerTester tester = new TestJobRunnerTester();
        Result result = tester.run(jobContext);
        System.out.println(JSON.toJSONString(result));
    }

    @Override
    protected void initContext() {
        // TODO 初始化Spring容器
    }

    @Override
    protected JobRunner newJobRunner() {
        return new TestJobRunner();
    }
}

(12.3) Spring Quartz Cron任務無縫接入

對於Quartz的Cron任務只需要在Spring配置中增加一下代碼就可以接入LTS平台

<bean class="com.github.ltsopensource.spring.quartz.QuartzLTSProxyBean">
    <property name="clusterName" value="test_cluster"/>
    <property name="registryAddress" value="zookeeper://127.0.0.1:2181"/>
    <property name="nodeGroup" value="quartz_test_group"/>
</bean>

(12.4) Spring Boot 支持

@SpringBootApplication
@EnableJobTracker       // 啟動JobTracker
@EnableJobClient        // 啟動JobClient
@EnableTaskTracker      // 啟動TaskTracker
@EnableMonitor          // 啟動Monitor
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

剩下的就只是在application.properties中添加相應的配置就行了, 具體見lts-example中的com.github.ltsopensource.examples.springboot包下的例子

---

輕量級分布式任務調度框架LTS系列

輕量級分布式任務調度框架(一、LTS簡介、特點、工作流程)
輕量級分布式任務調度框架(二、LTS編譯、打包、部署)
輕量級分布式任務調度框架(三、LTS簡單集成springboot項目)