lts1.7.2源代码

+*.js linguist-language=Java
+*.html linguist-language=Java
+*.css linguist-language=Java
\ No newline at end of file

+*.iml
+.idea
+.DS_Store
+target
+/dist/

+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

+
+# LTS用户文档
+	
+LTS(light-task-scheduler)主要用于解决分布式任务调度问题，支持实时任务，定时任务和Cron任务。有较好的伸缩性，扩展性，健壮稳定性而被多家公司使用，同时也希望开源爱好者一起贡献。
+
+## ---> 底部有招人帖 
+
+## 项目地址
+github地址:
+[https://github.com/ltsopensource/light-task-scheduler](https://github.com/ltsopensource/light-task-scheduler)
+
+oschina地址:
+[http://git.oschina.net/hugui/light-task-scheduler](http://git.oschina.net/hugui/light-task-scheduler)
+
+例子: 
+[https://github.com/ltsopensource/lts-examples](https://github.com/ltsopensource/lts-examples)
+
+文档地址(正在更新中,后面以这个为准):
+[https://www.gitbook.com/book/qq254963746/lts/details](https://www.gitbook.com/book/qq254963746/lts/details)
+
+这两个地址都会同步更新。感兴趣，请加QQ群：109500214 (加群密码: hello world)一起探讨、完善。越多人支持，就越有动力去更新，喜欢记得右上角star哈。
+
+## 1.7.2-SNAPSHOT(master)变更主要点
+1. 优化JobContext中的BizLogger，由原来的去掉了threadlocal，解决taskTracker多线程的问题, 去掉LtsLoggerFactory.getLogger()用法
+
+## 框架概况
+LTS 有主要有以下四种节点：
+
+* JobClient：主要负责提交任务, 并接收任务执行反馈结果。
+* JobTracker：负责接收并分配任务，任务调度。
+* TaskTracker：负责执行任务，执行完反馈给JobTracker。
+* LTS-Admin：（管理后台）主要负责节点管理，任务队列管理，监控管理等。
+
+其中JobClient，JobTracker，TaskTracker节点都是`无状态`的。
+可以部署多个并动态的进行删减，来实现负载均衡，实现更大的负载量, 并且框架采用FailStore策略使LTS具有很好的容错能力。 
+
+LTS注册中心提供多种实现（Zookeeper，redis等），注册中心进行节点信息暴露，master选举。(Mongo or Mysql)存储任务队列和任务执行日志, netty or mina做底层通信, 并提供多种序列化方式fastjson, hessian2, java等。
+
+LTS支持任务类型：
+
+* 实时任务：提交了之后立即就要执行的任务。
+* 定时任务：在指定时间点执行的任务，譬如 今天3点执行（单次）。
+* Cron任务：CronExpression，和quartz类似（但是不是使用quartz实现的）譬如 0 0/1 * * * ?
+
+支持动态修改任务参数,任务执行时间等设置,支持后台动态添加任务,支持Cron任务暂停,支持手动停止正在执行的任务(有条件),支持任务的监控统计,支持各个节点的任务执行监控,JVM监控等等.
+
+## 架构图
+
+![LTS architecture](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_architecture.png?dir=0&filepath=docs%2FLTS_architecture.png&oid=262a5234534e2d9fa8862f3e632c5551ebd95e21&sha=d01be5d59e8d768f49bbdc66c8334c37af8f7af5)
+
+## 概念说明
+
+### 节点组
+1. 英文名称 NodeGroup,一个节点组等同于一个小的集群，同一个节点组中的各个节点是对等的，等效的，对外提供相同的服务。
+2. 每个节点组中都有一个master节点，这个master节点是由LTS动态选出来的，当一个master节点挂掉之后，LTS会立马选出另外一个master节点，框架提供API监听接口给用户。
+
+### FailStore
+1. 顾名思义，这个主要是用于失败了存储的，主要用于节点容错，当远程数据交互失败之后，存储在本地，等待远程通信恢复的时候，再将数据提交。
+2. FailStore主要用户JobClient的任务提交，TaskTracker的任务反馈，TaskTracker的业务日志传输的场景下。
+3. FailStore目前提供几种实现：leveldb,rocksdb,berkeleydb,mapdb,ltsdb，用于可以自由选择使用哪种,用户也可以采用SPI扩展使用自己的实现。
+
+
+## 流程图
+下图是一个标准的实时任务执行流程。
+
+![LTS progress](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_progress.png?dir=0&filepath=docs%2FLTS_progress.png&oid=22f60a83b51b26bac8dabbb5053ec9913cefc45c&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+
+## LTS-Admin新版界面预览
+
+![LTS Admin](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS-Admin/LTS-Admin-cron-job-queue.png?dir=0&filepath=docs%2FLTS-Admin%2FLTS-Admin-cron-job-queue.png&oid=aecaf01bca5270a53b144891baaa3d7e56d47706&sha=a4fd9f31df9e1fc6d389a16bdc8d1964bb854766)
+目前后台带有由[ztajy](https://github.com/ztajy)提供的一个简易的认证功能. 用户名密码在auth.cfg中,用户自行修改.
+
+## 特性
+### 1、Spring支持
+LTS可以完全不用Spring框架，但是考虑到很用用户项目中都是用了Spring框架，所以LTS也提供了对Spring的支持，包括Xml和注解，引入`lts-spring.jar`即可。
+### 2、业务日志记录器
+在TaskTracker端提供了业务日志记录器，供应用程序使用，通过这个业务日志器，可以将业务日志提交到JobTracker，这些业务日志可以通过任务ID串联起来，可以在LTS-Admin中实时查看任务的执行进度。
+### 3、SPI扩展支持
+SPI扩展可以达到零侵入，只需要实现相应的接口，并实现即可被LTS使用，目前开放出来的扩展接口有
+
+1. 对任务队列的扩展，用户可以不选择使用mysql或者mongo作为队列存储，也可以自己实现。
+2. 对业务日志记录器的扩展，目前主要支持console，mysql，mongo，用户也可以通过扩展选择往其他地方输送日志。
+
+### 4、故障转移
+当正在执行任务的TaskTracker宕机之后，JobTracker会立马将分配在宕机的TaskTracker的所有任务再分配给其他正常的TaskTracker节点执行。
+### 5、节点监控
+可以对JobTracker，TaskTracker节点进行资源监控，任务监控等，可以实时的在LTS-Admin管理后台查看，进而进行合理的资源调配。
+### 6、多样化任务执行结果支持
+LTS框架提供四种执行结果支持，`EXECUTE_SUCCESS`，`EXECUTE_FAILED`，`EXECUTE_LATER`，`EXECUTE_EXCEPTION`，并对每种结果采取相应的处理机制，譬如重试。
+
+* EXECUTE_SUCCESS: 执行成功,这种情况，直接反馈客户端（如果任务被设置了要反馈给客户端）。
+* EXECUTE_FAILED：执行失败，这种情况，直接反馈给客户端，不进行重试。
+* EXECUTE_LATER：稍后执行（需要重试），这种情况，不反馈客户端，重试策略采用1min，2min，3min的策略，默认最大重试次数为10次，用户可以通过参数设置修改这个重试次数。
+* EXECUTE_EXCEPTION：执行异常, 这种情况也会重试(重试策略，同上)
+
+### 7、FailStore容错
+采用FailStore机制来进行节点容错，Fail And Store，不会因为远程通信的不稳定性而影响当前应用的运行。具体FailStore说明，请参考概念说明中的FailStore说明。
+
+## 项目编译打包
+项目主要采用maven进行构建，目前提供shell脚本的打包。
+环境依赖：`Java(jdk1.6+)` `Maven`
+
+用户使用一般分为两种：
+### 1、Maven构建
+可以通过maven命令将lts的jar包上传到本地仓库中。在父pom.xml中添加相应的repository，并用deploy命令上传即可。具体引用方式可以参考lts中的例子即可。
+### 2、直接Jar引用
+需要将lts的各个模块打包成单独的jar包，并且将所有lts依赖包引入。具体引用哪些jar包可以参考lts中的例子即可。
+
+## 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的文件结构
+
+```java
+-- 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`日志，启动成功在日志中会打印出访问地址，用户可以通过这个访问地址访问了。
+
+## JobClient（部署）使用
+需要引入lts的jar包有`lts-jobclient-{version}.jar`，`lts-core-{version}.jar` 及其它第三方依赖jar。
+### API方式启动
+```java
+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);
+```
+    
+### Spring XML方式启动
+```java
+<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>
+```    
+### Spring 全注解方式
+```java
+@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();
+    }
+}
+```
+## TaskTracker(部署使用)
+需要引入lts的jar包有`lts-tasktracker-{version}.jar`，`lts-core-{version}.jar` 及其它第三方依赖jar。
+### 定义自己的任务执行类
+```java
+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, "执行成功了，哈哈");
+    }
+}
+```
+### API方式启动
+```java 
+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();
+```
+### Spring XML方式启动
+```java
+<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>
+```
+### Spring注解方式启动
+```java
+@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();
+    }
+}
+```
+## 参数说明
+[参数说明](https://qq254963746.gitbooks.io/lts/content/use/config-name.html)
+
+## 使用建议
+一般在一个JVM中只需要一个JobClient实例即可，不要为每种任务都新建一个JobClient实例，这样会大大的浪费资源，因为一个JobClient可以提交多种任务。相同的一个JVM一般也尽量保持只有一个TaskTracker实例即可，多了就可能造成资源浪费。当遇到一个TaskTracker要运行多种任务的时候，请参考下面的 "一个TaskTracker执行多种任务"。
+## 一个TaskTracker执行多种任务
+有的时候，业务场景需要执行多种任务，有些人会问，是不是要每种任务类型都要一个TaskTracker去执行。我的答案是否定的，如果在一个JVM中，最好使用一个TaskTracker去运行多种任务，因为一个JVM中使用多个TaskTracker实例比较浪费资源（当然当你某种任务量比较多的时候，可以将这个任务单独使用一个TaskTracker节点来执行）。那么怎么才能实现一个TaskTracker执行多种任务呢。下面是我给出来的参考例子。
+
+```java
+/**
+ * 总入口，在 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;
+    }
+}
+```
+## TaskTracker的JobRunner测试
+一般在编写TaskTracker的时候，只需要测试JobRunner的实现逻辑是否正确，又不想启动LTS进行远程测试。为了方便测试，LTS提供了JobRunner的快捷测试方法。自己的测试类集成`com.github.ltsopensource.tasktracker.runner.JobRunnerTester`即可，并实现`initContext`和`newJobRunner`方法即可。如[lts-examples](https://github.com/ltsopensource/lts-examples)中的例子：
+
+```java
+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();
+    }
+}
+```
+
+## Spring Quartz Cron任务无缝接入
+对于Quartz的Cron任务只需要在Spring配置中增加一下代码就可以接入LTS平台
+
+```xml
+<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>
+```
+## Spring Boot 支持
+
+```java
+@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的流量走外网网卡，那么需要在host中，把主机名称的映射地址改为外网网卡地址即可，内网同理。
+
+## 关于节点标识问题
+如果在节点启动的时候设置节点标识,LTS会默认设置一个UUID为节点标识,可读性会比较差,但是能保证每个节点的唯一性,如果用户能自己保证节点标识的唯一性,可以通过 `setIdentity` 来设置,譬如如果每个节点都是部署在一台机器(一个虚拟机)上,那么可以将identity设置为主机名称
+
+## SPI扩展说明
+支持JobLogger,JobQueue等等的SPI扩展
+
+## [和其它解决方案比较](https://qq254963746.gitbooks.io/lts/content/introduce/compareother.html)
+
+
+## LTS-Admin使用jetty启动(默认)，不定期挂掉解决方案
+见[issue#389](https://github.com/ltsopensource/light-task-scheduler/issues/389)
+
+
+# 招人！！！
+工作年限  三年以上
+
+学历要求  本科
+
+期望层级  P6(资深Java工程师)/P7(技术专家)
+
+岗位描述  
+
+会员平台，负责阿里巴巴集团的用户体系，支持集团内各线业务线用户类需求，支持集团对外合作的用户通和业务通。
+包括各个端的用户登录&授权、Session体系、注册、账户管理、账户安全等功能，底层的用户信息服务，会话和凭证管理等等，是集团最核心的产品线之一，每天承载千亿次调用量、峰值千万QPS、以及分布全球的混合云架构等等。
+
+作为软件工程师，你将会在我们的核心产品上工作，这些产品为我们的商业基础设施提供关键功能，
+取决于你的兴趣和经验，你可以在如下的一个或多个领域工作：全球化，用户体验，数据安全，机器学习，系统高可用性等等。
+
+1. 独立完成中小型项目的系统分析、设计，并主导完成详细设计和编码的任务，确保项目的进度和质量； 
+2. 能够在团队中完成code review的任务，确保相关代码的有效性和正确性，并能够通过code review提供相关性能以及稳定性的建议； 
+3. 参与建设通用、灵活、智能的业务支撑平台，支撑上层多场景的复杂业务。
+岗位要求  
+1. 扎实的java编程基础，熟悉常用的Java开源框架； 
+2. 具有基于数据库、缓存、分布式存储开发高性能、高可用数据应用的实际经验，熟练掌握LINUX操作系统； 
+3. 具备良好的识别和设计通用框架及模块的能力； 
+4. 热爱技术，工作认真、严谨，对系统质量有近乎苛刻的要求意识，善于沟通与团队协作；     
+5. 具备大型电子商务网站或金融行业核心系统开发、设计工作经验者优先；
+6. 具备大数据处理、算法、机器学习类工作经验优先。
+感兴趣，可以发简历到 hugui.hg@alibaba-inc.com 欢迎投递

+@echo off
+
+start mvn clean install -DskipTests
+echo "LTS: mvn clean install -DskipTests"
+echo "LTS: After sub window finished, close it , and press any key to continue" & pause>nul
+
+set VERSION=1.7.2-SNAPSHOT
+set BASE_HOME=%~dp0%
+set DIST_BIN_DIR=lts-%VERSION%-bin
+
+md "%BASE_HOME%\dist"
+md "%BASE_HOME%\dist\%DIST_BIN_DIR%"
+
+set LTS_Bin_Dir=%BASE_HOME%dist\%DIST_BIN_DIR%
+
+set Startup_Dir=%BASE_HOME%\lts-startup
+cd %Startup_Dir%
+start mvn clean assembly:assembly -DskipTests -Pdefault
+echo "LTS: mvn clean assembly:assembly -DskipTests -Pdefault"
+echo "LTS: After sub window finished, close it , and press any key to continue" & pause>nul
+
+xcopy /e /y "%Startup_Dir%\target\lts-bin\lts" "%LTS_Bin_Dir%"
+cd ..\..\
+
+cd %Startup_Dir%
+start mvn clean assembly:assembly -DskipTests -Plts-admin
+echo "LTS: mvn clean assembly:assembly -DskipTests -Plts-admin"
+echo "LTS: After sub window finished, close it , and press any key to continue" & pause>nul
+
+xcopy /e /y "%Startup_Dir%\target\lts-bin\lts\lib" "%LTS_Bin_Dir%\war\jetty\lib"
+cd ..\..\
+
+xcopy /e /y "%BASE_HOME%\lts-admin\target\lts-admin-%VERSION%.war" "%LTS_Bin_Dir%\war\lts-admin.war"
+cd ..\..\

+#!/usr/bin/env bash
+
+VERSION="1.7.2-SNAPSHOT"
+
+LTS_BIN="${BASH_SOURCE-$0}"
+LTS_BIN="$(dirname "${LTS_BIN}")"
+LTS_Bin_Dir="$(cd "${LTS_BIN}"; pwd)"
+
+cd $LTS_Bin_Dir
+
+mvn clean install -U -DskipTests
+
+Dist_Bin_Dir="$LTS_Bin_Dir/dist/lts-$VERSION-bin"
+mkdir -p $Dist_Bin_Dir
+
+Dist_Bin_Dir="$(cd "$(dirname "${Dist_Bin_Dir}/.")"; pwd)"
+
+mkdir -p $Dist_Bin_Dir
+
+# 打包
+Startup_Dir="$LTS_Bin_Dir/lts-startup/"
+cd $Startup_Dir
+mvn clean assembly:assembly -DskipTests -Pdefault
+
+cp -rf $Startup_Dir/target/lts-bin/lts/*  $Dist_Bin_Dir
+
+mkdir -p $Dist_Bin_Dir/war/jetty/lib
+mvn clean assembly:assembly -DskipTests -Plts-admin
+cp -rf $Startup_Dir/target/lts-bin/lts/lib  $Dist_Bin_Dir/war/jetty
+cp -rf $LTS_Bin_Dir/lts-admin/target/lts-admin-$VERSION.war $Dist_Bin_Dir/war/lts-admin.war
+
+ cd $LTS_Bin_Dir/dist
+ zip -r lts-$VERSION-bin.zip lts-$VERSION-bin/*
+ rm -rf lts-$VERSION-bin

+```java
+/**
+ * 下面是给的参考示例，
+ * 在其他Spring Bean 中就直接可以使用注解 @Autowired 注入使用了
+ * 这里为了方便起见写在一起的，一般这三种节点是分开的，注意单独写
+ * @author Robert HG (254963746@qq.com) on 8/22/15.
+ */
+@Configuration
+public class LTSSpringConfig implements ApplicationContextAware {
+
+    private ApplicationContext applicationContext;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        this.applicationContext = applicationContext;
+    }
+
+    @Bean(name = "jobClient")
+    public JobClient getJobClient() throws Exception {
+        JobClientFactoryBean factoryBean = new JobClientFactoryBean();
+        // TODO 设置一些配置 属性
+        factoryBean.afterPropertiesSet();
+        // factoryBean.start();
+        return factoryBean.getObject();
+    }
+
+    @Bean(name = "jobTracker")
+    public JobTracker getJobTracker() throws Exception {
+        JobTrackerFactoryBean factoryBean = new JobTrackerFactoryBean();
+        // TODO 设置一些配置 属性
+        factoryBean.afterPropertiesSet();
+        // factoryBean.start();
+        return factoryBean.getObject();
+    }
+    
+    @Bean(name = "taskTracker")
+    public TaskTracker getTaskTracker() throws Exception {
+        TaskTrackerAnnotationFactoryBean factoryBean = new TaskTrackerAnnotationFactoryBean();
+        factoryBean.setApplicationContext(applicationContext);
+        // TODO 设置一些配置 属性
+        factoryBean.afterPropertiesSet();
+        // factoryBean.start();
+        return factoryBean.getObject(); 
+    }
+}
+```

+# LTS用户文档
+	
+LTS(light-task-scheduler)主要用于解决分布式任务调度问题，支持实时任务，定时任务和Cron任务。有较好的伸缩性，扩展性，健壮稳定性而被多家公司使用，同时也希望开源爱好者一起贡献。
+
+## 项目地址
+github地址:
+[https://github.com/ltsopensource/light-task-scheduler](https://github.com/ltsopensource/light-task-scheduler)
+
+oschina地址:
+[http://git.oschina.net/hugui/light-task-scheduler](http://git.oschina.net/hugui/light-task-scheduler)
+
+这两个地址都会同步更新。感兴趣，请加QQ群：109500214 一起探讨、完善。越多人支持，就越有动力去更新，喜欢记得右上角star哈。
+
+## 框架概况
+LTS 有主要有以下四种节点：
+
+* JobClient：主要负责提交任务, 并接收任务执行反馈结果。
+* JobTracker：负责接收并分配任务，任务调度。
+* TaskTracker：负责执行任务，执行完反馈给JobTracker。
+* LTS-Admin：（管理后台）主要负责节点管理，任务队列管理，监控管理等。
+
+其中JobClinet，JobTracker，TaskTracker节点都是`无状态`的。
+可以部署多个并动态的进行删减，来实现负载均衡，实现更大的负载量, 并且框架采用FailStore策略使LTS具有很好的容错能力。 
+
+LTS注册中心提供多种实现（Zookeeper，redis等），注册中心进行节点信息暴露，master选举。(Mongo or Mysql)存储任务队列和任务执行日志, netty做底层通信。
+
+LTS支持任务类型：
+
+* 实时任务：提交了之后立即就要执行的任务。
+* 定时任务：在指定时间点执行的任务，譬如 今天3点执行（单次）。
+* Cron任务：CronExpression，和quartz类似（但是不是使用quartz实现的）譬如 0 0/1 * * * ?
+
+## 架构图
+
+![LTS architecture](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_architecture.png?dir=0&filepath=docs%2FLTS_architecture.png&oid=1e5daa62b8d032daaa47eab4a84ab1d4c8962c33&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+
+## 概念说明
+
+###节点组
+1. 英文名称 NodeGroup,一个节点组等同于一个小的集群，同一个节点组中的各个节点是对等的，等效的，对外提供相同的服务。
+2. 没个节点组中都有一个master节点，这个master节点是由LTS动态选出来的，当一个master节点挂掉之后，LTS会立马选出另外一个master节点，框架提供API监听接口给用户。
+
+###FailStore
+1. 顾名思义，这个主要是用于失败了存储的，主要用于节点容错，当远程数据交互失败之后，存储在本地，等待远程通信恢复的时候，再将数据提交。
+2. FailStore主要用户JobClient的任务提交，TaskTracker的任务反馈，TaskTracker的业务日志传输的场景下。
+3. FailStore目前提供三种实现：leveldb，rocksdb，berkeleydb，用于可以自由选择使用哪种。
+
+
+## 流程图
+下图是一个标准的实时任务执行流程。
+
+![LTS progress](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_progress.png?dir=0&filepath=docs%2FLTS_progress.png&oid=22f60a83b51b26bac8dabbb5053ec9913cefc45c&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+
+##特性
+###1、Spring支持
+LTS可以完全不用Spring框架，但是考虑到很用用户项目中都是用了Spring框架，所以LTS也提供了对Spring的支持，包括Xml和注解，引入`lts-spring.jar`即可。
+###2、业务日志记录器
+在TaskTracker端提供了业务日志记录器，供应用程序使用，通过这个业务日志器，可以将业务日志提交到JobTracker，这些业务日志可以通过任务ID串联起来，可以在LTS-Admin中实时查看任务的执行进度。
+###3、SPI扩展支持
+SPI扩展可以达到零侵入，只需要实现相应的接口，并实现即可被LTS使用，目前开放出来的扩展接口有
+
+1. 对任务队列的扩展，用户可以不选择使用mysql或者mongo作为队列存储，也可以自己实现。
+2. 对业务日志记录器的扩展，目前主要支持console，mysql，mongo，用户也可以通过扩展选择往其他地方输送日志。
+
+###4、故障转移
+当正在执行任务的TaskTracker宕机之后，JobTracker会立马分配在宕机的TaskTracker的所有任务再分配给其他正常的TaskTracker节点执行。
+###5、节点监控
+可以对JobTracker，TaskTracker节点进行资源监控，任务监控等，可以实时的在LTS-Admin管理后台查看，进而进行合理的资源调配。
+###6、多样化任务执行结果支持
+LTS框架提供四种执行结果支持，`EXECUTE_SUCCESS`，`EXECUTE_FAILED`，`EXECUTE_LATER`，`EXECUTE_EXCEPTION`，并对每种结果采取相应的处理机制，譬如重试。
+
+* EXECUTE_SUCCESS: 执行成功,这种情况，直接反馈客户端（如果任务被设置了要反馈给客户端）。
+* EXECUTE_FAILED：执行失败，这种情况，直接反馈给客户端，不进行重试。
+* EXECUTE_LATER：稍后执行（需要重试），这种情况，不反馈客户端，重试策略采用1min，2min，3min的策略，默认最大重试次数为10次，用户可以通过参数设置修改这个重试次数。
+* EXECUTE_EXCEPTION：执行异常, 这中情况也会重试(重试策略，同上)
+
+###7、FailStore容错
+采用FailStore机制来进行节点容错，Fail And Store，不会因为远程通信的不稳定性而影响当前应用的运行。具体FailStore说明，请参考概念说明中的FailStore说明。
+
+##项目编译打包
+项目主要采用maven进行构建，目前提供shell脚本的打包。
+环境依赖：`Java(jdk1.7)` `Maven`
+
+用户使用一般分为两种：
+###1、Maven构建
+可以通过maven命令将lts的jar包上传到本地仓库中。在父pom.xml中添加相应的repository，并用deploy命令上传即可。具体引用方式可以参考lts中的例子即可。
+###2、直接Jar引用
+需要将lts的各个模块打包成单独的jar包，并且将所有lts依赖包引入。具体引用哪些jar包可以参考lts中的例子即可。
+
+##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的文件结构
+
+```java
+├── bin
+│   ├── jobtracker.cmd
+│   ├── jobtracker.sh
+│   ├── lts-admin.cmd
+│   └── lts-admin.sh
+├── jobtracker
+│   ├── conf
+│   │   └── zoo
+│   │       ├── jobtracker.cfg
+│   │       └── log4j.properties
+│   └── lib
+│       └── *.jar
+├── lts-admin
+│   ├── conf
+│   │   ├── log4j.properties
+│   │   └── lts-admin.cfg
+│   ├── lib
+│   │   └── *.jar
+│   └── lts-admin.war
+└── tasktracker
+    ├── bin
+    │   └── tasktracker.sh
+    ├── conf
+    │   ├── log4j.properties
+    │   └── tasktracker.cfg
+    └── lib
+        └── *.jar
+```	    
+        
+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启动.修改`lts-admin/conf`下的配置，然后运行`bin`下的`sh lts-admin.sh`或`lts-admin.cmd`脚本即可。logs文件夹下会生成`lts-admin.out`日志，启动成功在日志中会打印出访问地址，用户可以通过这个访问地址访问了。
+
+##JobClient（部署）使用
+需要引入lts的jar包有`lts-jobclient-{version}.jar`，`lts-core-{version}.jar` 及其它第三方依赖jar。
+###API方式启动
+```java
+JobClient jobClient = new RetryJobClient();
+jobClient.setNodeGroup("test_jobClient");
+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);
+```
+    
+###Spring XML方式启动
+```java
+<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>
+```    
+###Spring 全注解方式
+```java
+@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();
+    }
+}
+```
+##TaskTracker(部署使用)
+需要引入lts的jar包有`lts-tasktracker-{version}.jar`，`lts-core-{version}.jar` 及其它第三方依赖jar。
+###定义自己的任务执行类
+```java
+public class MyJobRunner implements JobRunner {
+    @Override
+    public Result run(JobContext jobContext) throws Throwable {
+        try {
+            BizLogger bizLogger = jobContext.getBizLogger();
+            // TODO 业务逻辑
+            // 会发送到 LTS (JobTracker上)
+            bizLogger.info("测试，业务日志啊啊啊啊啊");
+
+        } catch (Exception e) {
+            return new Result(Action.EXECUTE_FAILED, e.getMessage());
+        }
+        return new Result(Action.EXECUTE_SUCCESS, "执行成功了，哈哈");
+    }
+}
+```
+###API方式启动
+```java 
+TaskTracker taskTracker = new TaskTracker();
+taskTracker.setJobRunnerClass(MyJobRunner.class);
+taskTracker.setRegistryAddress("zookeeper://127.0.0.1:2181");
+taskTracker.setNodeGroup("test_trade_TaskTracker");
+taskTracker.setWorkThreads(20);
+taskTracker.start();
+```
+###Spring XML方式启动
+```java
+<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>
+```
+###Spring注解方式启动
+```java
+@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();
+    }
+}
+```
+##参数说明
+
+| 参数  | 是否必须  | 默认值 | 使用范围 | 设置方式|参数说明 |
+|:------------- |:------------- |:---------------:|:---------------:| -------------:| -------------:|
+|registryAddress|必须|无|JobClient,JobTracker,TaskTracker|setRegistryAddress("xxxx")|注册中心，可以选用zk或者redis，参考值: zookeeper://127.0.0.1:2181|
+|clusterName|必须|无|JobClient,JobTracker,TaskTracker|setClusterName("xxxx")|集群名称，clusterName相同的所有节点才会组成整个LTS架构|
+|listenPort|必须|35001|JobTracker|setListenPort(xxx)|JobTracker的远程监听端口|
+|job.logger|必须|console|JobTracker|addConfig("job.logger","xxx")|LTS业务日志记录器，可选值console,mysql,mongo,或者自己实现SPI扩展|
+|job.queue|必须|mongo|JobTracker|addConfig("job.queue", "xx")|LTS任务队列,可选值mongo,mysql,或者自己实现SPI扩展|
+|jdbc.url|可选|无|JobTracker|addConfig("jdbc.url", "xxx")|mysql连接URL，当job.queue为mysql的时候起作用|
+|jdbc.username|可选|无|JobTracker|addConfig("jdbc.username", "xxx")|mysql连接密码,当job.queue为mysql的时候起作用|
+|jdbc.password|可选|无|JobTracker|addConfig("jdbc.password", "xxx")|mysql连接密码,当job.queue为mysql的时候起作用|
+|mongo.addresses|可选|无|JobTracker|addConfig("mongo.addresses", "xxx")|mongo连接URL,当job.queue为mongo的时候起作用|
+|mongo.database|可选|无|JobTracker|addConfig("mongo.database", "xxx")|mongo数据库名,当job.queue为mongo的时候起作用|
+|zk.client|可选|zkclient|JobClient,JobTracker,TaskTracker|addConfig("zk.client", "xxx")|zookeeper客户端,可选值zkclient, curator|
+|job.pull.frequency|可选|3|TaskTracker|addConfig("job.pull.frequency", "xx")|TaskTracker去向JobTracker Pull任务的频率，针对不同的场景可以做相应的调整，单位秒|
+|job.max.retry.times|可选|10|JobTracker|addConfig("job.max.retry.times", "xx")|任务的最大重试次数|
+|stop.working|可选|false|TaskTracker|addConfig("stop.working", "true")|主要用于当TaskTracker与JobTracker出现网络隔离的时候，超过一定时间隔离之后，TaskTracker自动停止当前正在运行的任务|
+
+
+
+##使用建议
+一般在一个JVM中只需要一个JobClient实例即可，不要为每种任务都新建一个JobClient实例，这样会大大的浪费资源，因为一个JobClient可以提交多种任务。相同的一个JVM一般也尽量保持只有一个TaskTracker实例即可，多了就可能造成资源浪费。当遇到一个TaskTracker要运行多种任务的时候，请参考下面的 "一个TaskTracker执行多种任务"。
+##一个TaskTracker执行多种任务
+有的时候，业务场景需要执行多种任务，有些人会问，是不是要每种任务类型都要一个TaskTracker去执行。我的答案是否定的，如果在一个JVM中，最好使用一个TaskTracker去运行多种任务，因为一个JVM中使用多个TaskTracker实例比较浪费资源（当然当你某种任务量比较多的时候，可以将这个任务单独使用一个TaskTracker节点来执行）。那么怎么才能实现一个TaskTracker执行多种任务呢。下面是我给出来的参考例子。
+
+```java
+/**
+ * 总入口，在 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(Job job) throws Throwable {
+        String type = job.getParam("type");
+        return JOB_RUNNER_MAP.get(type).run(job);
+    }
+}
+
+class JobRunnerA implements JobRunner {
+    @Override
+    public Result run(Job job) throws Throwable {
+        //  TODO A类型Job的逻辑
+        return null;
+    }
+}
+
+class JobRunnerB implements JobRunner {
+    @Override
+    public Result run(Job job) throws Throwable {
+        // TODO B类型Job的逻辑
+        return null;
+    }
+}
+```
+##SPI扩展说明
+###LTS-Logger扩展
+1. 引入`lts-core-{version}.jar`
+2. 实现`JobLogger`和`JobLoggerFactory`接口
+3. 在 resources `META-INF/lts/com.github.ltsopensource.biz.logger.JobLoggerFactory`文件,文件内容为`xxx=com.github.ltsopensource.biz.logger.xxx.XxxJobLoggerFactory`
+4. 使用自己的logger扩展，修改jobtracker参数配置 configs.job.logger=xxx。（如果你自己引入JobTracker jar包的方式的话，使用 `jobtracker.addConfig("job.logger", "xxx"))`
+
+###LTS-Queue扩展
+实现方式和LTS-Logger扩展类似，具体参考`lts-queue-mysql`或`lts-queue-mongo`模块的实现
+##和其它解决方案比较
+###和MQ比较
+见docs/LTS业务场景说明.pdf
+###和Quartz比较
+见docs/LTS业务场景说明.pdf
+
+
+

+LTS 轻量级分布式任务调度框架(Light Task Scheduler)
+-----------------
+
+###框架概况：
+ LTS是一个轻量级分布式任务调度框架。有三种角色, JobClient, JobTracker, TaskTracker。各个节点都是无状态的，可以部署多个，来实现负载均衡，实现更大的负载量, 并且框架具有很好的容错能力。
+ 采用多种注册中心（Zookeeper，redis等）进行节点信息暴露，master选举。(Mongo or Mysql)存储任务队列和任务执行日志, netty做底层通信。
+* JobClient : 主要负责提交任务, 和 接收任务执行反馈结果。
+* JobTracker : 负责接收并分配任务，任务调度。
+* TaskTracker: 负责执行任务，执行完反馈给JobTracker。
+
+支持任务类型:
+* 实时任务 
+* 也支持定时任务 (如：3天之后执行)
+* CronExpression (如:0 0/1 * * * ?) 
+
+感兴趣，请加QQ群：109500214 一起探讨、完善。越多人支持，就越有动力去更新，喜欢记得右上角star哈。
+
+github地址:[https://github.com/ltsopensource/light-task-scheduler](https://github.com/ltsopensource/light-task-scheduler) 
+
+###架构图
+![Aaron Swartz](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_architecture.png?dir=0&filepath=docs%2FLTS_architecture.png&oid=1e5daa62b8d032daaa47eab4a84ab1d4c8962c33&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+####节点组:
+* 1. 一个节点组等同于一个集群，同一个节点组中的各个节点是对等的，外界无论连接节点组中的任务一个节点都是可以的。
+* 2. 每个节点组中都有一个master节点(master宕机，会自动选举出新的master节点)，框架会提供接口API来监听master节点的变化，用户可以自己使用master节点做自己想做的事情。
+* 3. JobClient和TaskTracker都可以存在多个节点组。譬如 JobClient 可以存在多个节点组。 譬如：JobClient 节点组为 ‘lts_WEB’ 中的一个节点提交提交一个 只有节点组为’lts_TRADE’的 TaskTracker 才能执行的任务。
+* 4. (每个集群中)JobTacker只有一个节点组。
+* 5. 多个JobClient节点组和多个TaskTracker节点组再加上一个JobTacker节点组, 组成一个大的集群。
+
+###工作流程:
+* 1. JobClient 提交一个 任务 给 JobTracker, 这里我提供了两种客户端API, 一种是如果JobTracker 不存在或者提交失败，直接返回提交失败。另一种客户端是重试客户端, 如果提交失败，先存储到本地FailStore(可以使用NFS来达到同个节点组共享leveldb文件的目的,多线程访问,已经做了文件锁处理)，返回给客户端提交成功的信息，待JobTracker可用的时候，再将任务提交。
+* 2. JobTracker收到JobClient提交来的任务,将任务存入任务队列。JobTracker等待TaskTracker的Pull请求，然后将任务Push给TaskTracker去执行。
+* 3. TaskTracker收到JobTracker分发来的任务之后，然后从线程池中拿到一个线程去执行。执行完毕之后，再反馈任务执行结果给JobTracker（成功or 失败[失败有失败错误信息]），如果发现JobTacker不可用，那么存储本地FailStore，等待JobTracker可用的时候再反馈。反馈结果的同时，询问JobTacker有没有新的任务要执行。
+* 4. JobTacker收到TaskTracker节点的任务结果信息。根据任务信息决定要不要反馈给客户端。不需要反馈的直接删除,需要反馈的,直接反馈,反馈失败进入FeedbackQueue, 等待重新反馈。
+* 5. JobClient收到任务执行结果，进行自己想要的逻辑处理。
+* 详细请查看 [流程图](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_progress.png?dir=0&filepath=docs%2FLTS_progress.png&oid=22f60a83b51b26bac8dabbb5053ec9913cefc45c&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+
+###特性
+* 负载均衡:
+     * JobClient和TaskTracker可是根据自己设置的负载均衡策略来请求JobTracker节点组中的一个节点。当连接上后将一直保持连接这个节点,保持连接通道，直到这个节点不可用,减少每次都重新连接一个节点带来的性能开销。
+
+* 健壮性:
+     * 当节点组中的一个节点当机之后，自动转到其他节点工作。当整个节点组当机之后，将会采用存储文件的方式，待节点组可用的时候进行重发。
+     * 当执行任务的TaskTracker节点当机之后，JobTracker会将这个TaskTracker上的未完成的任务(死任务)，重新分配给节点组中其他节点执行。
+
+* 伸缩性：
+     * 因为各个节点都是无状态的，可以动态增加机器部署实例, 节点关注者会自动发现。
+* 扩展性:
+     * 采用和dubbo一样的SPI扩展方式，可以实现任务队列扩展，日志记录器扩展等
+
+###日志记录
+对于任务的分发，执行，还有用户通过 (BizLogger)  【JobContext#getBizLogger()】 输入的业务日志，LTS都有记录，用户可以在LTS Admin 后台界面查看某个任务的所有日志，可以实时查看这个任务的执行情况。 
+
+###开发计划：
+* WEB后台管理：性能统计分析，预警等
+* 实现LTS的分布式队列存储
+
+###LTS Admin
+后台首页  [http://localhost:8081/main.html](http://localhost:8081/main.html)
+
+![Aaron Swartz](http://git.oschina.net/hugui/light-task-scheduler/raw/master/docs/LTS_Admin.png?dir=0&filepath=docs%2FLTS_Admin.png&oid=a53f98823a0451a80a34467c7dfa2a01d568a9e2&sha=774aa73d186470aedbb8f4da3c04a86a6022be05)
+###调用示例
+下面提供的是最简单的配置方式。更多配置请查看 [lts-example](https://github.com/ltsopensource/light-task-scheduler/tree/master/lts-example/src/main/java/com/lts/example/api) 模块下的 API 调用方式例子.
+
+####JobTracker 端
+```java
+    final JobTracker jobTracker = new JobTracker();
+    // 节点信息配置
+    jobTracker.setRegistryAddress("zookeeper://127.0.0.1:2181");
+    // 1. 任务队列用mongo
+    jobTracker.addConfig("job.queue", "mongo");
+    // mongo 配置
+    jobTracker.addConfig("mongo.addresses", "127.0.0.1:27017"); 
+    jobTracker.addConfig("mongo.database", "lts");
+    jobTracker.setOldDataHandler(new OldDataDeletePolicy());
+    // 启动节点
+    jobTracker.start();
+```
+
+#### TaskTracker端
+```java
+    TaskTracker taskTracker = new TaskTracker();
+    taskTracker.setJobRunnerClass(TestJobRunner.class);
+    taskTracker.setRegistryAddress("zookeeper://127.0.0.1:2181");
+    taskTracker.setNodeGroup("test_trade_TaskTracker");
+    taskTracker.setWorkThreads(20);
+    taskTracker.start();
+    // 任务执行类
+    public class TestJobRunner implements JobRunner {
+        @Override
+        public void run(Job job) throws Throwable {
+            System.out.println("我要执行"+ job);
+            System.out.println(job.getParam("shopId"));
+            // TODO 用户自己的业务逻辑, 应该保证幂等
+            try {
+                Thread.sleep(5*1000L);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+```
+
+#### JobClient端
+```java
+    JobClient jobClient = new RetryJobClient();
+    // final JobClient jobClient = new JobClient();
+    jobClient.setNodeGroup("test_jobClient");
+    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);
+```
+
+##更新
+1.5.5
+1. 添加自动编译打包, LTS-Admin和JobTracker的shell脚本运行
+
+1.5.4.1 
+* 增加TaskTracker的监控数据，LTS-admin可以查看
+
+1.5.4:
+* 1. 增加 lts-spring 工程对spring的支持 (见lts-example 中spring文件夹下的例子)
+* 2. 对于TaskTracker 同时支持 JobRunner 中 注解注入bean 和xml注入的方式
\ No newline at end of file

+# 查看远程地址
+git remote -v
+
+# 添加新的远程地址
+git remote add osc https://git.oschina.net/hugui/light-task-scheduler.git
+git remote add github https://github.com/ltsopensource/light-task-scheduler.git
+
+# 推送develop的本地分支git, 所有分支的话使用--all
+git push -u osc develop
+git push -u github develop
+
+#推送所有的标签
+git push osc --tags
+git push github --tags
+
+#从远处拉取标签
+git fetch osc --tags
+git fetch github --tags
+
+# 查询远程标签
+git ls-remote --tags osc
+git ls-remote --tags github
+
+
+
+##
+~/Data/Software/apache-maven-3.2.5/bin/mvn clean install -U -DskipTests
+~/Data/Software/apache-maven-3.2.5/bin/mvn clean deploy -DskipTests
+~/Data/Software/apache-maven-3.2.5/bin/mvn clean deploy -P release -Dgpg.passphrase=密码 -DskipTests
+

+
+###包引入说明
+
+####1. JobTracker,JobClient,TaskTracker都需要引入的包
+
+#####1.1 lts-core
+
+```java
+<dependency>
+    <groupId>com.github.ltsopensource</groupId>
+    <artifactId>lts-core</artifactId>
+    <version>${lts版本号}</version>
+</dependency>
+```
+
+#####1.2 zk客户端包 
+二选一, 通过 addConfig("zk.client", "可选值: curator, zkclient, lts") 设置, 如果用lts,可以不用引入包
+
+`zkclient`
+
+```java
+<dependency>
+    <groupId>com.github.sgroschupf</groupId>
+    <artifactId>zkclient</artifactId>
+    <version>0.1</version>
+</dependency>
+```
+
+`curator`
+
+```java
+<dependency>
+    <groupId>org.apache.curator</groupId>
+    <artifactId>curator-recipes</artifactId>
+    <version>2.9.1</version>
+</dependency>
+```
+
+`zookeeper包`
+
+```java
+<dependency>
+    <groupId>org.apache.zookeeper</groupId>
+    <artifactId>zookeeper</artifactId>
+    <version>${zk.version}</version>
+    <exclusions>
+        <exclusion>
+            <groupId>org.jboss.netty</groupId>
+            <artifactId>netty</artifactId>
+        </exclusion>
+        <exclusion>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+        </exclusion>
+    </exclusions>
+</dependency>
+```
+
+#####1.3 通讯包
+netty或者mina, 二选一, 通过 addConfig("lts.remoting", "可选值: netty, mina") 设置
+
+`netty`
+
+```java
+<dependency>
+    <groupId>io.netty</groupId>
+    <artifactId>netty-all</artifactId>
+    <version>4.0.20.Final</version>
+</dependency>
+```
+
+`mina`
+
+```java
+<dependency>
+    <groupId>org.apache.mina</groupId>
+    <artifactId>mina-core</artifactId>
+    <version>2.0.9</version>
+</dependency>
+```
+
+#####1.4 json包
+fastjson或者jackson, 二选一, 通过 addConfig("lts.json", "可选值: fastjson, jackson") 设置
+
+`fastjson`
+
+```java
+<dependency>
+    <groupId>com.alibaba</groupId>
+    <artifactId>fastjson</artifactId>
+    <version>1.2.7</version>
+</dependency>
+```
+
+`jackson`
+
+```java
+<dependency>
+    <groupId>com.fasterxml.jackson.core</groupId>
+    <artifactId>jackson-core</artifactId>
+    <version>2.6.3</version>
+</dependency>
+<dependency>
+    <groupId>com.fasterxml.jackson.core</groupId>
+    <artifactId>jackson-databind</artifactId>
+    <version>2.6.3</version>
+</dependency>
+```
+
+#####1.5 日志包
+可以选用 slf4j, jcl, log4j, 或者使用jdk原生logger
+
+LoggerFactory.setLoggerAdapter("可选值: slf4j, jcl, log4j, jdk"), 不手动设置, 默认按这个顺序加载
+
+
+`log4j`
+
+```java
+<dependency>
+    <groupId>log4j</groupId>
+    <artifactId>log4j</artifactId>
+    <version>1.2.16</version>
+</dependency>
+```
+
+`slf4j`
+
+```java
+<dependency>
+    <groupId>org.slf4j</groupId>
+    <artifactId>slf4j-api</artifactId>
+    <version>1.7.5</version>
+</dependency>
+<dependency>
+    <groupId>org.slf4j</groupId>
+    <artifactId>slf4j-log4j12</artifactId>
+    <version>1.7.5</version>
+</dependency>
+```
+
+`jcl`
+
+```java
+<dependency>
+    <groupId>commons-logging</groupId>
+    <artifactId>commons-logging-api</artifactId>
+    <version>1.1</version>
+</dependency>
+```
+
+#####1.6 如果需要spring的话,需要引入lts-spring及spring的相关包
+
+```java
+<dependency>
+    <groupId>com.github.ltsopensource</groupId>
+    <artifactId>lts-spring</artifactId>
+    <version>${lts版本号}</version>
+</dependency>
+```
+
+####2. 对于JobTracker端
+
+#####2.1 必须引入的包:
+
+```java
+<dependency>
+    <groupId>com.github.ltsopensource</groupId>
+    <artifactId>lts-jobtracker</artifactId>
+    <version>${lts版本号}</version>
+</dependency>
+```
+
+#####2.2 除了基础包之外还需要引入任务队列的包(可以是mongo或者mysql) 
+
+`mysql`
+
+```java
+<dependency>
+    <groupId>mysql</groupId>
+    <artifactId>mysql-connector-java</artifactId>
+    <version>5.1.26</version>
+</dependency>
+<dependency>
+    <groupId>com.alibaba</groupId>
+    <artifactId>druid</artifactId>
+    <version>1.0.14</version>
+</dependency>
+```
+
+`mongo`
+
+```java
+<dependency>
+    <groupId>org.mongodb.morphia</groupId>
+    <artifactId>morphia</artifactId>
+    <version>1.0.0-rc1</version>
+</dependency>
+<dependency>
+    <groupId>org.mongodb</groupId>
+    <artifactId>mongo-java-driver</artifactId>
+    <version>3.0.2</version>
+</dependency>
+```
+
+####3. JobClient需要引入的包
+
+必须引入的包
+
+```java
+<dependency>
+    <groupId>com.github.ltsopensource</groupId>
+    <artifactId>lts-jobclient</artifactId>
+    <version>${project.version}</version>
+</dependency>
+```
+
+FailStore存储包(四选一)
+
+通过 jobClient.addConfig("job.fail.store", "可选值: leveldb, mapdb, berkeleydb, rocksdb") 设置
+
+```java
+<!--mapdb -->
+<dependency>
+    <groupId>org.mapdb</groupId>
+    <artifactId>mapdb</artifactId>
+    <version>2.0-beta10</version>
+</dependency>
+<!-- leveldb -->
+<dependency>
+    <groupId>org.fusesource.leveldbjni</groupId>
+    <artifactId>leveldbjni-all</artifactId>
+    <version>1.2.7<version>
+</dependency>
+<!-- berkeleydb  -->
+<dependency>
+    <groupId>com.sleepycat</groupId>
+    <artifactId>je</artifactId>
+    <version>5.0.73</version>
+</dependency>
+<!-- rocksdb -->
+<dependency>
+    <groupId>org.rocksdb</groupId>
+    <artifactId>rocksdbjni</artifactId>
+    <version>3.10.1</version>
+</dependency>
+```
+
+####3. TaskTracker需要引入的包
+
+必须引入的包
+
+```java
+<dependency>
+    <groupId>com.github.ltsopensource</groupId>
+    <artifactId>lts-tasktracker</artifactId>
+    <version>${project.version}</version>
+</dependency>
+```
+
+FailStore存储包(四选一)
+
+通过 taskTracker.addConfig("job.fail.store", "可选值: leveldb, mapdb, berkeleydb, rocksdb") 设置
+
+```java
+<!--mapdb -->
+<dependency>
+    <groupId>org.mapdb</groupId>
+    <artifactId>mapdb</artifactId>
+    <version>2.0-beta10</version>
+</dependency>
+<!-- leveldb -->
+<dependency>
+    <groupId>org.fusesource.leveldbjni</groupId>
+    <artifactId>leveldbjni-all</artifactId>
+    <version>1.2.7<version>
+</dependency>
+<!-- berkeleydb  -->
+<dependency>
+    <groupId>com.sleepycat</groupId>
+    <artifactId>je</artifactId>
+    <version>5.0.73</version>
+</dependency>
+<!-- rocksdb -->
+<dependency>
+    <groupId>org.rocksdb</groupId>
+    <artifactId>rocksdbjni</artifactId>
+    <version>3.10.1</version>
+</dependency>
+```
+

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>lts-parent</artifactId>
+        <groupId>com.github.ltsopensource</groupId>
+        <version>1.7.2-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <packaging>war</packaging>
+    <artifactId>lts-admin</artifactId>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.tomcat.maven</groupId>
+                <artifactId>tomcat7-maven-plugin</artifactId>
+                <version>2.2</version>
+                <configuration>
+                    <path>/</path>
+                    <port>8081</port>
+                    <server>tomcat</server>
+                    <warFile>lts-admin.war</warFile>
+                    <uriEncoding>utf-8</uriEncoding>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.github.ltsopensource</groupId>
+            <artifactId>lts-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.ltsopensource</groupId>
+            <artifactId>lts-monitor</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.github.sgroschupf</groupId>
+            <artifactId>zkclient</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjrt</artifactId>
+            <version>${aspectj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+            <version>${aspectj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <version>${springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>${springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context-support</artifactId>
+            <version>${springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>${springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-orm</artifactId>
+            <version>${springframework.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>3.1.0</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>jstl</artifactId>
+            <version>1.2</version>
+        </dependency>
+
+        <!-- Just the annotations; use this dependency if you want to attach annotations
+             to classes without connecting them to the code. -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-annotations</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+
+        <!-- databinding; ObjectMapper, JsonNode and related classes are here -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- smile (binary JSON). Other artifacts in this group do other formats. -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-smile</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <!-- JAX-RS provider -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.jaxrs</groupId>
+            <artifactId>jackson-jaxrs-json-provider</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <!-- Support for JAX-B annotations as additional configuration -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.module</groupId>
+            <artifactId>jackson-module-jaxb-annotations</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.velocity</groupId>
+            <artifactId>velocity</artifactId>
+            <version>1.7</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.velocity</groupId>
+            <artifactId>velocity-tools</artifactId>
+            <version>2.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.struts</groupId>
+                    <artifactId>struts-tiles</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.struts</groupId>
+                    <artifactId>struts-taglib</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.struts</groupId>
+                    <artifactId>struts-core</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>commons-chain</groupId>
+                    <artifactId>commons-chain</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>commons-lang</groupId>
+                    <artifactId>commons-lang</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>commons-validator</groupId>
+                    <artifactId>commons-validator</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>oro</groupId>
+                    <artifactId>oro</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>sslext</groupId>
+                    <artifactId>sslext</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>dom4j</groupId>
+                    <artifactId>dom4j</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.mongodb.morphia</groupId>
+            <artifactId>morphia</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.mongodb</groupId>
+            <artifactId>mongo-java-driver</artifactId>
+        </dependency>
+    </dependencies>
+</project>

+package com.github.ltsopensource.admin.access;
+
+import com.github.ltsopensource.admin.access.face.*;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.core.constant.ExtConfig;
+import com.github.ltsopensource.core.spi.SPI;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+@SPI(key = ExtConfig.ACCESS_DB, dftValue = "mysql")
+public interface BackendAccessFactory {
+
+    BackendJobTrackerMAccess getJobTrackerMAccess(Config config);
+
+    BackendJobClientMAccess getBackendJobClientMAccess(Config config);
+
+    BackendJVMGCAccess getBackendJVMGCAccess(Config config);
+
+    BackendJVMMemoryAccess getBackendJVMMemoryAccess(Config config);
+
+    BackendJVMThreadAccess getBackendJVMThreadAccess(Config config);
+
+    BackendNodeOnOfflineLogAccess getBackendNodeOnOfflineLogAccess(Config config);
+
+    BackendTaskTrackerMAccess getBackendTaskTrackerMAccess(Config config);
+}

+package com.github.ltsopensource.admin.access;
+
+import com.github.ltsopensource.admin.access.domain.NodeOnOfflineLog;
+import com.github.ltsopensource.admin.web.vo.NodeInfo;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.cluster.NodeType;
+import com.github.ltsopensource.monitor.access.domain.*;
+import com.github.ltsopensource.store.jdbc.dbutils.ResultSetHandler;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class RshHandler {
+
+    public static final ResultSetHandler<List<Node>> NODE_LIST_RSH = new ResultSetHandler<List<Node>>() {
+        @Override
+        public List<Node> handle(ResultSet rs) throws SQLException {
+            List<Node> nodes = new ArrayList<Node>();
+
+            while (rs.next()) {
+                nodes.add(getNodeByRs(rs));
+            }
+            return nodes;
+        }
+    };
+
+    public static final ResultSetHandler<Node> NODE_RSH = new ResultSetHandler<Node>() {
+        @Override
+        public Node handle(ResultSet rs) throws SQLException {
+            if (rs.next()) {
+                return getNodeByRs(rs);
+            }
+            return null;
+        }
+    };
+
+    private static Node getNodeByRs(final ResultSet rs) throws SQLException {
+        Node node = new Node();
+        node.setIdentity(rs.getString("identity"));
+        node.setClusterName(rs.getString("cluster_name"));
+        node.setNodeType(NodeType.valueOf(rs.getString("node_type")));
+        node.setIp(rs.getString("ip"));
+        node.setPort(rs.getInt("port"));
+        node.setGroup(rs.getString("node_group"));
+        node.setCreateTime(rs.getLong("create_time"));
+        node.setThreads(rs.getInt("threads"));
+        node.setAvailable(rs.getInt("available") == 1);
+        node.setHostName(rs.getString("host_name"));
+        node.setHttpCmdPort(rs.getInt("http_cmd_port"));
+        return node;
+    }
+
+    public static final ResultSetHandler<List<JobTrackerMDataPo>> JOB_TRACKER_SUM_M_DATA_RSH = new ResultSetHandler<List<JobTrackerMDataPo>>() {
+        @Override
+        public List<JobTrackerMDataPo> handle(ResultSet rs) throws SQLException {
+
+            List<JobTrackerMDataPo> list = new ArrayList<JobTrackerMDataPo>();
+
+            while (rs.next()) {
+                JobTrackerMDataPo po = new JobTrackerMDataPo();
+//                po.setId(rs.getString("id"));
+//                po.setGmtCreated(rs.getLong("gmt_created"));
+                po.setTimestamp(rs.getLong("timestamp"));
+//                po.setNodeType(NodeType.convert(rs.getString("node_type")));
+//                po.setNodeGroup(rs.getString("node_group"));
+//                po.setIdentity(rs.getString("identity"));
+                po.setReceiveJobNum(rs.getLong("receive_job_num"));
+                po.setPushJobNum(rs.getLong("push_job_num"));
+                po.setExeSuccessNum(rs.getLong("exe_success_num"));
+                po.setExeFailedNum(rs.getLong("exe_failed_num"));
+                po.setExeLaterNum(rs.getLong("exe_later_num"));
+                po.setExeExceptionNum(rs.getLong("exe_exception_num"));
+                po.setFixExecutingJobNum(rs.getLong("fix_executing_job_num"));
+                list.add(po);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<NodeOnOfflineLog>> NODE_ON_OFFLINE_LOG_LIST_RSH = new ResultSetHandler<List<NodeOnOfflineLog>>() {
+        @Override
+        public List<NodeOnOfflineLog> handle(ResultSet rs) throws SQLException {
+
+            List<NodeOnOfflineLog> list = new ArrayList<NodeOnOfflineLog>();
+            while (rs.next()) {
+                NodeOnOfflineLog log = new NodeOnOfflineLog();
+                log.setLogTime(rs.getTimestamp("log_time"));
+                log.setEvent(rs.getString("event"));
+                log.setNodeType(NodeType.convert(rs.getString("node_type")));
+                log.setClusterName(rs.getString("cluster_name"));
+                log.setIp(rs.getString("ip"));
+                log.setPort(rs.getInt("port"));
+                log.setHostName(rs.getString("host_name"));
+                log.setGroup(rs.getString("group"));
+                log.setCreateTime(rs.getLong("create_time"));
+                log.setThreads(rs.getInt("threads"));
+                log.setIdentity(rs.getString("identity"));
+                log.setHttpCmdPort(rs.getInt("http_cmd_port"));
+                list.add(log);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<TaskTrackerMDataPo>> TASK_TRACKER_SUM_M_DATA_RSH = new ResultSetHandler<List<TaskTrackerMDataPo>>() {
+        @Override
+        public List<TaskTrackerMDataPo> handle(ResultSet rs) throws SQLException {
+            List<TaskTrackerMDataPo> list = new ArrayList<TaskTrackerMDataPo>();
+
+            while (rs.next()) {
+                TaskTrackerMDataPo po = new TaskTrackerMDataPo();
+                po.setTimestamp(rs.getLong("timestamp"));
+
+                po.setExeSuccessNum(rs.getLong("exe_success_num"));
+                po.setExeFailedNum(rs.getLong("exe_failed_num"));
+                po.setExeLaterNum(rs.getLong("exe_later_num"));
+                po.setExeExceptionNum(rs.getLong("exe_exception_num"));
+                po.setTotalRunningTime(rs.getLong("total_running_time"));
+
+                list.add(po);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<JobClientMDataPo>> JOB_CLIENT_SUM_M_DATA_RSH = new ResultSetHandler<List<JobClientMDataPo>>() {
+        @Override
+        public List<JobClientMDataPo> handle(ResultSet rs) throws SQLException {
+            List<JobClientMDataPo> list = new ArrayList<JobClientMDataPo>();
+
+            while (rs.next()) {
+                JobClientMDataPo po = new JobClientMDataPo();
+                po.setTimestamp(rs.getLong("timestamp"));
+
+                po.setSubmitSuccessNum(rs.getLong("submit_success_num"));
+                po.setSubmitFailedNum(rs.getLong("submit_failed_num"));
+                po.setFailStoreNum(rs.getLong("fail_store_num"));
+                po.setSubmitFailStoreNum(rs.getLong("submit_fail_store_num"));
+                po.setHandleFeedbackNum(rs.getLong("handle_feedback_num"));
+                list.add(po);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<NodeInfo>> NODE_INFO_LIST_RSH = new ResultSetHandler<List<NodeInfo>>() {
+        @Override
+        public List<NodeInfo> handle(ResultSet rs) throws SQLException {
+            List<NodeInfo> list = new ArrayList<NodeInfo>();
+
+            while (rs.next()) {
+                NodeInfo nodeInfo = new NodeInfo();
+                nodeInfo.setIdentity(rs.getString("identity"));
+                nodeInfo.setNodeGroup(rs.getString("node_group"));
+                list.add(nodeInfo);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<JVMMemoryDataPo>> JVM_MEMORY_SUM_M_DATA_RSH = new ResultSetHandler<List<JVMMemoryDataPo>>() {
+        @Override
+        public List<JVMMemoryDataPo> handle(ResultSet rs) throws SQLException {
+            List<JVMMemoryDataPo> list = new ArrayList<JVMMemoryDataPo>();
+
+            while (rs.next()) {
+                JVMMemoryDataPo po = new JVMMemoryDataPo();
+                po.setTimestamp(rs.getLong("timestamp"));
+
+                po.setHeapMemoryCommitted(rs.getLong("heap_memory_committed"));
+                po.setHeapMemoryInit(rs.getLong("heap_memory_init"));
+                po.setHeapMemoryMax(rs.getLong("heap_memory_max"));
+                po.setHeapMemoryUsed(rs.getLong("heap_memory_used"));
+                po.setNonHeapMemoryCommitted(rs.getLong("non_heap_memory_committed"));
+                po.setNonHeapMemoryInit(rs.getLong("non_heap_memory_init"));
+                po.setNonHeapMemoryMax(rs.getLong("non_heap_memory_max"));
+                po.setNonHeapMemoryUsed(rs.getLong("non_heap_memory_used"));
+                po.setPermGenCommitted(rs.getLong("perm_gen_committed"));
+                po.setPermGenInit(rs.getLong("perm_gen_init"));
+                po.setPermGenMax(rs.getLong("perm_gen_max"));
+                po.setPermGenUsed(rs.getLong("perm_gen_used"));
+                po.setOldGenCommitted(rs.getLong("old_gen_committed"));
+                po.setOldGenInit(rs.getLong("old_gen_init"));
+                po.setOldGenMax(rs.getLong("old_gen_max"));
+                po.setOldGenUsed(rs.getLong("old_gen_used"));
+                po.setEdenSpaceCommitted(rs.getLong("eden_space_committed"));
+                po.setEdenSpaceInit(rs.getLong("eden_space_init"));
+                po.setEdenSpaceMax(rs.getLong("eden_space_max"));
+                po.setEdenSpaceUsed(rs.getLong("eden_space_used"));
+                po.setSurvivorCommitted(rs.getLong("survivor_committed"));
+                po.setSurvivorInit(rs.getLong("survivor_init"));
+                po.setSurvivorMax(rs.getLong("survivor_max"));
+                po.setSurvivorUsed(rs.getLong("survivor_used"));
+
+                list.add(po);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<JVMGCDataPo>> JVM_GC_SUM_M_DATA_RSH = new ResultSetHandler<List<JVMGCDataPo>>() {
+        @Override
+        public List<JVMGCDataPo> handle(ResultSet rs) throws SQLException {
+            List<JVMGCDataPo> list = new ArrayList<JVMGCDataPo>();
+
+            while (rs.next()) {
+                JVMGCDataPo po = new JVMGCDataPo();
+                po.setTimestamp(rs.getLong("timestamp"));
+
+                po.setYoungGCCollectionCount(rs.getLong("young_gc_collection_count"));
+                po.setYoungGCCollectionTime(rs.getLong("young_gc_collection_time"));
+                po.setFullGCCollectionCount(rs.getLong("full_gc_collection_count"));
+                po.setFullGCCollectionTime(rs.getLong("full_gc_collection_time"));
+                po.setSpanYoungGCCollectionCount(rs.getLong("span_young_gc_collection_count"));
+                po.setSpanYoungGCCollectionTime(rs.getLong("span_young_gc_collection_time"));
+                po.setSpanFullGCCollectionCount(rs.getLong("span_full_gc_collection_count"));
+                po.setSpanFullGCCollectionTime(rs.getLong("span_full_gc_collection_time"));
+
+                list.add(po);
+            }
+            return list;
+        }
+    };
+
+    public static final ResultSetHandler<List<JVMThreadDataPo>> JVM_THREAD_SUM_M_DATA_RSH = new ResultSetHandler<List<JVMThreadDataPo>>() {
+        @Override
+        public List<JVMThreadDataPo> handle(ResultSet rs) throws SQLException {
+            List<JVMThreadDataPo> list = new ArrayList<JVMThreadDataPo>();
+
+            while (rs.next()) {
+                JVMThreadDataPo po = new JVMThreadDataPo();
+                po.setTimestamp(rs.getLong("timestamp"));
+
+                po.setDaemonThreadCount(rs.getInt("daemon_thread_count"));
+                po.setThreadCount(rs.getInt("thread_count"));
+                po.setTotalStartedThreadCount(rs.getLong("total_started_thread_count"));
+                po.setDeadLockedThreadCount(rs.getInt("dead_locked_thread_count"));
+                po.setProcessCpuTimeRate(rs.getDouble("process_cpu_time_rate"));
+                list.add(po);
+            }
+            return list;
+        }
+    };
+}

+package com.github.ltsopensource.admin.access.domain;
+
+import com.github.ltsopensource.core.cluster.NodeType;
+
+import java.util.Date;
+
+/**
+ * 用来记录节点的上下线
+ *
+ * @author Robert HG (254963746@qq.com) on 9/26/15.
+ */
+public class NodeOnOfflineLog {
+
+    // 日志时间
+    private Date logTime;
+    // 取值 ONLINE(上线) OFFLINE(离线)
+    private String event;
+
+    /**
+     * 下面属性来自
+     * {@link com.github.ltsopensource.core.cluster.Node}
+     */
+    private String clusterName;
+    private String ip;
+    private Integer port;
+    private String hostName;
+    private String group;
+    private Long createTime;
+    private Integer threads;
+    private String identity;
+    private NodeType nodeType;
+    private Integer httpCmdPort;
+
+    public NodeType getNodeType() {
+        return nodeType;
+    }
+
+    public void setNodeType(NodeType nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public Date getLogTime() {
+        return logTime;
+    }
+
+    public void setLogTime(Date logTime) {
+        this.logTime = logTime;
+    }
+
+    public String getEvent() {
+        return event;
+    }
+
+    public void setEvent(String event) {
+        this.event = event;
+    }
+
+    public String getClusterName() {
+        return clusterName;
+    }
+
+    public void setClusterName(String clusterName) {
+        this.clusterName = clusterName;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public Integer getPort() {
+        return port;
+    }
+
+    public void setPort(Integer port) {
+        this.port = port;
+    }
+
+    public String getHostName() {
+        return hostName;
+    }
+
+    public void setHostName(String hostName) {
+        this.hostName = hostName;
+    }
+
+    public String getGroup() {
+        return group;
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    public Long getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(Long createTime) {
+        this.createTime = createTime;
+    }
+
+    public Integer getThreads() {
+        return threads;
+    }
+
+    public void setThreads(Integer threads) {
+        this.threads = threads;
+    }
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public Integer getHttpCmdPort() {
+        return httpCmdPort;
+    }
+
+    public void setHttpCmdPort(Integer httpCmdPort) {
+        this.httpCmdPort = httpCmdPort;
+    }
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.monitor.access.domain.JVMGCDataPo;
+import com.github.ltsopensource.monitor.access.face.JVMGCAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/28/15.
+ */
+public interface BackendJVMGCAccess extends JVMGCAccess {
+
+    void delete(JvmDataReq request);
+
+    List<JVMGCDataPo> queryAvg(MDataPaginationReq request);
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.monitor.access.domain.JVMMemoryDataPo;
+import com.github.ltsopensource.monitor.access.face.JVMMemoryAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/28/15.
+ */
+public interface BackendJVMMemoryAccess extends JVMMemoryAccess{
+
+    void delete(JvmDataReq request);
+
+    List<JVMMemoryDataPo> queryAvg(MDataPaginationReq request);
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.monitor.access.domain.JVMThreadDataPo;
+import com.github.ltsopensource.monitor.access.face.JVMThreadAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/28/15.
+ */
+public interface BackendJVMThreadAccess extends JVMThreadAccess {
+
+    void delete(JvmDataReq request);
+
+    List<JVMThreadDataPo> queryAvg(MDataPaginationReq request);
+
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.admin.web.vo.NodeInfo;
+import com.github.ltsopensource.monitor.access.domain.JobClientMDataPo;
+import com.github.ltsopensource.monitor.access.face.JobClientMAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/12/16.
+ */
+public interface BackendJobClientMAccess extends JobClientMAccess {
+
+    void delete(MDataPaginationReq request);
+
+    List<JobClientMDataPo> querySum(MDataPaginationReq request);
+
+    List<NodeInfo> getJobClients();
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.monitor.access.domain.JobTrackerMDataPo;
+import com.github.ltsopensource.monitor.access.face.JobTrackerMAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/22/15.
+ */
+public interface BackendJobTrackerMAccess extends JobTrackerMAccess {
+
+    List<JobTrackerMDataPo> querySum(MDataPaginationReq request);
+
+    void delete(MDataPaginationReq request);
+
+    List<String> getJobTrackers();
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.access.domain.NodeOnOfflineLog;
+import com.github.ltsopensource.admin.request.NodeOnOfflineLogPaginationReq;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/26/15.
+ */
+public interface BackendNodeOnOfflineLogAccess {
+
+    void insert(List<NodeOnOfflineLog> nodeOnOfflineLogs);
+
+    List<NodeOnOfflineLog> select(NodeOnOfflineLogPaginationReq request);
+
+    Long count(NodeOnOfflineLogPaginationReq request);
+
+    void delete(NodeOnOfflineLogPaginationReq request);
+
+}

+package com.github.ltsopensource.admin.access.face;
+
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.admin.web.vo.NodeInfo;
+import com.github.ltsopensource.monitor.access.domain.TaskTrackerMDataPo;
+import com.github.ltsopensource.monitor.access.face.TaskTrackerMAccess;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/22/15.
+ */
+public interface BackendTaskTrackerMAccess extends TaskTrackerMAccess{
+
+    List<TaskTrackerMDataPo> querySum(MDataPaginationReq request);
+
+    void delete(MDataPaginationReq request);
+
+    List<NodeInfo> getTaskTrackers();
+}

+package com.github.ltsopensource.admin.access.memory;
+
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.core.commons.file.FileUtils;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.constant.Constants;
+import com.github.ltsopensource.core.exception.LtsRuntimeException;
+import com.github.ltsopensource.store.jdbc.SqlTemplate;
+import com.github.ltsopensource.store.jdbc.SqlTemplateFactory;
+import com.github.ltsopensource.store.jdbc.exception.JdbcException;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Memory-Only Databases , HSQLDB
+ *
+ * @author Robert HG (254963746@qq.com) on 6/6/15.
+ */
+public abstract class MemoryAccess {
+
+    private SqlTemplate sqlTemplate;
+
+    public MemoryAccess() {
+        Config config = new Config();
+        config.setIdentity(StringUtils.generateUUID());
+        config.setParameter("jdbc.datasource.provider", "h2");
+        // see http://www.h2database.com/html/features.html#in_memory_databases
+        config.setParameter("jdbc.url", "jdbc:h2:mem:lts_admin;DB_CLOSE_DELAY=-1");
+        config.setParameter("jdbc.username", "lts");
+        config.setParameter("jdbc.password", "lts");
+        sqlTemplate = SqlTemplateFactory.create(config);
+    }
+
+    protected SqlTemplate getSqlTemplate() {
+        return sqlTemplate;
+    }
+
+    protected String readSqlFile(String path) {
+        InputStream is = this.getClass().getClassLoader().getResourceAsStream(path);
+        try {
+            return FileUtils.read(is, Constants.CHARSET);
+        } catch (IOException e) {
+            throw new LtsRuntimeException("Read sql file : [" + path + "] error ", e);
+        }
+    }
+
+    protected void createTable(String sql) throws JdbcException {
+        try {
+            getSqlTemplate().createTable(sql);
+        } catch (Exception e) {
+            throw new JdbcException("Create table error, sql=" + sql, e);
+        }
+    }
+}

+package com.github.ltsopensource.admin.access.memory;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.request.NodePaginationReq;
+import com.github.ltsopensource.admin.response.PaginationRsp;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.cluster.NodeType;
+import com.github.ltsopensource.core.commons.utils.CharacterUtils;
+import com.github.ltsopensource.core.commons.utils.CollectionUtils;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.logger.Logger;
+import com.github.ltsopensource.core.logger.LoggerFactory;
+import com.github.ltsopensource.store.jdbc.builder.*;
+import com.github.ltsopensource.store.jdbc.dbutils.JdbcTypeUtils;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 6/6/15.
+ */
+public class NodeMemCacheAccess extends MemoryAccess {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(NodeMemCacheAccess.class);
+
+    public NodeMemCacheAccess() {
+        createTable(readSqlFile("sql/h2/lts_node.sql"));
+    }
+
+    private String getTableName() {
+        return "lts_node";
+    }
+
+    public void addNode(List<Node> nodes) {
+        for (Node node : nodes) {
+            try {
+                NodePaginationReq request = new NodePaginationReq();
+                request.setIdentity(node.getIdentity());
+                List<Node> existNodes = search(request);
+                if (CollectionUtils.isNotEmpty(existNodes)) {
+                    // 如果存在,那么先删除
+                    removeNode(existNodes);
+                }
+
+                new InsertSql(getSqlTemplate())
+                        .insert(getTableName())
+                        .columns("identity",
+                                "available",
+                                "cluster_name",
+                                "node_type",
+                                "ip",
+                                "port",
+                                "node_group",
+                                "create_time",
+                                "threads",
+                                "host_name",
+                                "http_cmd_port"
+                        )
+                        .values(node.getIdentity(),
+                                node.isAvailable() ? 1 : 0,
+                                node.getClusterName(),
+                                node.getNodeType().name(),
+                                node.getIp(),
+                                node.getPort(),
+                                node.getGroup(),
+                                node.getCreateTime(),
+                                node.getThreads(),
+                                node.getHostName(),
+                                node.getHttpCmdPort())
+                        .doInsert();
+            } catch (Exception e) {
+                LOGGER.error("Insert {} error!", node, e);
+            }
+        }
+    }
+
+    public void clear() {
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .doDelete();
+    }
+
+    public void removeNode(List<Node> nodes) {
+        for (Node node : nodes) {
+            try {
+                new DeleteSql(getSqlTemplate())
+                        .delete()
+                        .from()
+                        .table(getTableName())
+                        .where("identity = ?", node.getIdentity())
+                        .doDelete();
+            } catch (Exception e) {
+                LOGGER.error("Delete {} error!", node, e);
+            }
+        }
+    }
+
+    public Node getNodeByIdentity(String identity) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .all()
+                .from()
+                .table(getTableName())
+                .where("identity = ?", identity)
+                .single(RshHandler.NODE_RSH);
+    }
+
+    public List<Node> getNodeByNodeType(NodeType nodeType) {
+        NodePaginationReq nodePaginationReq = new NodePaginationReq();
+        nodePaginationReq.setNodeType(nodeType);
+        nodePaginationReq.setLimit(Integer.MAX_VALUE);
+        return search(nodePaginationReq);
+    }
+
+    public List<Node> search(NodePaginationReq request) {
+
+        SelectSql selectSql = new SelectSql(getSqlTemplate())
+                .select()
+                .all()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request));
+        if (StringUtils.isNotEmpty(request.getField())) {
+            selectSql.orderBy()
+                    .column(CharacterUtils.camelCase2Underscore(request.getField()), OrderByType.convert(request.getDirection()));
+        }
+        return selectSql.limit(request.getStart(), request.getLimit())
+                .list(RshHandler.NODE_LIST_RSH);
+    }
+
+    private WhereSql buildWhereSql(NodePaginationReq request) {
+        return new WhereSql()
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andOnNotNull("node_type = ?", request.getNodeType() == null ? null : request.getNodeType().name())
+                .andOnNotEmpty("ip = ?", request.getIp())
+                .andOnNotNull("available = ?", request.getAvailable())
+                .andBetween("create_time", JdbcTypeUtils.toTimestamp(request.getStartDate()), JdbcTypeUtils.toTimestamp(request.getEndDate()));
+    }
+
+    public PaginationRsp<Node> pageSelect(NodePaginationReq request) {
+        PaginationRsp<Node> response = new PaginationRsp<Node>();
+
+        Long results = new SelectSql(getSqlTemplate())
+                .select()
+                .columns("count(1)")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .single();
+        response.setResults(results.intValue());
+
+        if (results > 0) {
+            List<Node> nodes = search(request);
+            response.setRows(nodes);
+        }
+        return response;
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.BackendAccessFactory;
+import com.github.ltsopensource.admin.access.face.*;
+import com.github.ltsopensource.core.cluster.Config;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendAccessFactory implements BackendAccessFactory {
+    @Override
+    public BackendJobTrackerMAccess getJobTrackerMAccess(Config config) {
+        return new MysqlBackendJobTrackerMAccess(config);
+    }
+
+    @Override
+    public BackendJobClientMAccess getBackendJobClientMAccess(Config config) {
+        return new MysqlBackendJobClientMAccess(config);
+    }
+
+    @Override
+    public BackendJVMGCAccess getBackendJVMGCAccess(Config config) {
+        return new MysqlBackendJVMGCAccess(config);
+    }
+
+    @Override
+    public BackendJVMMemoryAccess getBackendJVMMemoryAccess(Config config) {
+        return new MysqlBackendJVMMemoryAccess(config);
+    }
+
+    @Override
+    public BackendJVMThreadAccess getBackendJVMThreadAccess(Config config) {
+        return new MysqlBackendJVMThreadAccess(config);
+    }
+
+    @Override
+    public BackendNodeOnOfflineLogAccess getBackendNodeOnOfflineLogAccess(Config config) {
+        return new MysqlBackendNodeOnOfflineLogAccess(config);
+    }
+
+    @Override
+    public BackendTaskTrackerMAccess getBackendTaskTrackerMAccess(Config config) {
+        return new MysqlBackendTaskTrackerMAccess(config);
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendJVMGCAccess;
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.JVMGCDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlJVMGCAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/10/16.
+ */
+public class MysqlBackendJVMGCAccess extends MysqlJVMGCAccess implements BackendJVMGCAccess {
+
+    public MysqlBackendJVMGCAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public void delete(JvmDataReq request) {
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<JVMGCDataPo> queryAvg(MDataPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "AVG(young_gc_collection_count) AS young_gc_collection_count",
+                        "AVG(young_gc_collection_time) AS young_gc_collection_time",
+                        "AVG(full_gc_collection_count) AS full_gc_collection_count",
+                        "AVG(full_gc_collection_time) AS full_gc_collection_time",
+                        "AVG(span_young_gc_collection_count) AS span_young_gc_collection_count",
+                        "AVG(span_young_gc_collection_time) AS span_young_gc_collection_time",
+                        "AVG(span_full_gc_collection_count) span_full_gc_collection_count",
+                        "AVG(span_full_gc_collection_time) span_full_gc_collection_time")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.JVM_GC_SUM_M_DATA_RSH);
+    }
+
+    public WhereSql buildWhereSql(JvmDataReq req) {
+        return new WhereSql()
+                .andOnNotEmpty("identity = ?", req.getIdentity())
+                .andBetween("timestamp", req.getStartTime(), req.getEndTime());
+
+    }
+
+    public WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotNull("id = ?", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendJVMMemoryAccess;
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.JVMMemoryDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlJVMMemoryAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendJVMMemoryAccess extends MysqlJVMMemoryAccess implements BackendJVMMemoryAccess {
+
+    public MysqlBackendJVMMemoryAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public void delete(JvmDataReq request) {
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<JVMMemoryDataPo> queryAvg(MDataPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "AVG(heap_memory_committed) AS heap_memory_committed",
+                        "AVG(heap_memory_init) AS heap_memory_init",
+                        "AVG(heap_memory_max) AS heap_memory_max",
+                        "AVG(heap_memory_used) AS heap_memory_used",
+                        "AVG(non_heap_memory_committed) AS non_heap_memory_committed",
+                        "AVG(non_heap_memory_init) AS non_heap_memory_init",
+                        "AVG(non_heap_memory_max) AS non_heap_memory_max",
+                        "AVG(non_heap_memory_used) AS non_heap_memory_used",
+                        "AVG(perm_gen_committed) AS perm_gen_committed",
+                        "AVG(perm_gen_init) AS perm_gen_init",
+                        "AVG(perm_gen_max) AS perm_gen_max",
+                        "AVG(perm_gen_used) AS perm_gen_used",
+                        "AVG(old_gen_committed) AS old_gen_committed",
+                        "AVG(old_gen_init) AS old_gen_init",
+                        "AVG(old_gen_max) AS old_gen_max",
+                        "AVG(old_gen_used) AS old_gen_used",
+                        "AVG(eden_space_committed) AS eden_space_committed",
+                        "AVG(eden_space_init) AS eden_space_init",
+                        "AVG(eden_space_max) AS eden_space_max",
+                        "AVG(eden_space_used) AS eden_space_used",
+                        "AVG(survivor_committed) AS survivor_committed",
+                        "AVG(survivor_init) AS survivor_init",
+                        "AVG(survivor_max) AS survivor_max",
+                        "AVG(survivor_used) AS survivor_used")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.JVM_MEMORY_SUM_M_DATA_RSH);
+    }
+
+    public WhereSql buildWhereSql(JvmDataReq req) {
+        return new WhereSql()
+                .andOnNotEmpty("identity = ?", req.getIdentity())
+                .andBetween("timestamp", req.getStartTime(), req.getEndTime());
+
+    }
+
+    public WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotNull("id = ?", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendJVMThreadAccess;
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.JVMThreadDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlJVMThreadAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendJVMThreadAccess extends MysqlJVMThreadAccess implements BackendJVMThreadAccess {
+
+    public MysqlBackendJVMThreadAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public void delete(JvmDataReq request) {
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<JVMThreadDataPo> queryAvg(MDataPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "AVG(daemon_thread_count) AS daemon_thread_count",
+                        "AVG(thread_count) AS thread_count",
+                        "AVG(total_started_thread_count) AS total_started_thread_count",
+                        "AVG(dead_locked_thread_count) AS dead_locked_thread_count",
+                        "AVG(process_cpu_time_rate) AS process_cpu_time_rate")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.JVM_THREAD_SUM_M_DATA_RSH);
+    }
+
+    public WhereSql buildWhereSql(JvmDataReq req) {
+        return new WhereSql()
+                .andOnNotEmpty("identity = ?", req.getIdentity())
+                .andBetween("timestamp", req.getStartTime(), req.getEndTime());
+
+    }
+
+    public WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotNull("id = ?", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendJobClientMAccess;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.admin.web.vo.NodeInfo;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.JobClientMDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlJobClientMAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/12/16.
+ */
+public class MysqlBackendJobClientMAccess extends MysqlJobClientMAccess implements BackendJobClientMAccess {
+
+    public MysqlBackendJobClientMAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public void delete(MDataPaginationReq request) {
+
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<JobClientMDataPo> querySum(MDataPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "SUM(submit_success_num) AS submit_success_num",
+                        "SUM(submit_failed_num) AS submit_failed_num",
+                        "SUM(fail_store_num) AS fail_store_num",
+                        "SUM(submit_fail_store_num) AS submit_fail_store_num",
+                        "SUM(handle_feedback_num) AS handle_feedback_num")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.JOB_CLIENT_SUM_M_DATA_RSH);
+    }
+
+    @Override
+    public List<NodeInfo> getJobClients() {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("DISTINCT identity AS identity", "node_group")
+                .from()
+                .table(getTableName())
+                .list(RshHandler.NODE_INFO_LIST_RSH);
+    }
+
+    public WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotNull("id = ?", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendJobTrackerMAccess;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.JobTrackerMDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlJobTrackerMAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+import com.github.ltsopensource.store.jdbc.dbutils.ResultSetHandler;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendJobTrackerMAccess extends MysqlJobTrackerMAccess implements BackendJobTrackerMAccess {
+
+    public MysqlBackendJobTrackerMAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public List<JobTrackerMDataPo> querySum(MDataPaginationReq request) {
+
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "SUM(receive_job_num) AS receive_job_num",
+                        "SUM(push_job_num) AS push_job_num" ,
+                        "SUM(exe_success_num) AS exe_success_num" ,
+                        "SUM(exe_failed_num) AS exe_failed_num" ,
+                        "SUM(exe_later_num) AS exe_later_num" ,
+                        "SUM(exe_exception_num) AS exe_exception_num" ,
+                        "SUM(fix_executing_job_num) AS fix_executing_job_num")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.JOB_TRACKER_SUM_M_DATA_RSH);
+    }
+
+    private WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotEmpty("id = ? ", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+
+    @Override
+    public void delete(MDataPaginationReq request) {
+
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<String> getJobTrackers() {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("DISTINCT identity AS `identity` ")
+                .from()
+                .table(getTableName())
+                .list(new ResultSetHandler<List<String>>() {
+                    @Override
+                    public List<String> handle(ResultSet rs) throws SQLException {
+                        List<String> list = new ArrayList<String>();
+                        while (rs.next()) {
+                            list.add(rs.getString("identity"));
+                        }
+                        return list;
+                    }
+                });
+    }
+
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.domain.NodeOnOfflineLog;
+import com.github.ltsopensource.admin.access.face.BackendNodeOnOfflineLogAccess;
+import com.github.ltsopensource.admin.request.NodeOnOfflineLogPaginationReq;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.mysql.MysqlAbstractJdbcAccess;
+import com.github.ltsopensource.store.jdbc.builder.*;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendNodeOnOfflineLogAccess extends MysqlAbstractJdbcAccess implements BackendNodeOnOfflineLogAccess {
+
+    public MysqlBackendNodeOnOfflineLogAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "lts_admin_node_onoffline_log";
+    }
+
+    @Override
+    public void insert(List<NodeOnOfflineLog> nodeOnOfflineLogs) {
+        InsertSql insertSql = new InsertSql(getSqlTemplate())
+                .insert(getTableName())
+                .columns("log_time",
+                        "event",
+                        "node_type",
+                        "cluster_name",
+                        "ip",
+                        "port",
+                        "host_name",
+                        "group",
+                        "create_time",
+                        "threads",
+                        "identity",
+                        "http_cmd_port");
+        for (NodeOnOfflineLog nodeOnOfflineLog : nodeOnOfflineLogs) {
+            insertSql.values(nodeOnOfflineLog.getLogTime(),
+                    nodeOnOfflineLog.getEvent(),
+                    nodeOnOfflineLog.getNodeType().name(),
+                    nodeOnOfflineLog.getClusterName(),
+                    nodeOnOfflineLog.getIp(),
+                    nodeOnOfflineLog.getPort(),
+                    nodeOnOfflineLog.getHostName(),
+                    nodeOnOfflineLog.getGroup(),
+                    nodeOnOfflineLog.getCreateTime(),
+                    nodeOnOfflineLog.getThreads(),
+                    nodeOnOfflineLog.getIdentity(),
+                    nodeOnOfflineLog.getHttpCmdPort()
+                    );
+        }
+        insertSql.doBatchInsert();
+    }
+
+    @Override
+    public List<NodeOnOfflineLog> select(NodeOnOfflineLogPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .all()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .orderBy()
+                .column("log_time", OrderByType.DESC)
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.NODE_ON_OFFLINE_LOG_LIST_RSH);
+    }
+
+    @Override
+    public Long count(NodeOnOfflineLogPaginationReq request) {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("count(1)")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .single();
+    }
+
+    @Override
+    public void delete(NodeOnOfflineLogPaginationReq request) {
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    private WhereSql buildWhereSql(NodeOnOfflineLogPaginationReq request){
+        return new WhereSql()
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("group = ?", request.getGroup())
+                .andOnNotEmpty("event = ?", request.getEvent())
+                .andBetween("log_time", request.getStartLogTime(), request.getEndLogTime());
+    }
+}

+package com.github.ltsopensource.admin.access.mysql;
+
+import com.github.ltsopensource.admin.access.RshHandler;
+import com.github.ltsopensource.admin.access.face.BackendTaskTrackerMAccess;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.admin.web.vo.NodeInfo;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.monitor.access.domain.TaskTrackerMDataPo;
+import com.github.ltsopensource.monitor.access.mysql.MysqlTaskTrackerMAccess;
+import com.github.ltsopensource.store.jdbc.builder.DeleteSql;
+import com.github.ltsopensource.store.jdbc.builder.SelectSql;
+import com.github.ltsopensource.store.jdbc.builder.WhereSql;
+
+import java.util.List;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class MysqlBackendTaskTrackerMAccess extends MysqlTaskTrackerMAccess implements BackendTaskTrackerMAccess {
+
+    public MysqlBackendTaskTrackerMAccess(Config config) {
+        super(config);
+    }
+
+    @Override
+    public List<TaskTrackerMDataPo> querySum(MDataPaginationReq request) {
+
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("timestamp",
+                        "SUM(exe_success_num) AS exe_success_num",
+                        "SUM(exe_failed_num) AS exe_failed_num",
+                        "SUM(exe_later_num) AS exe_later_num",
+                        "SUM(exe_exception_num) AS exe_exception_num",
+                        "SUM(total_running_time) AS total_running_time")
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .groupBy(" timestamp ASC ")
+                .limit(request.getStart(), request.getLimit())
+                .list(RshHandler.TASK_TRACKER_SUM_M_DATA_RSH);
+    }
+
+    @Override
+    public void delete(MDataPaginationReq request) {
+
+        new DeleteSql(getSqlTemplate())
+                .delete()
+                .from()
+                .table(getTableName())
+                .whereSql(buildWhereSql(request))
+                .doDelete();
+    }
+
+    @Override
+    public List<NodeInfo> getTaskTrackers() {
+        return new SelectSql(getSqlTemplate())
+                .select()
+                .columns("DISTINCT identity", "node_group")
+                .from()
+                .table(getTableName())
+                .list(RshHandler.NODE_INFO_LIST_RSH);
+    }
+
+    public WhereSql buildWhereSql(MDataPaginationReq request) {
+        return new WhereSql()
+                .andOnNotNull("id = ?", request.getId())
+                .andOnNotEmpty("identity = ?", request.getIdentity())
+                .andOnNotEmpty("node_group = ?", request.getNodeGroup())
+                .andBetween("timestamp", request.getStartTime(), request.getEndTime());
+    }
+}

+package com.github.ltsopensource.admin.cluster;
+
+import com.github.ltsopensource.admin.access.face.*;
+import com.github.ltsopensource.admin.access.memory.NodeMemCacheAccess;
+import com.github.ltsopensource.admin.web.support.NoRelyJobGenerator;
+import com.github.ltsopensource.biz.logger.JobLogger;
+import com.github.ltsopensource.core.AppContext;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.queue.*;
+
+/**
+ * Robert HG (254963746@qq.com) on 6/5/15.
+ */
+public class BackendAppContext extends AppContext {
+
+    private CronJobQueue cronJobQueue;
+    private RepeatJobQueue repeatJobQueue;
+    private ExecutableJobQueue executableJobQueue;
+    private ExecutingJobQueue executingJobQueue;
+    private JobFeedbackQueue jobFeedbackQueue;
+    private SuspendJobQueue suspendJobQueue;
+    private NodeGroupStore nodeGroupStore;
+    private JobLogger jobLogger;
+    private Node node;
+
+    private BackendJobClientMAccess backendJobClientMAccess;
+    private BackendJobTrackerMAccess backendJobTrackerMAccess;
+    private BackendTaskTrackerMAccess backendTaskTrackerMAccess;
+    private BackendJVMGCAccess backendJVMGCAccess;
+    private BackendJVMMemoryAccess backendJVMMemoryAccess;
+    private BackendJVMThreadAccess backendJVMThreadAccess;
+    private BackendNodeOnOfflineLogAccess backendNodeOnOfflineLogAccess;
+
+    private NodeMemCacheAccess nodeMemCacheAccess;
+
+    private NoRelyJobGenerator noRelyJobGenerator;
+
+    private BackendRegistrySrv backendRegistrySrv;
+
+    public Node getNode() {
+        return node;
+    }
+
+    public void setNode(Node node) {
+        this.node = node;
+    }
+
+    public CronJobQueue getCronJobQueue() {
+        return cronJobQueue;
+    }
+
+    public void setCronJobQueue(CronJobQueue cronJobQueue) {
+        this.cronJobQueue = cronJobQueue;
+    }
+
+    public RepeatJobQueue getRepeatJobQueue() {
+        return repeatJobQueue;
+    }
+
+    public void setRepeatJobQueue(RepeatJobQueue repeatJobQueue) {
+        this.repeatJobQueue = repeatJobQueue;
+    }
+
+    public ExecutableJobQueue getExecutableJobQueue() {
+        return executableJobQueue;
+    }
+
+    public void setExecutableJobQueue(ExecutableJobQueue executableJobQueue) {
+        this.executableJobQueue = executableJobQueue;
+    }
+
+    public ExecutingJobQueue getExecutingJobQueue() {
+        return executingJobQueue;
+    }
+
+    public void setExecutingJobQueue(ExecutingJobQueue executingJobQueue) {
+        this.executingJobQueue = executingJobQueue;
+    }
+
+    public SuspendJobQueue getSuspendJobQueue() {
+        return suspendJobQueue;
+    }
+
+    public void setSuspendJobQueue(SuspendJobQueue suspendJobQueue) {
+        this.suspendJobQueue = suspendJobQueue;
+    }
+
+    public NodeGroupStore getNodeGroupStore() {
+        return nodeGroupStore;
+    }
+
+    public void setNodeGroupStore(NodeGroupStore nodeGroupStore) {
+        this.nodeGroupStore = nodeGroupStore;
+    }
+
+    public JobFeedbackQueue getJobFeedbackQueue() {
+        return jobFeedbackQueue;
+    }
+
+    public void setJobFeedbackQueue(JobFeedbackQueue jobFeedbackQueue) {
+        this.jobFeedbackQueue = jobFeedbackQueue;
+    }
+
+    public JobLogger getJobLogger() {
+        return jobLogger;
+    }
+
+    public void setJobLogger(JobLogger jobLogger) {
+        this.jobLogger = jobLogger;
+    }
+
+    public BackendJobClientMAccess getBackendJobClientMAccess() {
+        return backendJobClientMAccess;
+    }
+
+    public void setBackendJobClientMAccess(BackendJobClientMAccess backendJobClientMAccess) {
+        this.backendJobClientMAccess = backendJobClientMAccess;
+    }
+
+    public BackendJobTrackerMAccess getBackendJobTrackerMAccess() {
+        return backendJobTrackerMAccess;
+    }
+
+    public void setBackendJobTrackerMAccess(BackendJobTrackerMAccess backendJobTrackerMAccess) {
+        this.backendJobTrackerMAccess = backendJobTrackerMAccess;
+    }
+
+    public BackendTaskTrackerMAccess getBackendTaskTrackerMAccess() {
+        return backendTaskTrackerMAccess;
+    }
+
+    public void setBackendTaskTrackerMAccess(BackendTaskTrackerMAccess backendTaskTrackerMAccess) {
+        this.backendTaskTrackerMAccess = backendTaskTrackerMAccess;
+    }
+
+    public BackendJVMGCAccess getBackendJVMGCAccess() {
+        return backendJVMGCAccess;
+    }
+
+    public void setBackendJVMGCAccess(BackendJVMGCAccess backendJVMGCAccess) {
+        this.backendJVMGCAccess = backendJVMGCAccess;
+    }
+
+    public BackendJVMMemoryAccess getBackendJVMMemoryAccess() {
+        return backendJVMMemoryAccess;
+    }
+
+    public void setBackendJVMMemoryAccess(BackendJVMMemoryAccess backendJVMMemoryAccess) {
+        this.backendJVMMemoryAccess = backendJVMMemoryAccess;
+    }
+
+    public BackendJVMThreadAccess getBackendJVMThreadAccess() {
+        return backendJVMThreadAccess;
+    }
+
+    public void setBackendJVMThreadAccess(BackendJVMThreadAccess backendJVMThreadAccess) {
+        this.backendJVMThreadAccess = backendJVMThreadAccess;
+    }
+
+    public BackendNodeOnOfflineLogAccess getBackendNodeOnOfflineLogAccess() {
+        return backendNodeOnOfflineLogAccess;
+    }
+
+    public void setBackendNodeOnOfflineLogAccess(BackendNodeOnOfflineLogAccess backendNodeOnOfflineLogAccess) {
+        this.backendNodeOnOfflineLogAccess = backendNodeOnOfflineLogAccess;
+    }
+
+    public NodeMemCacheAccess getNodeMemCacheAccess() {
+        return nodeMemCacheAccess;
+    }
+
+    public void setNodeMemCacheAccess(NodeMemCacheAccess nodeMemCacheAccess) {
+        this.nodeMemCacheAccess = nodeMemCacheAccess;
+    }
+
+    public NoRelyJobGenerator getNoRelyJobGenerator() {
+        return noRelyJobGenerator;
+    }
+
+    public void setNoRelyJobGenerator(NoRelyJobGenerator noRelyJobGenerator) {
+        this.noRelyJobGenerator = noRelyJobGenerator;
+    }
+
+    public BackendRegistrySrv getBackendRegistrySrv() {
+        return backendRegistrySrv;
+    }
+
+    public void setBackendRegistrySrv(BackendRegistrySrv backendRegistrySrv) {
+        this.backendRegistrySrv = backendRegistrySrv;
+    }
+}

+package com.github.ltsopensource.admin.cluster;
+
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.cluster.NodeType;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/12/16.
+ */
+public class BackendNode extends Node {
+
+    public BackendNode() {
+        this.setNodeType(NodeType.JOB_TRACKER);
+        this.addListenNodeType(NodeType.JOB_CLIENT);
+        this.addListenNodeType(NodeType.TASK_TRACKER);
+        this.addListenNodeType(NodeType.JOB_TRACKER);
+        this.addListenNodeType(NodeType.MONITOR);
+    }
+}

+package com.github.ltsopensource.admin.cluster;
+
+import com.github.ltsopensource.admin.access.domain.NodeOnOfflineLog;
+import com.github.ltsopensource.admin.request.NodePaginationReq;
+import com.github.ltsopensource.admin.response.PaginationRsp;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.commons.utils.CollectionUtils;
+import com.github.ltsopensource.core.logger.Logger;
+import com.github.ltsopensource.core.logger.LoggerFactory;
+import com.github.ltsopensource.core.registry.*;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Robert HG (254963746@qq.com) on 6/5/15.
+ */
+public class BackendRegistrySrv {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BackendRegistrySrv.class);
+    private BackendAppContext appContext;
+    private Registry registry;
+    private NotifyListener notifyListener;
+
+    public BackendRegistrySrv(BackendAppContext appContext) {
+        this.appContext = appContext;
+    }
+
+    private void subscribe() {
+
+        if (registry instanceof AbstractRegistry) {
+            ((AbstractRegistry) registry).setNode(appContext.getNode());
+        }
+        registry.subscribe(appContext.getNode(), notifyListener);
+    }
+
+    public void reSubscribe() {
+        // 取消订阅
+        registry.unsubscribe(appContext.getNode(), notifyListener);
+        // 清空内存数据
+        appContext.getNodeMemCacheAccess().clear();
+        // 重新订阅
+        subscribe();
+    }
+
+    public PaginationRsp<Node> getOnlineNodes(NodePaginationReq request) {
+        return appContext.getNodeMemCacheAccess().pageSelect(request);
+    }
+
+    /**
+     * 记录节点上下线日志
+     */
+    private void addLog(NotifyEvent event, List<Node> nodes) {
+        List<NodeOnOfflineLog> logs = new ArrayList<NodeOnOfflineLog>(nodes.size());
+
+        for (Node node : nodes) {
+            NodeOnOfflineLog log = new NodeOnOfflineLog();
+            log.setLogTime(new Date());
+            log.setEvent(event == NotifyEvent.ADD ? "ONLINE" : "OFFLINE");
+
+            log.setClusterName(node.getClusterName());
+            log.setCreateTime(node.getCreateTime());
+            log.setGroup(node.getGroup());
+            log.setHostName(node.getHostName());
+            log.setIdentity(node.getIdentity());
+            log.setIp(node.getIp());
+            log.setPort(node.getPort());
+            log.setThreads(node.getThreads());
+            log.setNodeType(node.getNodeType());
+            log.setHttpCmdPort(node.getHttpCmdPort());
+
+            logs.add(log);
+        }
+
+        appContext.getBackendNodeOnOfflineLogAccess().insert(logs);
+    }
+
+    public void start() throws Exception {
+
+        registry = RegistryFactory.getRegistry(appContext);
+
+        notifyListener = new NotifyListener() {
+            @Override
+            public void notify(NotifyEvent event, List<Node> nodes) {
+                if (CollectionUtils.isEmpty(nodes)) {
+                    return;
+                }
+                switch (event) {
+                    case ADD:
+                        appContext.getNodeMemCacheAccess().addNode(nodes);
+                        LOGGER.info("ADD NODE " + nodes);
+                        break;
+                    case REMOVE:
+                        appContext.getNodeMemCacheAccess().removeNode(nodes);
+                        LOGGER.info("REMOVE NODE " + nodes);
+                        break;
+                }
+                // 记录日志
+                addLog(event, nodes);
+            }
+        };
+
+        subscribe();
+    }
+}

+package com.github.ltsopensource.admin.request;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/13/16.
+ */
+public enum JVMType {
+
+    GC,
+    MEMORY,
+    THREAD
+
+}

+package com.github.ltsopensource.admin.request;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/28/15.
+ */
+public class JvmDataReq {
+
+    private String identity;
+
+    private Long startTime;
+
+    private Long endTime;
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public Long getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(Long startTime) {
+        this.startTime = startTime;
+    }
+
+    public Long getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(Long endTime) {
+        this.endTime = endTime;
+    }
+}

+package com.github.ltsopensource.admin.request;
+
+import com.github.ltsopensource.core.cluster.NodeType;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 8/22/15.
+ */
+public class MDataPaginationReq extends PaginationReq {
+
+    private NodeType nodeType;
+
+    private String id;
+
+    private String nodeGroup;
+
+    private String identity;
+
+    private Long startTime;
+
+    private Long endTime;
+
+    private JVMType jvmType;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getNodeGroup() {
+        return nodeGroup;
+    }
+
+    public void setNodeGroup(String nodeGroup) {
+        this.nodeGroup = nodeGroup;
+    }
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public Long getStartTime() {
+        return startTime;
+    }
+
+    public void setStartTime(Long startTime) {
+        this.startTime = startTime;
+    }
+
+    public Long getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(Long endTime) {
+        this.endTime = endTime;
+    }
+
+    public NodeType getNodeType() {
+        return nodeType;
+    }
+
+    public void setNodeType(NodeType nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public JVMType getJvmType() {
+        return jvmType;
+    }
+
+    public void setJvmType(JVMType jvmType) {
+        this.jvmType = jvmType;
+    }
+}

+package com.github.ltsopensource.admin.request;
+
+import com.github.ltsopensource.core.cluster.NodeType;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/5/15.
+ */
+public class NodeGroupRequest {
+
+    private NodeType nodeType;
+
+    private String nodeGroup;
+
+    public NodeType getNodeType() {
+        return nodeType;
+    }
+
+    public void setNodeType(NodeType nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public String getNodeGroup() {
+        return nodeGroup;
+    }
+
+    public void setNodeGroup(String nodeGroup) {
+        this.nodeGroup = nodeGroup;
+    }
+}

+package com.github.ltsopensource.admin.request;
+
+import java.util.Date;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/26/15.
+ */
+public class NodeOnOfflineLogPaginationReq extends PaginationReq {
+
+    private Date startLogTime;
+
+    private Date endLogTime;
+
+    private String group;
+
+    private String identity;
+
+    private String event;
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public String getEvent() {
+        return event;
+    }
+
+    public void setEvent(String event) {
+        this.event = event;
+    }
+
+    public String getGroup() {
+        return group;
+    }
+
+    public void setGroup(String group) {
+        this.group = group;
+    }
+
+    public Date getStartLogTime() {
+        return startLogTime;
+    }
+
+    public void setStartLogTime(Date startLogTime) {
+        this.startLogTime = startLogTime;
+    }
+
+    public Date getEndLogTime() {
+        return endLogTime;
+    }
+
+    public void setEndLogTime(Date endLogTime) {
+        this.endLogTime = endLogTime;
+    }
+}

+package com.github.ltsopensource.admin.request;
+
+import com.github.ltsopensource.core.cluster.NodeType;
+
+import java.util.Date;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 6/6/15.
+ */
+public class NodePaginationReq extends PaginationReq {
+
+    private String identity;
+    private String ip;
+    private String nodeGroup;
+    private NodeType nodeType;
+    private Boolean available;
+    private Date startDate;
+    private Date endDate;
+
+    public NodePaginationReq() {
+        // 默认不分页
+        setLimit(Integer.MAX_VALUE);
+    }
+
+    public String getNodeGroup() {
+        return nodeGroup;
+    }
+
+    public void setNodeGroup(String nodeGroup) {
+        this.nodeGroup = nodeGroup;
+    }
+
+    public String getIdentity() {
+        return identity;
+    }
+
+    public void setIdentity(String identity) {
+        this.identity = identity;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public NodeType getNodeType() {
+        return nodeType;
+    }
+
+    public void setNodeType(NodeType nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public Boolean getAvailable() {
+        return available;
+    }
+
+    public void setAvailable(Boolean available) {
+        this.available = available;
+    }
+
+    public Date getStartDate() {
+        return startDate;
+    }
+
+    public void setStartDate(Date startDate) {
+        this.startDate = startDate;
+    }
+
+    public Date getEndDate() {
+        return endDate;
+    }
+
+    public void setEndDate(Date endDate) {
+        this.endDate = endDate;
+    }
+}

+package com.github.ltsopensource.admin.support;
+
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 系统的配置信息（lts-admin.cfg）
+ *
+ * @author Robert HG (254963746@qq.com) on 5/11/15.
+ */
+public class AppConfigurer {
+
+    private static final Map<String, String> CONFIG = new HashMap<String, String>();
+    private static final String CONF_NAME = "lts-admin.cfg";
+
+    private static AtomicBoolean load = new AtomicBoolean(false);
+
+    public static void load(String confPath) {
+        String path = "";
+        try {
+            if (load.compareAndSet(false, true)) {
+                Properties conf = new Properties();
+
+                if (StringUtils.isNotEmpty(confPath)) {
+                    path = confPath + "/" + CONF_NAME;
+                    InputStream is = new FileInputStream(new File(path));
+                    conf.load(is);
+                } else {
+                    path = CONF_NAME;
+                    InputStream is = AppConfigurer.class.getClassLoader().getResourceAsStream(path);
+                    conf.load(is);
+                }
+
+                for (Map.Entry<Object, Object> entry : conf.entrySet()) {
+                    String key = entry.getKey().toString();
+                    String value = entry.getValue() == null ? null : entry.getValue().toString();
+                    CONFIG.put(key, value);
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Load config[" + path + "] error ", e);
+        }
+    }
+
+    public static Map<String, String> allConfig() {
+        return CONFIG;
+    }
+
+    public static String getProperty(String name) {
+        return CONFIG.get(name);
+    }
+
+    public static String getProperty(String name, String defaultValue) {
+        String returnValue = CONFIG.get(name);
+        if (returnValue == null || returnValue.equals("")) {
+            returnValue = defaultValue;
+        }
+        return returnValue;
+    }
+}

+package com.github.ltsopensource.admin.support;
+
+import com.github.ltsopensource.admin.access.BackendAccessFactory;
+import com.github.ltsopensource.admin.access.memory.NodeMemCacheAccess;
+import com.github.ltsopensource.admin.cluster.BackendAppContext;
+import com.github.ltsopensource.admin.cluster.BackendNode;
+import com.github.ltsopensource.admin.cluster.BackendRegistrySrv;
+import com.github.ltsopensource.admin.web.support.NoRelyJobGenerator;
+import com.github.ltsopensource.biz.logger.SmartJobLogger;
+import com.github.ltsopensource.core.cluster.Config;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.commons.utils.BeanUtils;
+import com.github.ltsopensource.core.commons.utils.NetUtils;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.constant.Constants;
+import com.github.ltsopensource.core.registry.RegistryStatMonitor;
+import com.github.ltsopensource.core.spi.ServiceLoader;
+import com.github.ltsopensource.core.support.SystemClock;
+import com.github.ltsopensource.ec.EventCenter;
+import com.github.ltsopensource.queue.JobQueueFactory;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+
+import java.util.Map;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 6/6/15.
+ */
+public class BackendAppContextFactoryBean implements FactoryBean<BackendAppContext>, InitializingBean {
+
+    private BackendAppContext appContext;
+
+    @Override
+    public BackendAppContext getObject() throws Exception {
+        return appContext;
+    }
+
+    @Override
+    public Class<?> getObjectType() {
+        return BackendAppContext.class;
+    }
+
+    @Override
+    public boolean isSingleton() {
+        return true;
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        final Node node = new BackendNode();
+        node.setCreateTime(SystemClock.now());
+        node.setIp(NetUtils.getLocalHost());
+        node.setHostName(NetUtils.getLocalHostName());
+        node.setIdentity(Constants.ADMIN_ID_PREFIX + StringUtils.generateUUID());
+
+        Config config = new Config();
+        config.setIdentity(node.getIdentity());
+        config.setNodeType(node.getNodeType());
+        config.setRegistryAddress(AppConfigurer.getProperty("registryAddress"));
+        String clusterName = AppConfigurer.getProperty("clusterName");
+        if (StringUtils.isEmpty(clusterName)) {
+            throw new IllegalArgumentException("clusterName in lts-admin.cfg can not be null.");
+        }
+        config.setClusterName(clusterName);
+
+        for (Map.Entry<String, String> entry : AppConfigurer.allConfig().entrySet()) {
+            // 将 config. 开头的配置都加入到config中
+            if (entry.getKey().startsWith("configs.")) {
+                config.setParameter(entry.getKey().replaceFirst("configs.", ""), entry.getValue());
+            }
+        }
+
+        appContext = new BackendAppContext();
+        appContext.setConfig(config);
+        appContext.setNode(node);
+        appContext.setEventCenter(ServiceLoader.load(EventCenter.class, config));
+        appContext.setRegistryStatMonitor(new RegistryStatMonitor(appContext));
+        appContext.setBackendRegistrySrv(new BackendRegistrySrv(appContext));
+
+        initAccess(config);
+
+        // ----------------------下面是JobQueue的配置---------------------------
+        Config jobTConfig = (Config) BeanUtils.deepClone(config);
+        for (Map.Entry<String, String> entry : AppConfigurer.allConfig().entrySet()) {
+            // 将 jobT. 开头的配置都加入到jobTConfig中
+            if (entry.getKey().startsWith("jobT.")) {
+                String key = entry.getKey().replace("jobT.", "");
+                String value = entry.getValue();
+                jobTConfig.setParameter(key, value);
+            }
+        }
+        initJobQueue(jobTConfig);
+
+        appContext.getBackendRegistrySrv().start();
+    }
+
+    private void initJobQueue(Config config) {
+        JobQueueFactory factory = ServiceLoader.load(JobQueueFactory.class, config);
+        appContext.setExecutableJobQueue(factory.getExecutableJobQueue(config));
+        appContext.setExecutingJobQueue(factory.getExecutingJobQueue(config));
+        appContext.setCronJobQueue(factory.getCronJobQueue(config));
+        appContext.setRepeatJobQueue(factory.getRepeatJobQueue(config));
+        appContext.setSuspendJobQueue(factory.getSuspendJobQueue(config));
+        appContext.setJobFeedbackQueue(factory.getJobFeedbackQueue(config));
+        appContext.setNodeGroupStore(factory.getNodeGroupStore(config));
+        appContext.setJobLogger(new SmartJobLogger(appContext));
+        appContext.setNoRelyJobGenerator(new NoRelyJobGenerator(appContext));
+    }
+
+    private void initAccess(Config config) {
+        BackendAccessFactory factory = ServiceLoader.load(BackendAccessFactory.class, config);
+        appContext.setBackendJobClientMAccess(factory.getBackendJobClientMAccess(config));
+        appContext.setBackendJobTrackerMAccess(factory.getJobTrackerMAccess(config));
+        appContext.setBackendTaskTrackerMAccess(factory.getBackendTaskTrackerMAccess(config));
+        appContext.setBackendJVMGCAccess(factory.getBackendJVMGCAccess(config));
+        appContext.setBackendJVMMemoryAccess(factory.getBackendJVMMemoryAccess(config));
+        appContext.setBackendJVMThreadAccess(factory.getBackendJVMThreadAccess(config));
+        appContext.setBackendNodeOnOfflineLogAccess(factory.getBackendNodeOnOfflineLogAccess(config));
+        appContext.setNodeMemCacheAccess(new NodeMemCacheAccess());
+    }
+
+}

+package com.github.ltsopensource.admin.support;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.MessageSource;
+
+import java.util.Locale;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/9/16.
+ */
+public class I18nManager {
+
+    private static final Logger logger = LoggerFactory.getLogger(I18nManager.class);
+
+    private static MessageSource messageSource;
+
+    @Autowired
+    public I18nManager(MessageSource messageSource) {
+        I18nManager.messageSource = messageSource;
+    }
+
+    public static String getMessage(String messageKey) {
+        return resolveMessage(null, messageKey, null);
+    }
+
+    public static String getMessage(String messageKey, Object... args) {
+        return resolveMessage(null, messageKey, args);
+    }
+
+    public static String getMessage(Locale locale, String messageKey, Object... args) {
+        return resolveMessage(locale, messageKey, args);
+    }
+
+    private static String resolveMessage(Locale locale, String key, Object[] args) {
+        if (locale == null) {
+            locale = new Locale("zh_CN");
+        }
+        try {
+            return messageSource.getMessage(key, args, locale);
+        } catch (Throwable t) {
+            logger.error("i18n error, message not found by key :" + key, t);
+            return key;
+        }
+    }
+}

+package com.github.ltsopensource.admin.support;
+
+import com.github.ltsopensource.admin.cluster.BackendAppContext;
+import com.github.ltsopensource.admin.request.JvmDataReq;
+import com.github.ltsopensource.admin.request.MDataPaginationReq;
+import com.github.ltsopensource.admin.request.NodeOnOfflineLogPaginationReq;
+import com.github.ltsopensource.core.commons.utils.Callable;
+import com.github.ltsopensource.core.commons.utils.DateUtils;
+import com.github.ltsopensource.core.commons.utils.QuietUtils;
+import com.github.ltsopensource.core.factory.NamedThreadFactory;
+import com.github.ltsopensource.core.logger.Logger;
+import com.github.ltsopensource.core.logger.LoggerFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.Date;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 定时清除 monitor 数据
+ *
+ * @author Robert HG (254963746@qq.com) on 8/23/15.
+ */
+public class LtsAdminDataCleaner implements InitializingBean {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(LtsAdminDataCleaner.class);
+
+    @Autowired
+    private BackendAppContext appContext;
+
+    private ScheduledExecutorService cleanExecutor = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("LTS-Admin-Clean", true));
+
+    private AtomicBoolean start = new AtomicBoolean(false);
+
+    public void start() {
+        if (start.compareAndSet(false, true)) {
+            cleanExecutor.scheduleAtFixedRate(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        clean();
+                    } catch (Throwable t) {
+                        LOGGER.error("Clean monitor data error ", t);
+                    }
+                }
+            }, 1, 24, TimeUnit.HOURS);
+            LOGGER.info("LtsAdminDataCleaner start succeed ");
+        }
+    }
+
+    private void clean() {
+        //  1. 清除TaskTracker JobTracker, JobClient的统计数据(3天之前的)
+        final MDataPaginationReq request = new MDataPaginationReq();
+        request.setEndTime(DateUtils.addDay(new Date(), -3).getTime());
+
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendTaskTrackerMAccess().delete(request);
+            }
+        });
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendJobTrackerMAccess().delete(request);
+            }
+        });
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendJobClientMAccess().delete(request);
+            }
+        });
+
+        // 2. 清除30天以前的节点上下线日志
+        final NodeOnOfflineLogPaginationReq nodeOnOfflineLogPaginationReq = new NodeOnOfflineLogPaginationReq();
+        nodeOnOfflineLogPaginationReq.setEndLogTime(DateUtils.addDay(new Date(), -30));
+
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendNodeOnOfflineLogAccess().delete(nodeOnOfflineLogPaginationReq);
+            }
+        });
+
+        // 3. 清除3天前的JVM监控信息
+        final JvmDataReq jvmDataReq = new JvmDataReq();
+        jvmDataReq.setEndTime(DateUtils.addDay(new Date(), -3).getTime());
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendJVMGCAccess().delete(jvmDataReq);
+            }
+        });
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendJVMThreadAccess().delete(jvmDataReq);
+            }
+        });
+        QuietUtils.doWithWarn(new Callable() {
+            @Override
+            public void call() throws Exception {
+                appContext.getBackendJVMMemoryAccess().delete(jvmDataReq);
+            }
+        });
+
+        LOGGER.info("Clean monitor data succeed ");
+    }
+
+    @Override
+    public void afterPropertiesSet() throws Exception {
+        start();
+    }
+}

+package com.github.ltsopensource.admin.support;
+
+import com.github.ltsopensource.core.commons.file.FileUtils;
+import com.github.ltsopensource.core.commons.utils.PlatformUtils;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.compiler.AbstractCompiler;
+import com.github.ltsopensource.core.constant.ExtConfig;
+import com.github.ltsopensource.core.json.JSONFactory;
+import com.github.ltsopensource.core.logger.LoggerFactory;
+import com.github.ltsopensource.monitor.MonitorAgentStartup;
+import org.apache.log4j.PropertyConfigurator;
+
+import javax.servlet.ServletContextEvent;
+import javax.servlet.ServletContextListener;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/2/15.
+ */
+public class SystemInitListener implements ServletContextListener {
+
+    @Override
+    public void contextInitialized(ServletContextEvent servletContextEvent) {
+
+        String confPath = servletContextEvent.getServletContext().getInitParameter("lts.admin.config.path");
+        if (StringUtils.isNotEmpty(confPath)) {
+            System.out.println("lts.admin.config.path : " + confPath);
+        }
+        AppConfigurer.load(confPath);
+
+        String compiler = AppConfigurer.getProperty("configs." + ExtConfig.COMPILER);
+        if (StringUtils.isNotEmpty(compiler)) {
+            AbstractCompiler.setCompiler(compiler);
+        }
+
+        String jsonAdapter = AppConfigurer.getProperty("configs." + ExtConfig.LTS_JSON);
+        if (StringUtils.isNotEmpty(jsonAdapter)) {
+            JSONFactory.setJSONAdapter(jsonAdapter);
+        }
+
+        String loggerAdapter = AppConfigurer.getProperty("configs." + ExtConfig.LTS_LOGGER);
+        if (StringUtils.isNotEmpty(loggerAdapter)) {
+            LoggerFactory.setLoggerAdapter(loggerAdapter);
+        }
+
+        String log4jPath = confPath + "/log4j.properties";
+        if (FileUtils.exist(log4jPath)) {
+            //  log4j 配置文件路径
+            PropertyConfigurator.configure(log4jPath);
+        }
+
+        boolean monitorAgentEnable = Boolean.valueOf(AppConfigurer.getProperty("lts.monitorAgent.enable", "true"));
+        if (monitorAgentEnable) {
+            String ltsMonitorCfgPath = confPath;
+            if (StringUtils.isEmpty(ltsMonitorCfgPath)) {
+                ltsMonitorCfgPath = this.getClass().getResource("/").getPath();
+                if (PlatformUtils.isWindows()) {
+                    // 替换window下空格问题
+                    ltsMonitorCfgPath = ltsMonitorCfgPath.replaceAll("%20", " ");
+                }
+            }
+            MonitorAgentStartup.start(ltsMonitorCfgPath);
+        }
+    }
+
+    @Override
+    public void contextDestroyed(ServletContextEvent servletContextEvent) {
+        MonitorAgentStartup.stop();
+    }
+}

+package com.github.ltsopensource.admin.web;
+
+import com.github.ltsopensource.admin.web.support.DateEditor;
+import com.github.ltsopensource.admin.web.support.MapEditor;
+import org.springframework.web.bind.ServletRequestDataBinder;
+import org.springframework.web.bind.annotation.InitBinder;
+
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 5/9/15.
+ */
+public class AbstractMVC {
+
+    @InitBinder
+    protected void initBinder(ServletRequestDataBinder binder) throws Exception {
+        //对于需要转换为Date类型的属性，使用DateEditor进行处理
+        binder.registerCustomEditor(Date.class, new DateEditor());
+        binder.registerCustomEditor(Map.class, "extParams", new MapEditor());
+    }
+
+}

+package com.github.ltsopensource.admin.web.api;
+
+import com.github.ltsopensource.admin.cluster.BackendAppContext;
+import com.github.ltsopensource.admin.request.JobQueueReq;
+import com.github.ltsopensource.admin.response.PaginationRsp;
+import com.github.ltsopensource.admin.web.AbstractMVC;
+import com.github.ltsopensource.admin.web.support.Builder;
+import com.github.ltsopensource.admin.web.vo.RestfulResponse;
+import com.github.ltsopensource.biz.logger.JobLogUtils;
+import com.github.ltsopensource.biz.logger.domain.LogType;
+import com.github.ltsopensource.core.commons.utils.Assert;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.constant.Constants;
+import com.github.ltsopensource.core.logger.Logger;
+import com.github.ltsopensource.core.logger.LoggerFactory;
+import com.github.ltsopensource.core.support.CronExpression;
+import com.github.ltsopensource.core.support.JobUtils;
+import com.github.ltsopensource.core.support.SystemClock;
+import com.github.ltsopensource.queue.domain.JobPo;
+import com.github.ltsopensource.store.jdbc.exception.DupEntryException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.text.ParseException;
+import java.util.Date;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 3/26/16.
+ */
+@RestController
+public class CronJobQueueApi extends AbstractMVC {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CronJobQueueApi.class);
+    @Autowired
+    private BackendAppContext appContext;
+
+    @RequestMapping("/job-queue/cron-job-get")
+    public RestfulResponse cronJobGet(JobQueueReq request) {
+        PaginationRsp<JobPo> paginationRsp = appContext.getCronJobQueue().pageSelect(request);
+        RestfulResponse response = new RestfulResponse();
+        response.setSuccess(true);
+        response.setResults(paginationRsp.getResults());
+        response.setRows(paginationRsp.getRows());
+        return response;
+    }
+
+    @RequestMapping("/job-queue/cron-job-update")
+    public RestfulResponse cronJobUpdate(JobQueueReq request) {
+        RestfulResponse response = new RestfulResponse();
+        // 检查参数
+        try {
+            Assert.hasLength(request.getJobId(), "jobId不能为空!");
+            Assert.hasLength(request.getCronExpression(), "cronExpression不能为空!");
+        } catch (IllegalArgumentException e) {
+            return Builder.build(false, e.getMessage());
+        }
+        try {
+            // 1. 检测 cronExpression是否是正确的
+            CronExpression expression = new CronExpression(request.getCronExpression());
+            Date nextTriggerTime = expression.getTimeAfter(new Date());
+            if (nextTriggerTime == null) {
+                return Builder.build(false, StringUtils.format("该CronExpression={} 已经没有执行时间点! 请重新设置或者直接删除。", request.getCronExpression()));
+            }
+            JobPo oldJobPo = appContext.getCronJobQueue().getJob(request.getJobId());
+            boolean success = appContext.getCronJobQueue().selectiveUpdateByJobId(request);
+            if (success) {
+                JobPo newJobPo = appContext.getCronJobQueue().getJob(request.getJobId());
+                try {
+                    // 判断是否有relyOnPrevCycle变更
+                    boolean relyOnPrevCycleChanged = !newJobPo.getRelyOnPrevCycle().equals(oldJobPo.getRelyOnPrevCycle());
+                    boolean cronExpressionChanged = !newJobPo.getCronExpression().equals(oldJobPo.getCronExpression());
+
+                    // 1. 修改前relyOnPrevCycle=true,并且修改后也是true
+                    if (oldJobPo.getRelyOnPrevCycle() && !relyOnPrevCycleChanged) {
+                        // 看CronExpression是否有修改,如果有修改,需要更新triggerTime
+                        if (cronExpressionChanged) {
+                            request.setTriggerTime(nextTriggerTime);
+                        }
+                        appContext.getExecutableJobQueue().selectiveUpdateByJobId(request);
+                    } else {
+                        // 2. 需要对批量任务做处理
+                        if (relyOnPrevCycleChanged) {
+                            // 如果relyOnPrevCycle 修改过
+                            if (oldJobPo.getRelyOnPrevCycle()) {
+                                // 之前是依赖的,现在不依赖,需要生成批量任务
+                                appContext.getExecutableJobQueue().remove(oldJobPo.getTaskTrackerNodeGroup(), oldJobPo.getJobId());
+                                appContext.getNoRelyJobGenerator().generateCronJobForInterval(newJobPo, new Date());
+                            } else {
+                                // 之前不依赖,现在依赖,需要删除批量任务
+                                appContext.getExecutableJobQueue().removeBatch(oldJobPo.getRealTaskId(), oldJobPo.getTaskTrackerNodeGroup());
+                                // 添加新的任务
+                                newJobPo.setTriggerTime(nextTriggerTime.getTime());
+                                try {
+                                    newJobPo.setInternalExtParam(Constants.EXE_SEQ_ID, JobUtils.generateExeSeqId(newJobPo));
+                                    appContext.getExecutableJobQueue().add(newJobPo);
+                                } catch (DupEntryException ignored) {
+                                }
+                            }
+                        } else {
+                            // 如果relyOnPrevCycle 没有修改过, 表示relyOnPrevCycle=false, 那么要看cronExpression是否修改过,如果修改过,需要删除重新生成
+                            if (cronExpressionChanged) {
+                                appContext.getExecutableJobQueue().removeBatch(oldJobPo.getRealTaskId(), oldJobPo.getTaskTrackerNodeGroup());
+                                appContext.getNoRelyJobGenerator().generateCronJobForInterval(newJobPo, new Date());
+                            } else {
+                                appContext.getExecutableJobQueue().selectiveUpdateByTaskId(request);
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    LOGGER.error(e.getMessage(), e);
+                    return Builder.build(false, "更新等待执行的任务失败，请手动更新! error:" + e.getMessage());
+                }
+                response.setSuccess(true);
+            } else {
+                return Builder.build(false, "该任务已经被删除或者执行完成");
+            }
+            JobLogUtils.log(LogType.UPDATE, oldJobPo, appContext.getJobLogger());
+            return response;
+        } catch (ParseException e) {
+            LOGGER.error(e.getMessage(), e);
+            return Builder.build(false, "请输入正确的 CronExpression!" + e.getMessage());
+        }
+    }
+
+    @RequestMapping("/job-queue/cron-job-delete")
+    public RestfulResponse cronJobDelete(JobQueueReq request) {
+        if (StringUtils.isEmpty(request.getJobId())) {
+            return Builder.build(false, "JobId 必须传!");
+        }
+        JobPo jobPo = appContext.getCronJobQueue().getJob(request.getJobId());
+        if (jobPo == null) {
+            return Builder.build(true, "已经删除");
+        }
+        boolean success = appContext.getCronJobQueue().remove(request.getJobId());
+        if (success) {
+            try {
+                appContext.getExecutableJobQueue().removeBatch(jobPo.getRealTaskId(), jobPo.getTaskTrackerNodeGroup());
+            } catch (Exception e) {
+                LOGGER.error(e.getMessage(), e);
+                return Builder.build(false, "删除等待执行的任务失败，请手动删除! error:{}" + e.getMessage());
+            }
+        }
+        JobLogUtils.log(LogType.DEL, jobPo, appContext.getJobLogger());
+
+        return Builder.build(true, "ok");
+    }
+
+    @RequestMapping("/job-queue/cron-job-suspend")
+    public RestfulResponse cronJobSuspend(JobQueueReq request) {
+        if (StringUtils.isEmpty(request.getJobId())) {
+            return Builder.build(false, "JobId 必须传!");
+        }
+        JobPo jobPo = appContext.getCronJobQueue().getJob(request.getJobId());
+        if (jobPo == null) {
+            return Builder.build(false, "任务不存在，或者已经删除");
+        }
+        try {
+            jobPo.setGmtModified(SystemClock.now());
+            appContext.getSuspendJobQueue().add(jobPo);
+        } catch (DupEntryException e) {
+            LOGGER.error(e.getMessage(), e);
+            return Builder.build(false, "该任务已经被暂停, 请检查暂停队列");
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+            return Builder.build(false, "移动任务到暂停队列失败, error:" + e.getMessage());
+        }
+        try {
+            appContext.getCronJobQueue().remove(request.getJobId());
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+            return Builder.build(false, "删除Cron任务失败，请手动删除! error:" + e.getMessage());
+        }
+        try {
+            if (!jobPo.getRelyOnPrevCycle()) {
+                appContext.getCronJobQueue().updateLastGenerateTriggerTime(jobPo.getJobId(), new Date().getTime());
+                appContext.getExecutableJobQueue().removeBatch(jobPo.getRealTaskId(), jobPo.getTaskTrackerNodeGroup());
+            } else {
+                appContext.getExecutableJobQueue().remove(request.getTaskTrackerNodeGroup(), request.getJobId());
+            }
+        } catch (Exception e) {
+            LOGGER.error(e.getMessage(), e);
+            return Builder.build(false, "删除等待执行的任务失败，请手动删除! error:" + e.getMessage());
+        }
+
+        // 记录日志
+        JobLogUtils.log(LogType.SUSPEND, jobPo, appContext.getJobLogger());
+
+        return Builder.build(true, "ok");
+    }
+}

+package com.github.ltsopensource.admin.web.api;
+
+import com.github.ltsopensource.admin.cluster.BackendAppContext;
+import com.github.ltsopensource.admin.request.JobQueueReq;
+import com.github.ltsopensource.admin.response.PaginationRsp;
+import com.github.ltsopensource.admin.support.AppConfigurer;
+import com.github.ltsopensource.admin.support.I18nManager;
+import com.github.ltsopensource.admin.web.AbstractMVC;
+import com.github.ltsopensource.admin.web.support.Builder;
+import com.github.ltsopensource.admin.web.vo.RestfulResponse;
+import com.github.ltsopensource.biz.logger.domain.JobLogPo;
+import com.github.ltsopensource.biz.logger.domain.JobLoggerRequest;
+import com.github.ltsopensource.cmd.DefaultHttpCmd;
+import com.github.ltsopensource.cmd.HttpCmd;
+import com.github.ltsopensource.cmd.HttpCmdClient;
+import com.github.ltsopensource.cmd.HttpCmdResponse;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.cluster.NodeType;
+import com.github.ltsopensource.core.cmd.HttpCmdNames;
+import com.github.ltsopensource.core.commons.utils.Assert;
+import com.github.ltsopensource.core.commons.utils.CollectionUtils;
+import com.github.ltsopensource.core.commons.utils.StringUtils;
+import com.github.ltsopensource.core.domain.Job;
+import com.github.ltsopensource.core.domain.Pair;
+import com.github.ltsopensource.core.json.JSON;
+import com.github.ltsopensource.core.support.CronExpression;
+import com.github.ltsopensource.queue.domain.JobPo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 6/6/15.
+ */
+@RestController
+public class JobQueueApi extends AbstractMVC {
+
+    @Autowired
+    private BackendAppContext appContext;
+
+    @RequestMapping("/job-queue/executable-job-get")
+    public RestfulResponse executableJobGet(JobQueueReq request) {
+        PaginationRsp<JobPo> paginationRsp = appContext.getExecutableJobQueue().pageSelect(request);
+
+        boolean needClear = Boolean.valueOf(AppConfigurer.getProperty("lts.admin.remove.running.job.on.executable.search", "false"));
+        if (needClear) {
+            paginationRsp = clearRunningJob(paginationRsp);
+        }
+        RestfulResponse response = new RestfulResponse();
+        response.setSuccess(true);
+        response.setResults(paginationRsp.getResults());
+        response.setRows(paginationRsp.getRows());
+        return response;
+    }
+
+    /**
+     * 比较恶心的逻辑,当等待执行队列的任务同时也在执行中队列, 则不展示
+     */
+    private PaginationRsp<JobPo> clearRunningJob(PaginationRsp<JobPo> paginationRsp) {
+        if (paginationRsp == null || paginationRsp.getResults() == 0) {
+            return paginationRsp;
+        }
+        PaginationRsp<JobPo> rsp = new PaginationRsp<JobPo>();
+        List<JobPo> rows = new ArrayList<JobPo>();
+        for (JobPo jobPo : paginationRsp.getRows()) {
+            if (appContext.getExecutingJobQueue().getJob(jobPo.getTaskTrackerNodeGroup(), jobPo.getTaskId()) == null) {
+                // 没有正在执行, 则显示在等待执行列表中
+                rows.add(jobPo);
+            }
+        }
+        rsp.setRows(rows);
+        rsp.setResults(paginationRsp.getResults() - paginationRsp.getRows().size() - rows.size());
+        return rsp;
+    }
+
+    @RequestMapping("/job-queue/executing-job-trigger")
+    public RestfulResponse triggerJobManually(JobQueueReq request) {
+
+        try {
+            Assert.hasLength(request.getJobId(), "jobId不能为空!");
+            Assert.hasLength(request.getTaskTrackerNodeGroup(), "taskTrackerNodeGroup不能为空!");
+        } catch (IllegalArgumentException e) {
+            return Builder.build(false, e.getMessage());
+        }
+
+        HttpCmd httpCmd = new DefaultHttpCmd();
+        httpCmd.setCommand(HttpCmdNames.HTTP_CMD_TRIGGER_JOB_MANUALLY);
+        httpCmd.addParam("jobId", request.getJobId());
+        httpCmd.addParam("nodeGroup", request.getTaskTrackerNodeGroup());
+
+        List<Node> jobTrackerNodeList = appContext.getNodeMemCacheAccess().getNodeByNodeType(NodeType.JOB_TRACKER);
+        if (CollectionUtils.isEmpty(jobTrackerNodeList)) {
+            return Builder.build(false, I18nManager.getMessage("job.tracker.not.found"));
+        }
+
+        HttpCmdResponse response = null;
+        for (Node node : jobTrackerNodeList) {
+            httpCmd.setNodeIdentity(node.getIdentity());
+            response = HttpCmdClient.doGet(node.getIp(), node.getHttpCmdPort(), httpCmd);
+            if (response.isSuccess()) {
+                return Builder.build(true);
+            }
+        }
+        if (response != null) {
+            return Builder.build(false, response.getMsg());
+        } else {
+            return Builder.build(false, "TriggerFailed failed");
+        }
+    }
+
+    @RequestMapping("/job-queue/executing-job-get")
+    public RestfulResponse executingJobGet(JobQueueReq request) {
+        PaginationRsp<JobPo> paginationRsp = appContext.getExecutingJobQueue().pageSelect(request);
+        RestfulResponse response = new RestfulResponse();
+        response.setSuccess(true);
+        response.setResults(paginationRsp.getResults());
+        response.setRows(paginationRsp.getRows());
+        return response;
+    }
+
+    @RequestMapping("/job-queue/executable-job-update")
+    public RestfulResponse executableJobUpdate(JobQueueReq request) {
+        // 检查参数
+        // 1. 检测 cronExpression是否是正确的
+        if (StringUtils.isNotEmpty(request.getCronExpression())) {
+            try {
+                CronExpression expression = new CronExpression(request.getCronExpression());
+                if (expression.getTimeAfter(new Date()) == null) {
+                    return Builder.build(false, StringUtils.format("该CronExpression={} 已经没有执行时间点!", request.getCronExpression()));
+                }
+            } catch (ParseException e) {
+                return Builder.build(false, "请输入正确的 CronExpression!");
+            }
+        }
+        try {
+            Assert.hasLength(request.getJobId(), "jobId不能为空!");
+            Assert.hasLength(request.getTaskTrackerNodeGroup(), "taskTrackerNodeGroup不能为空!");
+        } catch (IllegalArgumentException e) {
+            return Builder.build(false, e.getMessage());
+        }
+        boolean success = appContext.getExecutableJobQueue().selectiveUpdateByJobId(request);
+        RestfulResponse response = new RestfulResponse();
+        if (success) {
+            response.setSuccess(true);
+        } else {
+            response.setSuccess(false);
+            response.setCode("DELETE_OR_RUNNING");
+        }
+        return response;
+    }
+
+    @RequestMapping("/job-queue/executable-job-delete")
+    public RestfulResponse executableJobDelete(JobQueueReq request) {
+        try {
+            Assert.hasLength(request.getJobId(), "jobId不能为空!");
+            Assert.hasLength(request.getTaskTrackerNodeGroup(), "taskTrackerNodeGroup不能为空!");
+        } catch (IllegalArgumentException e) {
+            return Builder.build(false, e.getMessage());
+        }
+
+        boolean success = appContext.getExecutableJobQueue().remove(request.getTaskTrackerNodeGroup(), request.getJobId());
+        if (success) {
+            if (StringUtils.isNotEmpty(request.getCronExpression()) && !"null".equals(request.getCronExpression())) {
+                // 是Cron任务, Cron任务队列的也要被删除
+                try {
+                    appContext.getCronJobQueue().remove(request.getJobId());
+                } catch (Exception e) {
+                    return Builder.build(false, "在Cron任务队列中删除该任务失败，请手动更新! error:" + e.getMessage());
+                }
+            }
+            return Builder.build(true);
+        } else {
+            return Builder.build(false, "更新失败，该条任务可能已经删除.");
+        }
+    }
+
+    @RequestMapping("/job-logger/job-logger-get")
+    public RestfulResponse jobLoggerGet(JobLoggerRequest request) {
+        RestfulResponse response = new RestfulResponse();
+
+        PaginationRsp<JobLogPo> paginationRsp = appContext.getJobLogger().search(request);
+        response.setResults(paginationRsp.getResults());
+        response.setRows(paginationRsp.getRows());
+
+        response.setSuccess(true);
+        return response;
+    }
+
+    /**
+     * 给JobTracker发消息 加载任务到内存
+     */
+    @RequestMapping("/job-queue/load-add")
+    public RestfulResponse loadJob(JobQueueReq request) {
+        RestfulResponse response = new RestfulResponse();
+
+        String nodeGroup = request.getTaskTrackerNodeGroup();
+
+        HttpCmd httpCmd = new DefaultHttpCmd();
+        httpCmd.setCommand(HttpCmdNames.HTTP_CMD_LOAD_JOB);
+        httpCmd.addParam("nodeGroup", nodeGroup);
+
+        List<Node> jobTrackerNodeList = appContext.getNodeMemCacheAccess().getNodeByNodeType(NodeType.JOB_TRACKER);
+        if (CollectionUtils.isEmpty(jobTrackerNodeList)) {
+            response.setMsg(I18nManager.getMessage("job.tracker.not.found"));
+            response.setSuccess(false);
+            return response;
+        }
+
+        boolean success = false;
+        HttpCmdResponse cmdResponse = null;
+        for (Node node : jobTrackerNodeList) {
+            // 所有的JobTracker都load一遍
+            httpCmd.setNodeIdentity(node.getIdentity());
+            cmdResponse = HttpCmdClient.doGet(node.getIp(), node.getHttpCmdPort(), httpCmd);
+            if (cmdResponse.isSuccess()) {
+                success = true;
+            }
+        }
+        if (success) {
+            response.setMsg("Load success");
+        } else {
+            response.setMsg("Load failed");
+        }
+        response.setSuccess(success);
+        return response;
+    }
+
+    @RequestMapping("/job-queue/job-add")
+    public RestfulResponse jobAdd(String jobType, JobQueueReq request) {
+        // 表单check
+
+        try {
+            Assert.hasLength(request.getTaskId(), I18nManager.getMessage("taskId.not.null"));
+            Assert.hasLength(request.getTaskTrackerNodeGroup(), "taskTrackerNodeGroup不能为空!");
+            if (request.getNeedFeedback()) {
+                Assert.hasLength(request.getSubmitNodeGroup(), "submitNodeGroup不能为空!");
+            }
+
+            if (StringUtils.isNotEmpty(request.getCronExpression())) {
+                try {
+                    CronExpression expression = new CronExpression(request.getCronExpression());
+                    Date nextTime = expression.getTimeAfter(new Date());
+                    if (nextTime == null) {
+                        return Builder.build(false, StringUtils.format("该CronExpression={} 已经没有执行时间点!", request.getCronExpression()));
+                    } else {
+                        request.setTriggerTime(nextTime);
+                    }
+                } catch (ParseException e) {
+                    return Builder.build(false, "请输入正确的 CronExpression!");
+                }
+            }
+
+        } catch (IllegalArgumentException e) {
+            return Builder.build(false, e.getMessage());
+        }
+
+        Pair<Boolean, String> pair = addJob(jobType, request);
+        return Builder.build(pair.getKey(), pair.getValue());
+    }
+
+    private Pair<Boolean, String> addJob(String jobType, JobQueueReq request) {
+
+        Job job = new Job();
+        job.setTaskId(request.getTaskId());
+        if (CollectionUtils.isNotEmpty(request.getExtParams())) {
+            for (Map.Entry<String, String> entry : request.getExtParams().entrySet()) {
+                job.setParam(entry.getKey(), entry.getValue());
+            }
+        }
+        // 执行节点的group名称
+        job.setTaskTrackerNodeGroup(request.getTaskTrackerNodeGroup());
+        job.setSubmitNodeGroup(request.getSubmitNodeGroup());
+
+        job.setNeedFeedback(request.getNeedFeedback());
+        job.setReplaceOnExist(true);
+
+        // 这个是 cron expression 和 quartz 一样，可选
+        job.setCronExpression(request.getCronExpression());
+        if (request.getTriggerTime() != null) {
+            job.setTriggerTime(request.getTriggerTime().getTime());
+        }
+        job.setRepeatCount(request.getRepeatCount() == null ? 0 : request.getRepeatCount());
+        job.setRepeatInterval(request.getRepeatInterval());
+
+        job.setPriority(request.getPriority());
+        job.setMaxRetryTimes(request.getMaxRetryTimes() == null ? 0 : request.getMaxRetryTimes());
+        job.setRelyOnPrevCycle(request.getRelyOnPrevCycle() == null ? true : request.getRelyOnPrevCycle());
+
+        if ("REAL_TIME_JOB".equals(jobType)) {
+            job.setCronExpression(null);
+            job.setTriggerTime(null);
+            job.setRepeatInterval(null);
+            job.setRepeatCount(0);
+            job.setRelyOnPrevCycle(true);
+        } else if ("TRIGGER_TIME_JOB".equals(jobType)) {
+            job.setCronExpression(null);
+            job.setRepeatInterval(null);
+            job.setRepeatCount(0);
+            job.setRelyOnPrevCycle(true);
+        } else if ("CRON_JOB".equals(jobType)) {
+            job.setRepeatInterval(null);
+            job.setRepeatCount(0);
+        } else if ("REPEAT_JOB".equals(jobType)) {
+            job.setCronExpression(null);
+        }
+        return addJob(job);
+    }
+
+    private Pair<Boolean, String> addJob(Job job) {
+        HttpCmd httpCmd = new DefaultHttpCmd();
+        httpCmd.setCommand(HttpCmdNames.HTTP_CMD_ADD_JOB);
+        httpCmd.addParam("job", JSON.toJSONString(job));
+
+        List<Node> jobTrackerNodeList = appContext.getNodeMemCacheAccess().getNodeByNodeType(NodeType.JOB_TRACKER);
+        if (CollectionUtils.isEmpty(jobTrackerNodeList)) {
+            return new Pair<Boolean, String>(false, I18nManager.getMessage("job.tracker.not.found"));
+        }
+
+        HttpCmdResponse response = null;
+        for (Node node : jobTrackerNodeList) {
+            httpCmd.setNodeIdentity(node.getIdentity());
+            response = HttpCmdClient.doGet(node.getIp(), node.getHttpCmdPort(), httpCmd);
+            if (response.isSuccess()) {
+                return new Pair<Boolean, String>(true, "Add success");
+            }
+        }
+        if (response != null) {
+            return new Pair<Boolean, String>(false, response.getMsg());
+        } else {
+            return new Pair<Boolean, String>(false, "Add failed");
+        }
+    }
+
+    @RequestMapping("/job-queue/executing-job-terminate")
+    public RestfulResponse jobTerminate(String jobId) {
+
+        JobPo jobPo = appContext.getExecutingJobQueue().getJob(jobId);
+        if (jobPo == null) {
+            return Builder.build(false, "该任务已经执行完成或者被删除");
+        }
+
+        String taskTrackerIdentity = jobPo.getTaskTrackerIdentity();
+
+        Node node = appContext.getNodeMemCacheAccess().getNodeByIdentity(taskTrackerIdentity);
+        if (node == null) {
+            return Builder.build(false, "执行该任务的TaskTracker已经离线");
+        }
+
+        HttpCmd cmd = new DefaultHttpCmd();
+        cmd.setCommand(HttpCmdNames.HTTP_CMD_JOB_TERMINATE);
+        cmd.setNodeIdentity(taskTrackerIdentity);
+        cmd.addParam("jobId", jobId);
+        HttpCmdResponse response = HttpCmdClient.doPost(node.getIp(), node.getHttpCmdPort(), cmd);
+        if (response.isSuccess()) {
+            return Builder.build(true);
+        } else {
+            return Builder.build(false, response.getMsg());
+        }
+    }
+}

+package com.github.ltsopensource.admin.web.api;
+
+import com.github.ltsopensource.admin.cluster.BackendAppContext;
+import com.github.ltsopensource.admin.support.I18nManager;
+import com.github.ltsopensource.admin.web.AbstractMVC;
+import com.github.ltsopensource.admin.web.support.Builder;
+import com.github.ltsopensource.admin.web.vo.RestfulResponse;
+import com.github.ltsopensource.cmd.DefaultHttpCmd;
+import com.github.ltsopensource.cmd.HttpCmd;
+import com.github.ltsopensource.cmd.HttpCmdClient;
+import com.github.ltsopensource.cmd.HttpCmdResponse;
+import com.github.ltsopensource.core.cluster.Node;
+import com.github.ltsopensource.core.cmd.HttpCmdNames;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Collections;
+
+/**
+ * @author Robert HG (254963746@qq.com) on 9/28/15.
+ */
+@RestController
+@RequestMapping("/jvm")
+public class JvmDataApi extends AbstractMVC {
+
+    @Autowired
+    private BackendAppContext appContext;
+
+    @RequestMapping("node-jvm-info-get")
+    public RestfulResponse getNodeList(String identity) {
+
+        RestfulResponse restfulResponse = new RestfulResponse();
+
+        Node node = appContext.getNodeMemCacheAccess().getNodeByIdentity(identity);
+
+        if (node == null) {
+            return Builder.build(false, I18nManager.getMessage("node.dose.not.alive"));
+        }
+
+        HttpCmd cmd = new DefaultHttpCmd();
+        cmd.setCommand(HttpCmdNames.HTTP_CMD_JVM_INFO_GET);
+        cmd.setNodeIdentity(identity);
+
+        HttpCmdResponse response = HttpCmdClient.doGet(node.getIp(), node.getHttpCmdPort(), cmd);
+        if (response.isSuccess()) {
+            restfulResponse.setSuccess(true);
+            restfulResponse.setResults(1);
+            restfulResponse.setRows(Collections.singletonList(response.getObj()));
+        } else {
+            restfulResponse.setSuccess(false);
+            restfulResponse.setMsg(response.getMsg());
+        }
+
+        return restfulResponse;
+    }
+
+}