git clone https://github.com/xuxueli/xxl-job.git

Dockerfile

+FROM openjdk:7-jre-slim
+MAINTAINER xuxueli
+
+ENV PARAMS=""
+
+ENV TZ=PRC
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+ADD target/xxl-job-admin-*.jar /app.jar
+
+ENTRYPOINT ["sh","-c","java -jar /app.jar $PARAMS"]
\ No newline at end of file

pom.xml

+<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">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.xuxueli</groupId>
+        <artifactId>xxl-job</artifactId>
+        <version>2.1.1</version>
+    </parent>
+    <artifactId>xxl-job-admin</artifactId>
+    <packaging>jar</packaging>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-starter-parent</artifactId>
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+
+        <!-- starter-web：spring-webmvc + autoconfigure + logback + yaml + tomcat -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <!-- starter-test：junit + spring-test + mockito -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- freemarker-starter -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-freemarker</artifactId>
+        </dependency>
+
+        <!-- mail-starter -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-mail</artifactId>
+        </dependency>
+
+        <!-- starter-actuator -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+
+        <!-- mybatis-starter：mybatis + mybatis-spring + tomcat-jdbc（default） -->
+        <dependency>
+            <groupId>org.mybatis.spring.boot</groupId>
+            <artifactId>mybatis-spring-boot-starter</artifactId>
+            <version>${mybatis-spring-boot-starter.version}</version>
+        </dependency>
+        <!-- mysql -->
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>${mysql-connector-java.version}</version>
+        </dependency>
+
+        <!-- xxl-job-core -->
+        <dependency>
+            <groupId>com.xuxueli</groupId>
+            <artifactId>xxl-job-core</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring-boot.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <!-- docker -->
+            <plugin>
+                <groupId>com.spotify</groupId>
+                <artifactId>docker-maven-plugin</artifactId>
+                <version>0.4.13</version>
+                <configuration>
+                    <!-- made of '[a-z0-9-_.]' -->
+                    <imageName>${project.artifactId}:${project.version}</imageName>
+                    <dockerDirectory>${project.basedir}</dockerDirectory>
+                    <resources>
+                        <resource>
+                            <targetPath>/</targetPath>
+                            <directory>${project.build.directory}</directory>
+                            <include>${project.build.finalName}.jar</include>
+                        </resource>
+                    </resources>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

src/main/java/com/xxl/job/admin/XxlJobAdminApplication.java

+package com.xxl.job.admin;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * @author xuxueli 2018-10-28 00:38:13
+ */
+@SpringBootApplication
+public class XxlJobAdminApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(XxlJobAdminApplication.class, args);
+	}
+
+}
\ No newline at end of file

src/main/java/com/xxl/job/admin/controller/IndexController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.controller.annotation.PermissionLimit;
+import com.xxl.job.admin.service.LoginService;
+import com.xxl.job.admin.service.XxlJobService;
+import com.xxl.job.core.biz.model.ReturnT;
+import org.springframework.beans.propertyeditors.CustomDateEditor;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.InitBinder;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * index controller
+ *
+ * @author xuxueli 2015-12-19 16:13:16
+ */
+@Controller
+public class IndexController {
+
+	@Resource
+	private XxlJobService xxlJobService;
+	@Resource
+	private LoginService loginService;
+
+
+	@RequestMapping("/")
+	public String index(Model model) {
+
+		Map<String, Object> dashboardMap = xxlJobService.dashboardInfo();
+		model.addAllAttributes(dashboardMap);
+
+		return "index";
+	}
+
+	@RequestMapping("/chartInfo")
+	@ResponseBody
+	public ReturnT<Map<String, Object>> chartInfo(Date startDate, Date endDate) {
+		ReturnT<Map<String, Object>> chartInfo = xxlJobService.chartInfo(startDate, endDate);
+		return chartInfo;
+	}
+
+	@RequestMapping("/toLogin")
+	@PermissionLimit(limit = false)
+	public String toLogin(HttpServletRequest request, HttpServletResponse response) {
+		if (loginService.ifLogin(request, response) != null) {
+			return "redirect:/";
+		}
+		return "login";
+	}
+
+	@RequestMapping(value = "login", method = RequestMethod.POST)
+	@ResponseBody
+	@PermissionLimit(limit = false)
+	public ReturnT<String> loginDo(HttpServletRequest request, HttpServletResponse response, String userName, String password, String ifRemember) {
+		boolean ifRem = (ifRemember != null && ifRemember.trim().length() > 0 && "on".equals(ifRemember)) ? true : false;
+		return loginService.login(request, response, userName, password, ifRem);
+	}
+
+	@RequestMapping(value = "logout", method = RequestMethod.POST)
+	@ResponseBody
+	@PermissionLimit(limit = false)
+	public ReturnT<String> logout(HttpServletRequest request, HttpServletResponse response) {
+		return loginService.logout(request, response);
+	}
+
+	@RequestMapping("/help")
+	public String help() {
+
+		/*if (!PermissionInterceptor.ifLogin(request)) {
+			return "redirect:/toLogin";
+		}*/
+
+		return "help";
+	}
+
+	@InitBinder
+	public void initBinder(WebDataBinder binder) {
+		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+		dateFormat.setLenient(false);
+		binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/JobApiController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.controller.annotation.PermissionLimit;
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.util.JacksonUtil;
+import com.xxl.job.core.biz.AdminBiz;
+import com.xxl.job.core.biz.model.HandleCallbackParam;
+import com.xxl.job.core.biz.model.RegistryParam;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.util.XxlJobRemotingUtil;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/5/10.
+ */
+@Controller
+@RequestMapping("/api")
+public class JobApiController {
+
+	@Resource
+	private AdminBiz adminBiz;
+
+
+	// ---------------------- admin biz ----------------------
+
+	/**
+	 * callback
+	 *
+	 * @param data
+	 * @return
+	 */
+	@RequestMapping("/callback")
+	@ResponseBody
+	@PermissionLimit(limit = false)
+	public ReturnT<String> callback(HttpServletRequest request, @RequestBody(required = false) String data) {
+		// valid
+		if (XxlJobAdminConfig.getAdminConfig().getAccessToken() != null
+				&& XxlJobAdminConfig.getAdminConfig().getAccessToken().trim().length() > 0
+				&& !XxlJobAdminConfig.getAdminConfig().getAccessToken().equals(request.getHeader(XxlJobRemotingUtil.XXL_RPC_ACCESS_TOKEN))) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
+		}
+
+		// param
+		List<HandleCallbackParam> callbackParamList = null;
+		try {
+			callbackParamList = JacksonUtil.readValue(data, List.class, HandleCallbackParam.class);
+		} catch (Exception e) {
+		}
+		if (callbackParamList == null || callbackParamList.size() == 0) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The request data invalid.");
+		}
+
+		// invoke
+		return adminBiz.callback(callbackParamList);
+	}
+
+
+	/**
+	 * registry
+	 *
+	 * @param data
+	 * @return
+	 */
+	@RequestMapping("/registry")
+	@ResponseBody
+	@PermissionLimit(limit = false)
+	public ReturnT<String> registry(HttpServletRequest request, @RequestBody(required = false) String data) {
+		// valid
+		if (XxlJobAdminConfig.getAdminConfig().getAccessToken() != null
+				&& XxlJobAdminConfig.getAdminConfig().getAccessToken().trim().length() > 0
+				&& !XxlJobAdminConfig.getAdminConfig().getAccessToken().equals(request.getHeader(XxlJobRemotingUtil.XXL_RPC_ACCESS_TOKEN))) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
+		}
+
+		// param
+		RegistryParam registryParam = null;
+		try {
+			registryParam = JacksonUtil.readValue(data, RegistryParam.class);
+		} catch (Exception e) {
+		}
+		if (registryParam == null) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The request data invalid.");
+		}
+
+		// invoke
+		return adminBiz.registry(registryParam);
+	}
+
+	/**
+	 * registry remove
+	 *
+	 * @param data
+	 * @return
+	 */
+	@RequestMapping("/registryRemove")
+	@ResponseBody
+	@PermissionLimit(limit = false)
+	public ReturnT<String> registryRemove(HttpServletRequest request, @RequestBody(required = false) String data) {
+		// valid
+		if (XxlJobAdminConfig.getAdminConfig().getAccessToken() != null
+				&& XxlJobAdminConfig.getAdminConfig().getAccessToken().trim().length() > 0
+				&& !XxlJobAdminConfig.getAdminConfig().getAccessToken().equals(request.getHeader(XxlJobRemotingUtil.XXL_RPC_ACCESS_TOKEN))) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The access token is wrong.");
+		}
+
+		// param
+		RegistryParam registryParam = null;
+		try {
+			registryParam = JacksonUtil.readValue(data, RegistryParam.class);
+		} catch (Exception e) {
+		}
+		if (registryParam == null) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "The request data invalid.");
+		}
+
+		// invoke
+		return adminBiz.registryRemove(registryParam);
+	}
+
+	// ---------------------- job biz ----------------------
+
+}

src/main/java/com/xxl/job/admin/controller/JobCodeController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobLogGlue;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobInfoDao;
+import com.xxl.job.admin.dao.XxlJobLogGlueDao;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.glue.GlueTypeEnum;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * job code controller
+ *
+ * @author xuxueli 2015-12-19 16:13:16
+ */
+@Controller
+@RequestMapping("/jobcode")
+public class JobCodeController {
+
+	@Resource
+	private XxlJobInfoDao xxlJobInfoDao;
+	@Resource
+	private XxlJobLogGlueDao xxlJobLogGlueDao;
+
+	@RequestMapping
+	public String index(HttpServletRequest request, Model model, int jobId) {
+		XxlJobInfo jobInfo = xxlJobInfoDao.loadById(jobId);
+		List<XxlJobLogGlue> jobLogGlues = xxlJobLogGlueDao.findByJobId(jobId);
+
+		if (jobInfo == null) {
+			throw new RuntimeException(I18nUtil.getString("jobinfo_glue_jobid_unvalid"));
+		}
+		if (GlueTypeEnum.BEAN == GlueTypeEnum.match(jobInfo.getGlueType())) {
+			throw new RuntimeException(I18nUtil.getString("jobinfo_glue_gluetype_unvalid"));
+		}
+
+		// valid permission
+		JobInfoController.validPermission(request, jobInfo.getJobGroup());
+
+		// Glue类型-字典
+		model.addAttribute("GlueTypeEnum", GlueTypeEnum.values());
+
+		model.addAttribute("jobInfo", jobInfo);
+		model.addAttribute("jobLogGlues", jobLogGlues);
+		return "jobcode/jobcode.index";
+	}
+
+	@RequestMapping("/save")
+	@ResponseBody
+	public ReturnT<String> save(Model model, int id, String glueSource, String glueRemark) {
+		// valid
+		if (glueRemark == null) {
+			return new ReturnT<String>(500, (I18nUtil.getString("system_please_input") + I18nUtil.getString("jobinfo_glue_remark")));
+		}
+		if (glueRemark.length() < 4 || glueRemark.length() > 100) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobinfo_glue_remark_limit"));
+		}
+		XxlJobInfo exists_jobInfo = xxlJobInfoDao.loadById(id);
+		if (exists_jobInfo == null) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobinfo_glue_jobid_unvalid"));
+		}
+
+		// update new code
+		exists_jobInfo.setGlueSource(glueSource);
+		exists_jobInfo.setGlueRemark(glueRemark);
+		exists_jobInfo.setGlueUpdatetime(new Date());
+
+		exists_jobInfo.setUpdateTime(new Date());
+		xxlJobInfoDao.update(exists_jobInfo);
+
+		// log old code
+		XxlJobLogGlue xxlJobLogGlue = new XxlJobLogGlue();
+		xxlJobLogGlue.setJobId(exists_jobInfo.getId());
+		xxlJobLogGlue.setGlueType(exists_jobInfo.getGlueType());
+		xxlJobLogGlue.setGlueSource(glueSource);
+		xxlJobLogGlue.setGlueRemark(glueRemark);
+
+		xxlJobLogGlue.setAddTime(new Date());
+		xxlJobLogGlue.setUpdateTime(new Date());
+		xxlJobLogGlueDao.save(xxlJobLogGlue);
+
+		// remove code backup more than 30
+		xxlJobLogGlueDao.removeOld(exists_jobInfo.getId(), 30);
+
+		return ReturnT.SUCCESS;
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/JobGroupController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobRegistry;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobGroupDao;
+import com.xxl.job.admin.dao.XxlJobInfoDao;
+import com.xxl.job.admin.dao.XxlJobRegistryDao;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.enums.RegistryConfig;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import java.util.*;
+
+/**
+ * job group controller
+ *
+ * @author xuxueli 2016-10-02 20:52:56
+ */
+@Controller
+@RequestMapping("/jobgroup")
+public class JobGroupController {
+
+	@Resource
+	public XxlJobInfoDao xxlJobInfoDao;
+	@Resource
+	public XxlJobGroupDao xxlJobGroupDao;
+	@Resource
+	private XxlJobRegistryDao xxlJobRegistryDao;
+
+	@RequestMapping
+	public String index(Model model) {
+
+		// job group (executor)
+		List<XxlJobGroup> list = xxlJobGroupDao.findAll();
+
+		model.addAttribute("list", list);
+		return "jobgroup/jobgroup.index";
+	}
+
+	@RequestMapping("/save")
+	@ResponseBody
+	public ReturnT<String> save(XxlJobGroup xxlJobGroup) {
+
+		// valid
+		if (xxlJobGroup.getAppName() == null || xxlJobGroup.getAppName().trim().length() == 0) {
+			return new ReturnT<String>(500, (I18nUtil.getString("system_please_input") + "AppName"));
+		}
+		if (xxlJobGroup.getAppName().length() < 4 || xxlJobGroup.getAppName().length() > 64) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_appName_length"));
+		}
+		if (xxlJobGroup.getTitle() == null || xxlJobGroup.getTitle().trim().length() == 0) {
+			return new ReturnT<String>(500, (I18nUtil.getString("system_please_input") + I18nUtil.getString("jobgroup_field_title")));
+		}
+		if (xxlJobGroup.getAddressType() != 0) {
+			if (xxlJobGroup.getAddressList() == null || xxlJobGroup.getAddressList().trim().length() == 0) {
+				return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_addressType_limit"));
+			}
+			String[] addresss = xxlJobGroup.getAddressList().split(",");
+			for (String item : addresss) {
+				if (item == null || item.trim().length() == 0) {
+					return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_registryList_unvalid"));
+				}
+			}
+		}
+
+		int ret = xxlJobGroupDao.save(xxlJobGroup);
+		return (ret > 0) ? ReturnT.SUCCESS : ReturnT.FAIL;
+	}
+
+	@RequestMapping("/update")
+	@ResponseBody
+	public ReturnT<String> update(XxlJobGroup xxlJobGroup) {
+		// valid
+		if (xxlJobGroup.getAppName() == null || xxlJobGroup.getAppName().trim().length() == 0) {
+			return new ReturnT<String>(500, (I18nUtil.getString("system_please_input") + "AppName"));
+		}
+		if (xxlJobGroup.getAppName().length() < 4 || xxlJobGroup.getAppName().length() > 64) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_appName_length"));
+		}
+		if (xxlJobGroup.getTitle() == null || xxlJobGroup.getTitle().trim().length() == 0) {
+			return new ReturnT<String>(500, (I18nUtil.getString("system_please_input") + I18nUtil.getString("jobgroup_field_title")));
+		}
+		if (xxlJobGroup.getAddressType() == 0) {
+			// 0=自动注册
+			List<String> registryList = findRegistryByAppName(xxlJobGroup.getAppName());
+			String addressListStr = null;
+			if (registryList != null && !registryList.isEmpty()) {
+				Collections.sort(registryList);
+				addressListStr = "";
+				for (String item : registryList) {
+					addressListStr += item + ",";
+				}
+				addressListStr = addressListStr.substring(0, addressListStr.length() - 1);
+			}
+			xxlJobGroup.setAddressList(addressListStr);
+		} else {
+			// 1=手动录入
+			if (xxlJobGroup.getAddressList() == null || xxlJobGroup.getAddressList().trim().length() == 0) {
+				return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_addressType_limit"));
+			}
+			String[] addresss = xxlJobGroup.getAddressList().split(",");
+			for (String item : addresss) {
+				if (item == null || item.trim().length() == 0) {
+					return new ReturnT<String>(500, I18nUtil.getString("jobgroup_field_registryList_unvalid"));
+				}
+			}
+		}
+
+		int ret = xxlJobGroupDao.update(xxlJobGroup);
+		return (ret > 0) ? ReturnT.SUCCESS : ReturnT.FAIL;
+	}
+
+	private List<String> findRegistryByAppName(String appNameParam) {
+		HashMap<String, List<String>> appAddressMap = new HashMap<String, List<String>>();
+		List<XxlJobRegistry> list = xxlJobRegistryDao.findAll(RegistryConfig.DEAD_TIMEOUT, new Date());
+		if (list != null) {
+			for (XxlJobRegistry item : list) {
+				if (RegistryConfig.RegistType.EXECUTOR.name().equals(item.getRegistryGroup())) {
+					String appName = item.getRegistryKey();
+					List<String> registryList = appAddressMap.get(appName);
+					if (registryList == null) {
+						registryList = new ArrayList<String>();
+					}
+
+					if (!registryList.contains(item.getRegistryValue())) {
+						registryList.add(item.getRegistryValue());
+					}
+					appAddressMap.put(appName, registryList);
+				}
+			}
+		}
+		return appAddressMap.get(appNameParam);
+	}
+
+	@RequestMapping("/remove")
+	@ResponseBody
+	public ReturnT<String> remove(int id) {
+
+		// valid
+		int count = xxlJobInfoDao.pageListCount(0, 10, id, -1, null, null, null);
+		if (count > 0) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobgroup_del_limit_0"));
+		}
+
+		List<XxlJobGroup> allList = xxlJobGroupDao.findAll();
+		if (allList.size() == 1) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobgroup_del_limit_1"));
+		}
+
+		int ret = xxlJobGroupDao.remove(id);
+		return (ret > 0) ? ReturnT.SUCCESS : ReturnT.FAIL;
+	}
+
+	@RequestMapping("/loadById")
+	@ResponseBody
+	public ReturnT<XxlJobGroup> loadById(int id) {
+		XxlJobGroup jobGroup = xxlJobGroupDao.load(id);
+		return jobGroup != null ? new ReturnT<XxlJobGroup>(jobGroup) : new ReturnT<XxlJobGroup>(ReturnT.FAIL_CODE, null);
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/JobInfoController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.core.cron.CronExpression;
+import com.xxl.job.admin.core.exception.XxlJobException;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobUser;
+import com.xxl.job.admin.core.route.ExecutorRouteStrategyEnum;
+import com.xxl.job.admin.core.thread.JobTriggerPoolHelper;
+import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobGroupDao;
+import com.xxl.job.admin.service.LoginService;
+import com.xxl.job.admin.service.XxlJobService;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.enums.ExecutorBlockStrategyEnum;
+import com.xxl.job.core.glue.GlueTypeEnum;
+import com.xxl.job.core.util.DateUtil;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.text.ParseException;
+import java.util.*;
+
+/**
+ * index controller
+ *
+ * @author xuxueli 2015-12-19 16:13:16
+ */
+@Controller
+@RequestMapping("/jobinfo")
+public class JobInfoController {
+
+	@Resource
+	private XxlJobGroupDao xxlJobGroupDao;
+	@Resource
+	private XxlJobService xxlJobService;
+
+	@RequestMapping
+	public String index(HttpServletRequest request, Model model, @RequestParam(required = false, defaultValue = "-1") int jobGroup) {
+
+		// 枚举-字典
+		model.addAttribute("ExecutorRouteStrategyEnum", ExecutorRouteStrategyEnum.values());        // 路由策略-列表
+		model.addAttribute("GlueTypeEnum", GlueTypeEnum.values());                                // Glue类型-字典
+		model.addAttribute("ExecutorBlockStrategyEnum", ExecutorBlockStrategyEnum.values());        // 阻塞处理策略-字典
+
+		// 执行器列表
+		List<XxlJobGroup> jobGroupList_all = xxlJobGroupDao.findAll();
+
+		// filter group
+		List<XxlJobGroup> jobGroupList = filterJobGroupByRole(request, jobGroupList_all);
+		if (jobGroupList == null || jobGroupList.size() == 0) {
+			throw new XxlJobException(I18nUtil.getString("jobgroup_empty"));
+		}
+
+		model.addAttribute("JobGroupList", jobGroupList);
+		model.addAttribute("jobGroup", jobGroup);
+
+		return "jobinfo/jobinfo.index";
+	}
+
+	public static List<XxlJobGroup> filterJobGroupByRole(HttpServletRequest request, List<XxlJobGroup> jobGroupList_all) {
+		List<XxlJobGroup> jobGroupList = new ArrayList<>();
+		if (jobGroupList_all != null && jobGroupList_all.size() > 0) {
+			XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
+			if (loginUser.getRole() == 1) {
+				jobGroupList = jobGroupList_all;
+			} else {
+				List<String> groupIdStrs = new ArrayList<>();
+				if (loginUser.getPermission() != null && loginUser.getPermission().trim().length() > 0) {
+					groupIdStrs = Arrays.asList(loginUser.getPermission().trim().split(","));
+				}
+				for (XxlJobGroup groupItem : jobGroupList_all) {
+					if (groupIdStrs.contains(String.valueOf(groupItem.getId()))) {
+						jobGroupList.add(groupItem);
+					}
+				}
+			}
+		}
+		return jobGroupList;
+	}
+
+	public static void validPermission(HttpServletRequest request, int jobGroup) {
+		XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
+		if (!loginUser.validPermission(jobGroup)) {
+			throw new RuntimeException(I18nUtil.getString("system_permission_limit") + "[username=" + loginUser.getUsername() + "]");
+		}
+	}
+
+	@RequestMapping("/pageList")
+	@ResponseBody
+	public Map<String, Object> pageList(@RequestParam(required = false, defaultValue = "0") int start,
+	                                    @RequestParam(required = false, defaultValue = "10") int length,
+	                                    int jobGroup, int triggerStatus, String jobDesc, String executorHandler, String author) {
+
+		return xxlJobService.pageList(start, length, jobGroup, triggerStatus, jobDesc, executorHandler, author);
+	}
+
+	@RequestMapping("/add")
+	@ResponseBody
+	public ReturnT<String> add(XxlJobInfo jobInfo) {
+		return xxlJobService.add(jobInfo);
+	}
+
+	@RequestMapping("/update")
+	@ResponseBody
+	public ReturnT<String> update(XxlJobInfo jobInfo) {
+		return xxlJobService.update(jobInfo);
+	}
+
+	@RequestMapping("/remove")
+	@ResponseBody
+	public ReturnT<String> remove(int id) {
+		return xxlJobService.remove(id);
+	}
+
+	@RequestMapping("/stop")
+	@ResponseBody
+	public ReturnT<String> pause(int id) {
+		return xxlJobService.stop(id);
+	}
+
+	@RequestMapping("/start")
+	@ResponseBody
+	public ReturnT<String> start(int id) {
+		return xxlJobService.start(id);
+	}
+
+	@RequestMapping("/trigger")
+	@ResponseBody
+	//@PermissionLimit(limit = false)
+	public ReturnT<String> triggerJob(int id, String executorParam) {
+		// force cover job param
+		if (executorParam == null) {
+			executorParam = "";
+		}
+
+		JobTriggerPoolHelper.trigger(id, TriggerTypeEnum.MANUAL, -1, null, executorParam);
+		return ReturnT.SUCCESS;
+	}
+
+	@RequestMapping("/nextTriggerTime")
+	@ResponseBody
+	public ReturnT<List<String>> nextTriggerTime(String cron) {
+		List<String> result = new ArrayList<>();
+		try {
+			CronExpression cronExpression = new CronExpression(cron);
+			Date lastTime = new Date();
+			for (int i = 0; i < 5; i++) {
+				lastTime = cronExpression.getNextValidTimeAfter(lastTime);
+				if (lastTime != null) {
+					result.add(DateUtil.formatDateTime(lastTime));
+				} else {
+					break;
+				}
+			}
+		} catch (ParseException e) {
+			return new ReturnT<List<String>>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_unvalid"));
+		}
+		return new ReturnT<List<String>>(result);
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/JobLogController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.core.scheduler.XxlJobScheduler;
+import com.xxl.job.admin.core.exception.XxlJobException;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobLog;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobGroupDao;
+import com.xxl.job.admin.dao.XxlJobInfoDao;
+import com.xxl.job.admin.dao.XxlJobLogDao;
+import com.xxl.job.core.biz.ExecutorBiz;
+import com.xxl.job.core.biz.model.LogResult;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.util.DateUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * index controller
+ *
+ * @author xuxueli 2015-12-19 16:13:16
+ */
+@Controller
+@RequestMapping("/joblog")
+public class JobLogController {
+	private static Logger logger = LoggerFactory.getLogger(JobLogController.class);
+
+	@Resource
+	private XxlJobGroupDao xxlJobGroupDao;
+	@Resource
+	public XxlJobInfoDao xxlJobInfoDao;
+	@Resource
+	public XxlJobLogDao xxlJobLogDao;
+
+	@RequestMapping
+	public String index(HttpServletRequest request, Model model, @RequestParam(required = false, defaultValue = "0") Integer jobId) {
+
+		// 执行器列表
+		List<XxlJobGroup> jobGroupList_all = xxlJobGroupDao.findAll();
+
+		// filter group
+		List<XxlJobGroup> jobGroupList = JobInfoController.filterJobGroupByRole(request, jobGroupList_all);
+		if (jobGroupList == null || jobGroupList.size() == 0) {
+			throw new XxlJobException(I18nUtil.getString("jobgroup_empty"));
+		}
+
+		model.addAttribute("JobGroupList", jobGroupList);
+
+		// 任务
+		if (jobId > 0) {
+			XxlJobInfo jobInfo = xxlJobInfoDao.loadById(jobId);
+			if (jobInfo == null) {
+				throw new RuntimeException(I18nUtil.getString("jobinfo_field_id") + I18nUtil.getString("system_unvalid"));
+			}
+
+			model.addAttribute("jobInfo", jobInfo);
+
+			// valid permission
+			JobInfoController.validPermission(request, jobInfo.getJobGroup());
+		}
+
+		return "joblog/joblog.index";
+	}
+
+	@RequestMapping("/getJobsByGroup")
+	@ResponseBody
+	public ReturnT<List<XxlJobInfo>> getJobsByGroup(int jobGroup) {
+		List<XxlJobInfo> list = xxlJobInfoDao.getJobsByGroup(jobGroup);
+		return new ReturnT<List<XxlJobInfo>>(list);
+	}
+
+	@RequestMapping("/pageList")
+	@ResponseBody
+	public Map<String, Object> pageList(HttpServletRequest request,
+	                                    @RequestParam(required = false, defaultValue = "0") int start,
+	                                    @RequestParam(required = false, defaultValue = "10") int length,
+	                                    int jobGroup, int jobId, int logStatus, String filterTime) {
+
+		// valid permission
+		JobInfoController.validPermission(request, jobGroup);    // 仅管理员支持查询全部；普通用户仅支持查询有权限的 jobGroup
+
+		// parse param
+		Date triggerTimeStart = null;
+		Date triggerTimeEnd = null;
+		if (filterTime != null && filterTime.trim().length() > 0) {
+			String[] temp = filterTime.split(" - ");
+			if (temp.length == 2) {
+				triggerTimeStart = DateUtil.parseDateTime(temp[0]);
+				triggerTimeEnd = DateUtil.parseDateTime(temp[1]);
+			}
+		}
+
+		// page query
+		List<XxlJobLog> list = xxlJobLogDao.pageList(start, length, jobGroup, jobId, triggerTimeStart, triggerTimeEnd, logStatus);
+		int list_count = xxlJobLogDao.pageListCount(start, length, jobGroup, jobId, triggerTimeStart, triggerTimeEnd, logStatus);
+
+		// package result
+		Map<String, Object> maps = new HashMap<String, Object>();
+		maps.put("recordsTotal", list_count);        // 总记录数
+		maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
+		maps.put("data", list);                    // 分页列表
+		return maps;
+	}
+
+	@RequestMapping("/logDetailPage")
+	public String logDetailPage(int id, Model model) {
+
+		// base check
+		ReturnT<String> logStatue = ReturnT.SUCCESS;
+		XxlJobLog jobLog = xxlJobLogDao.load(id);
+		if (jobLog == null) {
+			throw new RuntimeException(I18nUtil.getString("joblog_logid_unvalid"));
+		}
+
+		model.addAttribute("triggerCode", jobLog.getTriggerCode());
+		model.addAttribute("handleCode", jobLog.getHandleCode());
+		model.addAttribute("executorAddress", jobLog.getExecutorAddress());
+		model.addAttribute("triggerTime", jobLog.getTriggerTime().getTime());
+		model.addAttribute("logId", jobLog.getId());
+		return "joblog/joblog.detail";
+	}
+
+	@RequestMapping("/logDetailCat")
+	@ResponseBody
+	public ReturnT<LogResult> logDetailCat(String executorAddress, long triggerTime, long logId, int fromLineNum) {
+		try {
+			ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(executorAddress);
+			ReturnT<LogResult> logResult = executorBiz.log(triggerTime, logId, fromLineNum);
+
+			// is end
+			if (logResult.getContent() != null && logResult.getContent().getFromLineNum() > logResult.getContent().getToLineNum()) {
+				XxlJobLog jobLog = xxlJobLogDao.load(logId);
+				if (jobLog.getHandleCode() > 0) {
+					logResult.getContent().setEnd(true);
+				}
+			}
+
+			return logResult;
+		} catch (Exception e) {
+			logger.error(e.getMessage(), e);
+			return new ReturnT<LogResult>(ReturnT.FAIL_CODE, e.getMessage());
+		}
+	}
+
+	@RequestMapping("/logKill")
+	@ResponseBody
+	public ReturnT<String> logKill(int id) {
+		// base check
+		XxlJobLog log = xxlJobLogDao.load(id);
+		XxlJobInfo jobInfo = xxlJobInfoDao.loadById(log.getJobId());
+		if (jobInfo == null) {
+			return new ReturnT<String>(500, I18nUtil.getString("jobinfo_glue_jobid_unvalid"));
+		}
+		if (ReturnT.SUCCESS_CODE != log.getTriggerCode()) {
+			return new ReturnT<String>(500, I18nUtil.getString("joblog_kill_log_limit"));
+		}
+
+		// request of kill
+		ReturnT<String> runResult = null;
+		try {
+			ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(log.getExecutorAddress());
+			runResult = executorBiz.kill(jobInfo.getId());
+		} catch (Exception e) {
+			logger.error(e.getMessage(), e);
+			runResult = new ReturnT<String>(500, e.getMessage());
+		}
+
+		if (ReturnT.SUCCESS_CODE == runResult.getCode()) {
+			log.setHandleCode(ReturnT.FAIL_CODE);
+			log.setHandleMsg(I18nUtil.getString("joblog_kill_log_byman") + ":" + (runResult.getMsg() != null ? runResult.getMsg() : ""));
+			log.setHandleTime(new Date());
+			xxlJobLogDao.updateHandleInfo(log);
+			return new ReturnT<String>(runResult.getMsg());
+		} else {
+			return new ReturnT<String>(500, runResult.getMsg());
+		}
+	}
+
+	@RequestMapping("/clearLog")
+	@ResponseBody
+	public ReturnT<String> clearLog(int jobGroup, int jobId, int type) {
+
+		Date clearBeforeTime = null;
+		int clearBeforeNum = 0;
+		if (type == 1) {
+			clearBeforeTime = DateUtil.addMonths(new Date(), -1);    // 清理一个月之前日志数据
+		} else if (type == 2) {
+			clearBeforeTime = DateUtil.addMonths(new Date(), -3);    // 清理三个月之前日志数据
+		} else if (type == 3) {
+			clearBeforeTime = DateUtil.addMonths(new Date(), -6);    // 清理六个月之前日志数据
+		} else if (type == 4) {
+			clearBeforeTime = DateUtil.addYears(new Date(), -1);    // 清理一年之前日志数据
+		} else if (type == 5) {
+			clearBeforeNum = 1000;        // 清理一千条以前日志数据
+		} else if (type == 6) {
+			clearBeforeNum = 10000;        // 清理一万条以前日志数据
+		} else if (type == 7) {
+			clearBeforeNum = 30000;        // 清理三万条以前日志数据
+		} else if (type == 8) {
+			clearBeforeNum = 100000;    // 清理十万条以前日志数据
+		} else if (type == 9) {
+			clearBeforeNum = 0;            // 清理所有日志数据
+		} else {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("joblog_clean_type_unvalid"));
+		}
+
+		List<Long> logIds = null;
+		do {
+			logIds = xxlJobLogDao.findClearLogIds(jobGroup, jobId, clearBeforeTime, clearBeforeNum, 1000);
+			if (logIds != null && logIds.size() > 0) {
+				xxlJobLogDao.clearLog(logIds);
+			}
+		} while (logIds != null && logIds.size() > 0);
+
+		return ReturnT.SUCCESS;
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/UserController.java

+package com.xxl.job.admin.controller;
+
+import com.xxl.job.admin.controller.annotation.PermissionLimit;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobUser;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobGroupDao;
+import com.xxl.job.admin.dao.XxlJobUserDao;
+import com.xxl.job.admin.service.LoginService;
+import com.xxl.job.core.biz.model.ReturnT;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.util.DigestUtils;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author xuxueli 2019-05-04 16:39:50
+ */
+@Controller
+@RequestMapping("/user")
+public class UserController {
+
+	@Resource
+	private XxlJobUserDao xxlJobUserDao;
+	@Resource
+	private XxlJobGroupDao xxlJobGroupDao;
+
+	@RequestMapping
+	@PermissionLimit(adminuser = true)
+	public String index(Model model) {
+
+		// 执行器列表
+		List<XxlJobGroup> groupList = xxlJobGroupDao.findAll();
+		model.addAttribute("groupList", groupList);
+
+		return "user/user.index";
+	}
+
+	@RequestMapping("/pageList")
+	@ResponseBody
+	@PermissionLimit(adminuser = true)
+	public Map<String, Object> pageList(@RequestParam(required = false, defaultValue = "0") int start,
+	                                    @RequestParam(required = false, defaultValue = "10") int length,
+	                                    String username, int role) {
+
+		// page list
+		List<XxlJobUser> list = xxlJobUserDao.pageList(start, length, username, role);
+		int list_count = xxlJobUserDao.pageListCount(start, length, username, role);
+
+		// package result
+		Map<String, Object> maps = new HashMap<String, Object>();
+		maps.put("recordsTotal", list_count);        // 总记录数
+		maps.put("recordsFiltered", list_count);    // 过滤后的总记录数
+		maps.put("data", list);                    // 分页列表
+		return maps;
+	}
+
+	@RequestMapping("/add")
+	@ResponseBody
+	@PermissionLimit(adminuser = true)
+	public ReturnT<String> add(XxlJobUser xxlJobUser) {
+
+		// valid username
+		if (!StringUtils.hasText(xxlJobUser.getUsername())) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_please_input") + I18nUtil.getString("user_username"));
+		}
+		xxlJobUser.setUsername(xxlJobUser.getUsername().trim());
+		if (!(xxlJobUser.getUsername().length() >= 4 && xxlJobUser.getUsername().length() <= 20)) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_lengh_limit") + "[4-20]");
+		}
+		// valid password
+		if (!StringUtils.hasText(xxlJobUser.getPassword())) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_please_input") + I18nUtil.getString("user_password"));
+		}
+		xxlJobUser.setPassword(xxlJobUser.getPassword().trim());
+		if (!(xxlJobUser.getPassword().length() >= 4 && xxlJobUser.getPassword().length() <= 20)) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_lengh_limit") + "[4-20]");
+		}
+		// md5 password
+		xxlJobUser.setPassword(DigestUtils.md5DigestAsHex(xxlJobUser.getPassword().getBytes()));
+
+		// check repeat
+		XxlJobUser existUser = xxlJobUserDao.loadByUserName(xxlJobUser.getUsername());
+		if (existUser != null) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("user_username_repeat"));
+		}
+
+		// write
+		xxlJobUserDao.save(xxlJobUser);
+		return ReturnT.SUCCESS;
+	}
+
+	@RequestMapping("/update")
+	@ResponseBody
+	@PermissionLimit(adminuser = true)
+	public ReturnT<String> update(HttpServletRequest request, XxlJobUser xxlJobUser) {
+
+		// avoid opt login seft
+		XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
+		if (loginUser.getUsername().equals(xxlJobUser.getUsername())) {
+			return new ReturnT<String>(ReturnT.FAIL.getCode(), I18nUtil.getString("user_update_loginuser_limit"));
+		}
+
+		// valid password
+		if (StringUtils.hasText(xxlJobUser.getPassword())) {
+			xxlJobUser.setPassword(xxlJobUser.getPassword().trim());
+			if (!(xxlJobUser.getPassword().length() >= 4 && xxlJobUser.getPassword().length() <= 20)) {
+				return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_lengh_limit") + "[4-20]");
+			}
+			// md5 password
+			xxlJobUser.setPassword(DigestUtils.md5DigestAsHex(xxlJobUser.getPassword().getBytes()));
+		} else {
+			xxlJobUser.setPassword(null);
+		}
+
+		// write
+		xxlJobUserDao.update(xxlJobUser);
+		return ReturnT.SUCCESS;
+	}
+
+	@RequestMapping("/remove")
+	@ResponseBody
+	@PermissionLimit(adminuser = true)
+	public ReturnT<String> remove(HttpServletRequest request, int id) {
+
+		// avoid opt login seft
+		XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
+		if (loginUser.getId() == id) {
+			return new ReturnT<String>(ReturnT.FAIL.getCode(), I18nUtil.getString("user_update_loginuser_limit"));
+		}
+
+		xxlJobUserDao.delete(id);
+		return ReturnT.SUCCESS;
+	}
+
+	@RequestMapping("/updatePwd")
+	@ResponseBody
+	public ReturnT<String> updatePwd(HttpServletRequest request, String password) {
+
+		// valid password
+		if (password == null || password.trim().length() == 0) {
+			return new ReturnT<String>(ReturnT.FAIL.getCode(), "密码不可为空");
+		}
+		password = password.trim();
+		if (!(password.length() >= 4 && password.length() <= 20)) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("system_lengh_limit") + "[4-20]");
+		}
+
+		// md5 password
+		String md5Password = DigestUtils.md5DigestAsHex(password.getBytes());
+
+		// update pwd
+		XxlJobUser loginUser = (XxlJobUser) request.getAttribute(LoginService.LOGIN_IDENTITY_KEY);
+
+		// do write
+		XxlJobUser existUser = xxlJobUserDao.loadByUserName(loginUser.getUsername());
+		existUser.setPassword(md5Password);
+		xxlJobUserDao.update(existUser);
+
+		return ReturnT.SUCCESS;
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/annotation/PermissionLimit.java

+package com.xxl.job.admin.controller.annotation;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 权限限制
+ *
+ * @author xuxueli 2015-12-12 18:29:02
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface PermissionLimit {
+
+	/**
+	 * 登录拦截 (默认拦截)
+	 */
+	boolean limit() default true;
+
+	/**
+	 * 要求管理员权限
+	 *
+	 * @return
+	 */
+	boolean adminuser() default false;
+
+}
\ No newline at end of file

src/main/java/com/xxl/job/admin/controller/interceptor/CookieInterceptor.java

+package com.xxl.job.admin.controller.interceptor;
+
+import com.xxl.job.admin.core.util.FtlUtil;
+import com.xxl.job.admin.core.util.I18nUtil;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+
+/**
+ * push cookies to model as cookieMap
+ *
+ * @author xuxueli 2015-12-12 18:09:04
+ */
+@Component
+public class CookieInterceptor extends HandlerInterceptorAdapter {
+
+	@Override
+	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
+	                       ModelAndView modelAndView) throws Exception {
+
+		// cookie
+		if (modelAndView != null && request.getCookies() != null && request.getCookies().length > 0) {
+			HashMap<String, Cookie> cookieMap = new HashMap<String, Cookie>();
+			for (Cookie ck : request.getCookies()) {
+				cookieMap.put(ck.getName(), ck);
+			}
+			modelAndView.addObject("cookieMap", cookieMap);
+		}
+
+		// static method
+		if (modelAndView != null) {
+			modelAndView.addObject("I18nUtil", FtlUtil.generateStaticModel(I18nUtil.class.getName()));
+		}
+
+		super.postHandle(request, response, handler, modelAndView);
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/interceptor/PermissionInterceptor.java

+package com.xxl.job.admin.controller.interceptor;
+
+import com.xxl.job.admin.controller.annotation.PermissionLimit;
+import com.xxl.job.admin.core.model.XxlJobUser;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.service.LoginService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * 权限拦截
+ *
+ * @author xuxueli 2015-12-12 18:09:04
+ */
+@Component
+public class PermissionInterceptor extends HandlerInterceptorAdapter {
+
+	@Resource
+	private LoginService loginService;
+
+	@Override
+	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+
+		if (!(handler instanceof HandlerMethod)) {
+			return super.preHandle(request, response, handler);
+		}
+
+		// if need login
+		boolean needLogin = true;
+		boolean needAdminuser = false;
+		HandlerMethod method = (HandlerMethod) handler;
+		PermissionLimit permission = method.getMethodAnnotation(PermissionLimit.class);
+		if (permission != null) {
+			needLogin = permission.limit();
+			needAdminuser = permission.adminuser();
+		}
+
+		if (needLogin) {
+			XxlJobUser loginUser = loginService.ifLogin(request, response);
+			if (loginUser == null) {
+				response.sendRedirect(request.getContextPath() + "/toLogin");
+				//request.getRequestDispatcher("/toLogin").forward(request, response);
+				return false;
+			}
+			if (needAdminuser && loginUser.getRole() != 1) {
+				throw new RuntimeException(I18nUtil.getString("system_permission_limit"));
+			}
+			request.setAttribute(LoginService.LOGIN_IDENTITY_KEY, loginUser);
+		}
+
+		return super.preHandle(request, response, handler);
+	}
+
+}

src/main/java/com/xxl/job/admin/controller/interceptor/WebMvcConfig.java

+package com.xxl.job.admin.controller.interceptor;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+
+import javax.annotation.Resource;
+
+/**
+ * web mvc config
+ *
+ * @author xuxueli 2018-04-02 20:48:20
+ */
+@Configuration
+public class WebMvcConfig extends WebMvcConfigurerAdapter {
+
+	@Resource
+	private PermissionInterceptor permissionInterceptor;
+	@Resource
+	private CookieInterceptor cookieInterceptor;
+
+	@Override
+	public void addInterceptors(InterceptorRegistry registry) {
+		registry.addInterceptor(permissionInterceptor).addPathPatterns("/**");
+		registry.addInterceptor(cookieInterceptor).addPathPatterns("/**");
+		super.addInterceptors(registry);
+	}
+
+}
\ No newline at end of file

src/main/java/com/xxl/job/admin/controller/resolver/WebExceptionResolver.java

+package com.xxl.job.admin.controller.resolver;
+
+import com.xxl.job.admin.core.exception.XxlJobException;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.admin.core.util.JacksonUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.HandlerExceptionResolver;
+import org.springframework.web.servlet.ModelAndView;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+/**
+ * common exception resolver
+ *
+ * @author xuxueli 2016-1-6 19:22:18
+ */
+@Component
+public class WebExceptionResolver implements HandlerExceptionResolver {
+	private static transient Logger logger = LoggerFactory.getLogger(WebExceptionResolver.class);
+
+	@Override
+	public ModelAndView resolveException(HttpServletRequest request,
+	                                     HttpServletResponse response, Object handler, Exception ex) {
+
+		if (!(ex instanceof XxlJobException)) {
+			logger.error("WebExceptionResolver:{}", ex);
+		}
+
+		// if json
+		boolean isJson = false;
+		HandlerMethod method = (HandlerMethod) handler;
+		ResponseBody responseBody = method.getMethodAnnotation(ResponseBody.class);
+		if (responseBody != null) {
+			isJson = true;
+		}
+
+		// error result
+		ReturnT<String> errorResult = new ReturnT<String>(ReturnT.FAIL_CODE, ex.toString().replaceAll("\n", "<br/>"));
+
+		// response
+		ModelAndView mv = new ModelAndView();
+		if (isJson) {
+			try {
+				response.setContentType("application/json;charset=utf-8");
+				response.getWriter().print(JacksonUtil.writeValueAsString(errorResult));
+			} catch (IOException e) {
+				logger.error(e.getMessage(), e);
+			}
+			return mv;
+		} else {
+
+			mv.addObject("exceptionMsg", errorResult.getMsg());
+			mv.setViewName("/common/common.exception");
+			return mv;
+		}
+	}
+
+}
\ No newline at end of file

src/main/java/com/xxl/job/admin/core/conf/XxlJobAdminConfig.java

+package com.xxl.job.admin.core.conf;
+
+import com.xxl.job.admin.core.scheduler.XxlJobScheduler;
+import com.xxl.job.admin.dao.*;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import javax.sql.DataSource;
+
+/**
+ * xxl-job config
+ *
+ * @author xuxueli 2017-04-28
+ */
+
+@Component
+public class XxlJobAdminConfig implements InitializingBean, DisposableBean {
+
+	private static XxlJobAdminConfig adminConfig = null;
+
+	public static XxlJobAdminConfig getAdminConfig() {
+		return adminConfig;
+	}
+
+
+	// ---------------------- XxlJobScheduler ----------------------
+
+	private XxlJobScheduler xxlJobScheduler;
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		adminConfig = this;
+
+		xxlJobScheduler = new XxlJobScheduler();
+		xxlJobScheduler.init();
+	}
+
+	@Override
+	public void destroy() throws Exception {
+		xxlJobScheduler.destroy();
+	}
+
+
+	// ---------------------- XxlJobScheduler ----------------------
+
+	// conf
+	@Value("${xxl.job.i18n}")
+	private String i18n;
+
+	@Value("${xxl.job.accessToken}")
+	private String accessToken;
+
+	@Value("${spring.mail.username}")
+	private String emailUserName;
+
+	@Value("${xxl.job.triggerpool.fast.max}")
+	private int triggerPoolFastMax;
+
+	@Value("${xxl.job.triggerpool.slow.max}")
+	private int triggerPoolSlowMax;
+
+	@Value("${xxl.job.logretentiondays}")
+	private int logretentiondays;
+
+	// dao, service
+
+	@Resource
+	private XxlJobLogDao xxlJobLogDao;
+	@Resource
+	private XxlJobInfoDao xxlJobInfoDao;
+	@Resource
+	private XxlJobRegistryDao xxlJobRegistryDao;
+	@Resource
+	private XxlJobGroupDao xxlJobGroupDao;
+	@Resource
+	private XxlJobLogReportDao xxlJobLogReportDao;
+	@Resource
+	private JavaMailSender mailSender;
+	@Resource
+	private DataSource dataSource;
+
+
+	public String getI18n() {
+		return i18n;
+	}
+
+	public String getAccessToken() {
+		return accessToken;
+	}
+
+	public String getEmailUserName() {
+		return emailUserName;
+	}
+
+	public int getTriggerPoolFastMax() {
+		if (triggerPoolFastMax < 200) {
+			return 200;
+		}
+		return triggerPoolFastMax;
+	}
+
+	public int getTriggerPoolSlowMax() {
+		if (triggerPoolSlowMax < 100) {
+			return 100;
+		}
+		return triggerPoolSlowMax;
+	}
+
+	public int getLogretentiondays() {
+		if (logretentiondays < 7) {
+			return -1;  // Limit greater than or equal to 7, otherwise close
+		}
+		return logretentiondays;
+	}
+
+	public XxlJobLogDao getXxlJobLogDao() {
+		return xxlJobLogDao;
+	}
+
+	public XxlJobInfoDao getXxlJobInfoDao() {
+		return xxlJobInfoDao;
+	}
+
+	public XxlJobRegistryDao getXxlJobRegistryDao() {
+		return xxlJobRegistryDao;
+	}
+
+	public XxlJobGroupDao getXxlJobGroupDao() {
+		return xxlJobGroupDao;
+	}
+
+	public XxlJobLogReportDao getXxlJobLogReportDao() {
+		return xxlJobLogReportDao;
+	}
+
+	public JavaMailSender getMailSender() {
+		return mailSender;
+	}
+
+	public DataSource getDataSource() {
+		return dataSource;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/exception/XxlJobException.java

+package com.xxl.job.admin.core.exception;
+
+/**
+ * @author xuxueli 2019-05-04 23:19:29
+ */
+public class XxlJobException extends RuntimeException {
+
+	public XxlJobException() {
+	}
+
+	public XxlJobException(String message) {
+		super(message);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobGroup.java

+package com.xxl.job.admin.core.model;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by xuxueli on 16/9/30.
+ */
+public class XxlJobGroup {
+
+	private int id;
+	private String appName;
+	private String title;
+	private int order;
+	private int addressType;        // 执行器地址类型：0=自动注册、1=手动录入
+	private String addressList;     // 执行器地址列表，多地址逗号分隔(手动录入)
+
+	// registry list
+	private List<String> registryList;  // 执行器地址列表(系统注册)
+
+	public List<String> getRegistryList() {
+		if (addressList != null && addressList.trim().length() > 0) {
+			registryList = new ArrayList<String>(Arrays.asList(addressList.split(",")));
+		}
+		return registryList;
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getAppName() {
+		return appName;
+	}
+
+	public void setAppName(String appName) {
+		this.appName = appName;
+	}
+
+	public String getTitle() {
+		return title;
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	public int getOrder() {
+		return order;
+	}
+
+	public void setOrder(int order) {
+		this.order = order;
+	}
+
+	public int getAddressType() {
+		return addressType;
+	}
+
+	public void setAddressType(int addressType) {
+		this.addressType = addressType;
+	}
+
+	public String getAddressList() {
+		return addressList;
+	}
+
+	public void setAddressList(String addressList) {
+		this.addressList = addressList;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobInfo.java

+package com.xxl.job.admin.core.model;
+
+import java.util.Date;
+
+/**
+ * xxl-job info
+ *
+ * @author xuxueli  2016-1-12 18:25:49
+ */
+public class XxlJobInfo {
+
+	private int id;                // 主键ID
+
+	private int jobGroup;        // 执行器主键ID
+	private String jobCron;        // 任务执行CRON表达式
+	private String jobDesc;
+
+	private Date addTime;
+	private Date updateTime;
+
+	private String author;        // 负责人
+	private String alarmEmail;    // 报警邮件
+
+	private String executorRouteStrategy;    // 执行器路由策略
+	private String executorHandler;            // 执行器，任务Handler名称
+	private String executorParam;            // 执行器，任务参数
+	private String executorBlockStrategy;    // 阻塞处理策略
+	private int executorTimeout;            // 任务执行超时时间，单位秒
+	private int executorFailRetryCount;        // 失败重试次数
+
+	private String glueType;        // GLUE类型	#com.xxl.job.core.glue.GlueTypeEnum
+	private String glueSource;        // GLUE源代码
+	private String glueRemark;        // GLUE备注
+	private Date glueUpdatetime;    // GLUE更新时间
+
+	private String childJobId;        // 子任务ID，多个逗号分隔
+
+	private int triggerStatus;        // 调度状态：0-停止，1-运行
+	private long triggerLastTime;    // 上次调度时间
+	private long triggerNextTime;    // 下次调度时间
+
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public int getJobGroup() {
+		return jobGroup;
+	}
+
+	public void setJobGroup(int jobGroup) {
+		this.jobGroup = jobGroup;
+	}
+
+	public String getJobCron() {
+		return jobCron;
+	}
+
+	public void setJobCron(String jobCron) {
+		this.jobCron = jobCron;
+	}
+
+	public String getJobDesc() {
+		return jobDesc;
+	}
+
+	public void setJobDesc(String jobDesc) {
+		this.jobDesc = jobDesc;
+	}
+
+	public Date getAddTime() {
+		return addTime;
+	}
+
+	public void setAddTime(Date addTime) {
+		this.addTime = addTime;
+	}
+
+	public Date getUpdateTime() {
+		return updateTime;
+	}
+
+	public void setUpdateTime(Date updateTime) {
+		this.updateTime = updateTime;
+	}
+
+	public String getAuthor() {
+		return author;
+	}
+
+	public void setAuthor(String author) {
+		this.author = author;
+	}
+
+	public String getAlarmEmail() {
+		return alarmEmail;
+	}
+
+	public void setAlarmEmail(String alarmEmail) {
+		this.alarmEmail = alarmEmail;
+	}
+
+	public String getExecutorRouteStrategy() {
+		return executorRouteStrategy;
+	}
+
+	public void setExecutorRouteStrategy(String executorRouteStrategy) {
+		this.executorRouteStrategy = executorRouteStrategy;
+	}
+
+	public String getExecutorHandler() {
+		return executorHandler;
+	}
+
+	public void setExecutorHandler(String executorHandler) {
+		this.executorHandler = executorHandler;
+	}
+
+	public String getExecutorParam() {
+		return executorParam;
+	}
+
+	public void setExecutorParam(String executorParam) {
+		this.executorParam = executorParam;
+	}
+
+	public String getExecutorBlockStrategy() {
+		return executorBlockStrategy;
+	}
+
+	public void setExecutorBlockStrategy(String executorBlockStrategy) {
+		this.executorBlockStrategy = executorBlockStrategy;
+	}
+
+	public int getExecutorTimeout() {
+		return executorTimeout;
+	}
+
+	public void setExecutorTimeout(int executorTimeout) {
+		this.executorTimeout = executorTimeout;
+	}
+
+	public int getExecutorFailRetryCount() {
+		return executorFailRetryCount;
+	}
+
+	public void setExecutorFailRetryCount(int executorFailRetryCount) {
+		this.executorFailRetryCount = executorFailRetryCount;
+	}
+
+	public String getGlueType() {
+		return glueType;
+	}
+
+	public void setGlueType(String glueType) {
+		this.glueType = glueType;
+	}
+
+	public String getGlueSource() {
+		return glueSource;
+	}
+
+	public void setGlueSource(String glueSource) {
+		this.glueSource = glueSource;
+	}
+
+	public String getGlueRemark() {
+		return glueRemark;
+	}
+
+	public void setGlueRemark(String glueRemark) {
+		this.glueRemark = glueRemark;
+	}
+
+	public Date getGlueUpdatetime() {
+		return glueUpdatetime;
+	}
+
+	public void setGlueUpdatetime(Date glueUpdatetime) {
+		this.glueUpdatetime = glueUpdatetime;
+	}
+
+	public String getChildJobId() {
+		return childJobId;
+	}
+
+	public void setChildJobId(String childJobId) {
+		this.childJobId = childJobId;
+	}
+
+	public int getTriggerStatus() {
+		return triggerStatus;
+	}
+
+	public void setTriggerStatus(int triggerStatus) {
+		this.triggerStatus = triggerStatus;
+	}
+
+	public long getTriggerLastTime() {
+		return triggerLastTime;
+	}
+
+	public void setTriggerLastTime(long triggerLastTime) {
+		this.triggerLastTime = triggerLastTime;
+	}
+
+	public long getTriggerNextTime() {
+		return triggerNextTime;
+	}
+
+	public void setTriggerNextTime(long triggerNextTime) {
+		this.triggerNextTime = triggerNextTime;
+	}
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobLog.java

+package com.xxl.job.admin.core.model;
+
+import java.util.Date;
+
+/**
+ * xxl-job log, used to track trigger process
+ *
+ * @author xuxueli  2015-12-19 23:19:09
+ */
+public class XxlJobLog {
+
+	private long id;
+
+	// job info
+	private int jobGroup;
+	private int jobId;
+
+	// execute info
+	private String executorAddress;
+	private String executorHandler;
+	private String executorParam;
+	private String executorShardingParam;
+	private int executorFailRetryCount;
+
+	// trigger info
+	private Date triggerTime;
+	private int triggerCode;
+	private String triggerMsg;
+
+	// handle info
+	private Date handleTime;
+	private int handleCode;
+	private String handleMsg;
+
+	// alarm info
+	private int alarmStatus;
+
+	public long getId() {
+		return id;
+	}
+
+	public void setId(long id) {
+		this.id = id;
+	}
+
+	public int getJobGroup() {
+		return jobGroup;
+	}
+
+	public void setJobGroup(int jobGroup) {
+		this.jobGroup = jobGroup;
+	}
+
+	public int getJobId() {
+		return jobId;
+	}
+
+	public void setJobId(int jobId) {
+		this.jobId = jobId;
+	}
+
+	public String getExecutorAddress() {
+		return executorAddress;
+	}
+
+	public void setExecutorAddress(String executorAddress) {
+		this.executorAddress = executorAddress;
+	}
+
+	public String getExecutorHandler() {
+		return executorHandler;
+	}
+
+	public void setExecutorHandler(String executorHandler) {
+		this.executorHandler = executorHandler;
+	}
+
+	public String getExecutorParam() {
+		return executorParam;
+	}
+
+	public void setExecutorParam(String executorParam) {
+		this.executorParam = executorParam;
+	}
+
+	public String getExecutorShardingParam() {
+		return executorShardingParam;
+	}
+
+	public void setExecutorShardingParam(String executorShardingParam) {
+		this.executorShardingParam = executorShardingParam;
+	}
+
+	public int getExecutorFailRetryCount() {
+		return executorFailRetryCount;
+	}
+
+	public void setExecutorFailRetryCount(int executorFailRetryCount) {
+		this.executorFailRetryCount = executorFailRetryCount;
+	}
+
+	public Date getTriggerTime() {
+		return triggerTime;
+	}
+
+	public void setTriggerTime(Date triggerTime) {
+		this.triggerTime = triggerTime;
+	}
+
+	public int getTriggerCode() {
+		return triggerCode;
+	}
+
+	public void setTriggerCode(int triggerCode) {
+		this.triggerCode = triggerCode;
+	}
+
+	public String getTriggerMsg() {
+		return triggerMsg;
+	}
+
+	public void setTriggerMsg(String triggerMsg) {
+		this.triggerMsg = triggerMsg;
+	}
+
+	public Date getHandleTime() {
+		return handleTime;
+	}
+
+	public void setHandleTime(Date handleTime) {
+		this.handleTime = handleTime;
+	}
+
+	public int getHandleCode() {
+		return handleCode;
+	}
+
+	public void setHandleCode(int handleCode) {
+		this.handleCode = handleCode;
+	}
+
+	public String getHandleMsg() {
+		return handleMsg;
+	}
+
+	public void setHandleMsg(String handleMsg) {
+		this.handleMsg = handleMsg;
+	}
+
+	public int getAlarmStatus() {
+		return alarmStatus;
+	}
+
+	public void setAlarmStatus(int alarmStatus) {
+		this.alarmStatus = alarmStatus;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobLogGlue.java

+package com.xxl.job.admin.core.model;
+
+import java.util.Date;
+
+/**
+ * xxl-job log for glue, used to track job code process
+ *
+ * @author xuxueli 2016-5-19 17:57:46
+ */
+public class XxlJobLogGlue {
+
+	private int id;
+	private int jobId;                // 任务主键ID
+	private String glueType;        // GLUE类型	#com.xxl.job.core.glue.GlueTypeEnum
+	private String glueSource;
+	private String glueRemark;
+	private Date addTime;
+	private Date updateTime;
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public int getJobId() {
+		return jobId;
+	}
+
+	public void setJobId(int jobId) {
+		this.jobId = jobId;
+	}
+
+	public String getGlueType() {
+		return glueType;
+	}
+
+	public void setGlueType(String glueType) {
+		this.glueType = glueType;
+	}
+
+	public String getGlueSource() {
+		return glueSource;
+	}
+
+	public void setGlueSource(String glueSource) {
+		this.glueSource = glueSource;
+	}
+
+	public String getGlueRemark() {
+		return glueRemark;
+	}
+
+	public void setGlueRemark(String glueRemark) {
+		this.glueRemark = glueRemark;
+	}
+
+	public Date getAddTime() {
+		return addTime;
+	}
+
+	public void setAddTime(Date addTime) {
+		this.addTime = addTime;
+	}
+
+	public Date getUpdateTime() {
+		return updateTime;
+	}
+
+	public void setUpdateTime(Date updateTime) {
+		this.updateTime = updateTime;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobLogReport.java

+package com.xxl.job.admin.core.model;
+
+import java.util.Date;
+
+public class XxlJobLogReport {
+
+	private int id;
+
+	private Date triggerDay;
+
+	private int runningCount;
+	private int sucCount;
+	private int failCount;
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public Date getTriggerDay() {
+		return triggerDay;
+	}
+
+	public void setTriggerDay(Date triggerDay) {
+		this.triggerDay = triggerDay;
+	}
+
+	public int getRunningCount() {
+		return runningCount;
+	}
+
+	public void setRunningCount(int runningCount) {
+		this.runningCount = runningCount;
+	}
+
+	public int getSucCount() {
+		return sucCount;
+	}
+
+	public void setSucCount(int sucCount) {
+		this.sucCount = sucCount;
+	}
+
+	public int getFailCount() {
+		return failCount;
+	}
+
+	public void setFailCount(int failCount) {
+		this.failCount = failCount;
+	}
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobRegistry.java

+package com.xxl.job.admin.core.model;
+
+import java.util.Date;
+
+/**
+ * Created by xuxueli on 16/9/30.
+ */
+public class XxlJobRegistry {
+
+	private int id;
+	private String registryGroup;
+	private String registryKey;
+	private String registryValue;
+	private Date updateTime;
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getRegistryGroup() {
+		return registryGroup;
+	}
+
+	public void setRegistryGroup(String registryGroup) {
+		this.registryGroup = registryGroup;
+	}
+
+	public String getRegistryKey() {
+		return registryKey;
+	}
+
+	public void setRegistryKey(String registryKey) {
+		this.registryKey = registryKey;
+	}
+
+	public String getRegistryValue() {
+		return registryValue;
+	}
+
+	public void setRegistryValue(String registryValue) {
+		this.registryValue = registryValue;
+	}
+
+	public Date getUpdateTime() {
+		return updateTime;
+	}
+
+	public void setUpdateTime(Date updateTime) {
+		this.updateTime = updateTime;
+	}
+}

src/main/java/com/xxl/job/admin/core/model/XxlJobUser.java

+package com.xxl.job.admin.core.model;
+
+import org.springframework.util.StringUtils;
+
+/**
+ * @author xuxueli 2019-05-04 16:43:12
+ */
+public class XxlJobUser {
+
+	private int id;
+	private String username;        // 账号
+	private String password;        // 密码
+	private int role;                // 角色：0-普通用户、1-管理员
+	private String permission;    // 权限：执行器ID列表，多个逗号分割
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getPassword() {
+		return password;
+	}
+
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
+	public int getRole() {
+		return role;
+	}
+
+	public void setRole(int role) {
+		this.role = role;
+	}
+
+	public String getPermission() {
+		return permission;
+	}
+
+	public void setPermission(String permission) {
+		this.permission = permission;
+	}
+
+	// plugin
+	public boolean validPermission(int jobGroup) {
+		if (this.role == 1) {
+			return true;
+		} else {
+			if (StringUtils.hasText(this.permission)) {
+				for (String permissionItem : this.permission.split(",")) {
+					if (String.valueOf(jobGroup).equals(permissionItem)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+	}
+
+}

src/main/java/com/xxl/job/admin/core/old/RemoteHttpJobBean.java

+//package com.xxl.job.admin.core.jobbean;
+//
+//import com.xxl.job.admin.core.thread.JobTriggerPoolHelper;
+//import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
+//import org.quartz.JobExecutionContext;
+//import org.quartz.JobExecutionException;
+//import org.quartz.JobKey;
+//import org.slf4j.Logger;
+//import org.slf4j.LoggerFactory;
+//import org.springframework.scheduling.quartz.QuartzJobBean;
+//
+///**
+// * http job bean
+// * “@DisallowConcurrentExecution” disable concurrent, thread size can not be only one, better given more
+// * @author xuxueli 2015-12-17 18:20:34
+// */
+////@DisallowConcurrentExecution
+//public class RemoteHttpJobBean extends QuartzJobBean {
+//	private static Logger logger = LoggerFactory.getLogger(RemoteHttpJobBean.class);
+//
+//	@Override
+//	protected void executeInternal(JobExecutionContext context)
+//			throws JobExecutionException {
+//
+//		// load jobId
+//		JobKey jobKey = context.getTrigger().getJobKey();
+//		Integer jobId = Integer.valueOf(jobKey.getName());
+//
+//
+//	}
+//
+//}
\ No newline at end of file

src/main/java/com/xxl/job/admin/core/old/XxlJobThreadPool.java

+//package com.xxl.job.admin.core.quartz;
+//
+//import org.quartz.SchedulerConfigException;
+//import org.quartz.spi.ThreadPool;
+//
+///**
+// * single thread pool, for async trigger
+// *
+// * @author xuxueli 2019-03-06
+// */
+//public class XxlJobThreadPool implements ThreadPool {
+//
+//    @Override
+//    public boolean runInThread(Runnable runnable) {
+//
+//        // async run
+//        runnable.run();
+//        return true;
+//
+//        //return false;
+//    }
+//
+//    @Override
+//    public int blockForAvailableThreads() {
+//        return 1;
+//    }
+//
+//    @Override
+//    public void initialize() throws SchedulerConfigException {
+//
+//    }
+//
+//    @Override
+//    public void shutdown(boolean waitForJobsToComplete) {
+//
+//    }
+//
+//    @Override
+//    public int getPoolSize() {
+//        return 1;
+//    }
+//
+//    @Override
+//    public void setInstanceId(String schedInstId) {
+//
+//    }
+//
+//    @Override
+//    public void setInstanceName(String schedName) {
+//
+//    }
+//
+//    // support
+//    public void setThreadCount(int count) {
+//        //
+//    }
+//
+//}

src/main/java/com/xxl/job/admin/core/route/ExecutorRouteStrategyEnum.java

+package com.xxl.job.admin.core.route;
+
+import com.xxl.job.admin.core.route.strategy.*;
+import com.xxl.job.admin.core.util.I18nUtil;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public enum ExecutorRouteStrategyEnum {
+
+	FIRST(I18nUtil.getString("jobconf_route_first"), new ExecutorRouteFirst()),
+	LAST(I18nUtil.getString("jobconf_route_last"), new ExecutorRouteLast()),
+	ROUND(I18nUtil.getString("jobconf_route_round"), new ExecutorRouteRound()),
+	RANDOM(I18nUtil.getString("jobconf_route_random"), new ExecutorRouteRandom()),
+	CONSISTENT_HASH(I18nUtil.getString("jobconf_route_consistenthash"), new ExecutorRouteConsistentHash()),
+	LEAST_FREQUENTLY_USED(I18nUtil.getString("jobconf_route_lfu"), new ExecutorRouteLFU()),
+	LEAST_RECENTLY_USED(I18nUtil.getString("jobconf_route_lru"), new ExecutorRouteLRU()),
+	FAILOVER(I18nUtil.getString("jobconf_route_failover"), new ExecutorRouteFailover()),
+	BUSYOVER(I18nUtil.getString("jobconf_route_busyover"), new ExecutorRouteBusyover()),
+	SHARDING_BROADCAST(I18nUtil.getString("jobconf_route_shard"), null);
+
+	ExecutorRouteStrategyEnum(String title, ExecutorRouter router) {
+		this.title = title;
+		this.router = router;
+	}
+
+	private String title;
+	private ExecutorRouter router;
+
+	public String getTitle() {
+		return title;
+	}
+
+	public ExecutorRouter getRouter() {
+		return router;
+	}
+
+	public static ExecutorRouteStrategyEnum match(String name, ExecutorRouteStrategyEnum defaultItem) {
+		if (name != null) {
+			for (ExecutorRouteStrategyEnum item : ExecutorRouteStrategyEnum.values()) {
+				if (item.name().equals(name)) {
+					return item;
+				}
+			}
+		}
+		return defaultItem;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/ExecutorRouter.java

+package com.xxl.job.admin.core.route;
+
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public abstract class ExecutorRouter {
+	protected static Logger logger = LoggerFactory.getLogger(ExecutorRouter.class);
+
+	/**
+	 * route address
+	 *
+	 * @param addressList
+	 * @return ReturnT.content=address
+	 */
+	public abstract ReturnT<String> route(TriggerParam triggerParam, List<String> addressList);
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteBusyover.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.scheduler.XxlJobScheduler;
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.core.biz.ExecutorBiz;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteBusyover extends ExecutorRouter {
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		StringBuffer idleBeatResultSB = new StringBuffer();
+		for (String address : addressList) {
+			// beat
+			ReturnT<String> idleBeatResult = null;
+			try {
+				ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);
+				idleBeatResult = executorBiz.idleBeat(triggerParam.getJobId());
+			} catch (Exception e) {
+				logger.error(e.getMessage(), e);
+				idleBeatResult = new ReturnT<String>(ReturnT.FAIL_CODE, "" + e);
+			}
+			idleBeatResultSB.append((idleBeatResultSB.length() > 0) ? "<br><br>" : "")
+					.append(I18nUtil.getString("jobconf_idleBeat") + "：")
+					.append("<br>address：").append(address)
+					.append("<br>code：").append(idleBeatResult.getCode())
+					.append("<br>msg：").append(idleBeatResult.getMsg());
+
+			// beat success
+			if (idleBeatResult.getCode() == ReturnT.SUCCESS_CODE) {
+				idleBeatResult.setMsg(idleBeatResultSB.toString());
+				idleBeatResult.setContent(address);
+				return idleBeatResult;
+			}
+		}
+
+		return new ReturnT<String>(ReturnT.FAIL_CODE, idleBeatResultSB.toString());
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteConsistentHash.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * 分组下机器地址相同，不同JOB均匀散列在不同机器上，保证分组下机器分配JOB平均；且每个JOB固定调度其中一台机器；
+ * a、virtual node：解决不均衡问题
+ * b、hash method replace hashCode：String的hashCode可能重复，需要进一步扩大hashCode的取值范围
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteConsistentHash extends ExecutorRouter {
+
+	private static int VIRTUAL_NODE_NUM = 5;
+
+	/**
+	 * get hash code on 2^32 ring (md5散列的方式计算hash值)
+	 *
+	 * @param key
+	 * @return
+	 */
+	private static long hash(String key) {
+
+		// md5 byte
+		MessageDigest md5;
+		try {
+			md5 = MessageDigest.getInstance("MD5");
+		} catch (NoSuchAlgorithmException e) {
+			throw new RuntimeException("MD5 not supported", e);
+		}
+		md5.reset();
+		byte[] keyBytes = null;
+		try {
+			keyBytes = key.getBytes("UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			throw new RuntimeException("Unknown string :" + key, e);
+		}
+
+		md5.update(keyBytes);
+		byte[] digest = md5.digest();
+
+		// hash code, Truncate to 32-bits
+		long hashCode = ((long) (digest[3] & 0xFF) << 24)
+				| ((long) (digest[2] & 0xFF) << 16)
+				| ((long) (digest[1] & 0xFF) << 8)
+				| (digest[0] & 0xFF);
+
+		long truncateHashCode = hashCode & 0xffffffffL;
+		return truncateHashCode;
+	}
+
+	public String hashJob(int jobId, List<String> addressList) {
+
+		// ------A1------A2-------A3------
+		// -----------J1------------------
+		TreeMap<Long, String> addressRing = new TreeMap<Long, String>();
+		for (String address : addressList) {
+			for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
+				long addressHash = hash("SHARD-" + address + "-NODE-" + i);
+				addressRing.put(addressHash, address);
+			}
+		}
+
+		long jobHash = hash(String.valueOf(jobId));
+		SortedMap<Long, String> lastRing = addressRing.tailMap(jobHash);
+		if (!lastRing.isEmpty()) {
+			return lastRing.get(lastRing.firstKey());
+		}
+		return addressRing.firstEntry().getValue();
+	}
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		String address = hashJob(triggerParam.getJobId(), addressList);
+		return new ReturnT<String>(address);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteFailover.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.scheduler.XxlJobScheduler;
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.core.biz.ExecutorBiz;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteFailover extends ExecutorRouter {
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+
+		StringBuffer beatResultSB = new StringBuffer();
+		for (String address : addressList) {
+			// beat
+			ReturnT<String> beatResult = null;
+			try {
+				ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);
+				beatResult = executorBiz.beat();
+			} catch (Exception e) {
+				logger.error(e.getMessage(), e);
+				beatResult = new ReturnT<String>(ReturnT.FAIL_CODE, "" + e);
+			}
+			beatResultSB.append((beatResultSB.length() > 0) ? "<br><br>" : "")
+					.append(I18nUtil.getString("jobconf_beat") + "：")
+					.append("<br>address：").append(address)
+					.append("<br>code：").append(beatResult.getCode())
+					.append("<br>msg：").append(beatResult.getMsg());
+
+			// beat success
+			if (beatResult.getCode() == ReturnT.SUCCESS_CODE) {
+
+				beatResult.setMsg(beatResultSB.toString());
+				beatResult.setContent(address);
+				return beatResult;
+			}
+		}
+		return new ReturnT<String>(ReturnT.FAIL_CODE, beatResultSB.toString());
+
+	}
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteFirst.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteFirst extends ExecutorRouter {
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		return new ReturnT<String>(addressList.get(0));
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLFU.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * 单个JOB对应的每个执行器，使用频率最低的优先被选举
+ * a(*)、LFU(Least Frequently Used)：最不经常使用，频率/次数
+ * b、LRU(Least Recently Used)：最近最久未使用，时间
+ * <p>
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteLFU extends ExecutorRouter {
+
+	private static ConcurrentMap<Integer, HashMap<String, Integer>> jobLfuMap = new ConcurrentHashMap<Integer, HashMap<String, Integer>>();
+	private static long CACHE_VALID_TIME = 0;
+
+	public String route(int jobId, List<String> addressList) {
+
+		// cache clear
+		if (System.currentTimeMillis() > CACHE_VALID_TIME) {
+			jobLfuMap.clear();
+			CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
+		}
+
+		// lfu item init
+		HashMap<String, Integer> lfuItemMap = jobLfuMap.get(jobId);     // Key排序可以用TreeMap+构造入参Compare；Value排序暂时只能通过ArrayList；
+		if (lfuItemMap == null) {
+			lfuItemMap = new HashMap<String, Integer>();
+			jobLfuMap.putIfAbsent(jobId, lfuItemMap);   // 避免重复覆盖
+		}
+
+		// put new
+		for (String address : addressList) {
+			if (!lfuItemMap.containsKey(address) || lfuItemMap.get(address) > 1000000) {
+				lfuItemMap.put(address, new Random().nextInt(addressList.size()));  // 初始化时主动Random一次，缓解首次压力
+			}
+		}
+		// remove old
+		List<String> delKeys = new ArrayList<>();
+		for (String existKey : lfuItemMap.keySet()) {
+			if (!addressList.contains(existKey)) {
+				delKeys.add(existKey);
+			}
+		}
+		if (delKeys.size() > 0) {
+			for (String delKey : delKeys) {
+				lfuItemMap.remove(delKey);
+			}
+		}
+
+		// load least userd count address
+		List<Map.Entry<String, Integer>> lfuItemList = new ArrayList<Map.Entry<String, Integer>>(lfuItemMap.entrySet());
+		Collections.sort(lfuItemList, new Comparator<Map.Entry<String, Integer>>() {
+			@Override
+			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
+				return o1.getValue().compareTo(o2.getValue());
+			}
+		});
+
+		Map.Entry<String, Integer> addressItem = lfuItemList.get(0);
+		String minAddress = addressItem.getKey();
+		addressItem.setValue(addressItem.getValue() + 1);
+
+		return addressItem.getKey();
+	}
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		String address = route(triggerParam.getJobId(), addressList);
+		return new ReturnT<String>(address);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLRU.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * 单个JOB对应的每个执行器，最久为使用的优先被选举
+ * a、LFU(Least Frequently Used)：最不经常使用，频率/次数
+ * b(*)、LRU(Least Recently Used)：最近最久未使用，时间
+ * <p>
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteLRU extends ExecutorRouter {
+
+	private static ConcurrentMap<Integer, LinkedHashMap<String, String>> jobLRUMap = new ConcurrentHashMap<Integer, LinkedHashMap<String, String>>();
+	private static long CACHE_VALID_TIME = 0;
+
+	public String route(int jobId, List<String> addressList) {
+
+		// cache clear
+		if (System.currentTimeMillis() > CACHE_VALID_TIME) {
+			jobLRUMap.clear();
+			CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
+		}
+
+		// init lru
+		LinkedHashMap<String, String> lruItem = jobLRUMap.get(jobId);
+		if (lruItem == null) {
+			/**
+			 * LinkedHashMap
+			 *      a、accessOrder：true=访问顺序排序（get/put时排序）；false=插入顺序排期；
+			 *      b、removeEldestEntry：新增元素时将会调用，返回true时会删除最老元素；可封装LinkedHashMap并重写该方法，比如定义最大容量，超出是返回true即可实现固定长度的LRU算法；
+			 */
+			lruItem = new LinkedHashMap<String, String>(16, 0.75f, true);
+			jobLRUMap.putIfAbsent(jobId, lruItem);
+		}
+
+		// put new
+		for (String address : addressList) {
+			if (!lruItem.containsKey(address)) {
+				lruItem.put(address, address);
+			}
+		}
+		// remove old
+		List<String> delKeys = new ArrayList<>();
+		for (String existKey : lruItem.keySet()) {
+			if (!addressList.contains(existKey)) {
+				delKeys.add(existKey);
+			}
+		}
+		if (delKeys.size() > 0) {
+			for (String delKey : delKeys) {
+				lruItem.remove(delKey);
+			}
+		}
+
+		// load
+		String eldestKey = lruItem.entrySet().iterator().next().getKey();
+		String eldestValue = lruItem.get(eldestKey);
+		return eldestValue;
+	}
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		String address = route(triggerParam.getJobId(), addressList);
+		return new ReturnT<String>(address);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteLast.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteLast extends ExecutorRouter {
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		return new ReturnT<String>(addressList.get(addressList.size() - 1));
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteRandom.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+import java.util.Random;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteRandom extends ExecutorRouter {
+
+	private static Random localRandom = new Random();
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		String address = addressList.get(localRandom.nextInt(addressList.size()));
+		return new ReturnT<String>(address);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/route/strategy/ExecutorRouteRound.java

+package com.xxl.job.admin.core.route.strategy;
+
+import com.xxl.job.admin.core.route.ExecutorRouter;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * Created by xuxueli on 17/3/10.
+ */
+public class ExecutorRouteRound extends ExecutorRouter {
+
+	private static ConcurrentMap<Integer, Integer> routeCountEachJob = new ConcurrentHashMap<Integer, Integer>();
+	private static long CACHE_VALID_TIME = 0;
+
+	private static int count(int jobId) {
+		// cache clear
+		if (System.currentTimeMillis() > CACHE_VALID_TIME) {
+			routeCountEachJob.clear();
+			CACHE_VALID_TIME = System.currentTimeMillis() + 1000 * 60 * 60 * 24;
+		}
+
+		// count++
+		Integer count = routeCountEachJob.get(jobId);
+		count = (count == null || count > 1000000) ? (new Random().nextInt(100)) : ++count;  // 初始化时主动Random一次，缓解首次压力
+		routeCountEachJob.put(jobId, count);
+		return count;
+	}
+
+	@Override
+	public ReturnT<String> route(TriggerParam triggerParam, List<String> addressList) {
+		String address = addressList.get(count(triggerParam.getJobId()) % addressList.size());
+		return new ReturnT<String>(address);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/scheduler/XxlJobScheduler.java

+package com.xxl.job.admin.core.scheduler;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.thread.*;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.core.biz.ExecutorBiz;
+import com.xxl.job.core.enums.ExecutorBlockStrategyEnum;
+import com.xxl.rpc.remoting.invoker.call.CallType;
+import com.xxl.rpc.remoting.invoker.reference.XxlRpcReferenceBean;
+import com.xxl.rpc.remoting.invoker.route.LoadBalance;
+import com.xxl.rpc.remoting.net.impl.netty_http.client.NettyHttpClient;
+import com.xxl.rpc.serialize.impl.HessianSerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * @author xuxueli 2018-10-28 00:18:17
+ */
+
+public class XxlJobScheduler {
+	private static final Logger logger = LoggerFactory.getLogger(XxlJobScheduler.class);
+
+
+	public void init() throws Exception {
+		// init i18n
+		initI18n();
+
+		// admin registry monitor run
+		JobRegistryMonitorHelper.getInstance().start();
+
+		// admin monitor run
+		JobFailMonitorHelper.getInstance().start();
+
+		// admin trigger pool start
+		JobTriggerPoolHelper.toStart();
+
+		// admin log report start
+		JobLogReportHelper.getInstance().start();
+
+		// start-schedule
+		JobScheduleHelper.getInstance().start();
+
+		logger.info(">>>>>>>>> init xxl-job admin success.");
+	}
+
+
+	public void destroy() throws Exception {
+
+		// stop-schedule
+		JobScheduleHelper.getInstance().toStop();
+
+		// admin log report stop
+		JobLogReportHelper.getInstance().toStop();
+
+		// admin trigger pool stop
+		JobTriggerPoolHelper.toStop();
+
+		// admin monitor stop
+		JobFailMonitorHelper.getInstance().toStop();
+
+		// admin registry stop
+		JobRegistryMonitorHelper.getInstance().toStop();
+
+	}
+
+	// ---------------------- I18n ----------------------
+
+	private void initI18n() {
+		for (ExecutorBlockStrategyEnum item : ExecutorBlockStrategyEnum.values()) {
+			item.setTitle(I18nUtil.getString("jobconf_block_".concat(item.name())));
+		}
+	}
+
+	// ---------------------- executor-client ----------------------
+	private static ConcurrentMap<String, ExecutorBiz> executorBizRepository = new ConcurrentHashMap<String, ExecutorBiz>();
+
+	public static ExecutorBiz getExecutorBiz(String address) throws Exception {
+		// valid
+		if (address == null || address.trim().length() == 0) {
+			return null;
+		}
+
+		// load-cache
+		address = address.trim();
+		ExecutorBiz executorBiz = executorBizRepository.get(address);
+		if (executorBiz != null) {
+			return executorBiz;
+		}
+
+		// set-cache
+		XxlRpcReferenceBean referenceBean = new XxlRpcReferenceBean();
+		referenceBean.setClient(NettyHttpClient.class);
+		referenceBean.setSerializer(HessianSerializer.class);
+		referenceBean.setCallType(CallType.SYNC);
+		referenceBean.setLoadBalance(LoadBalance.ROUND);
+		referenceBean.setIface(ExecutorBiz.class);
+		referenceBean.setVersion(null);
+		referenceBean.setTimeout(3000);
+		referenceBean.setAddress(address);
+		referenceBean.setAccessToken(XxlJobAdminConfig.getAdminConfig().getAccessToken());
+		referenceBean.setInvokeCallback(null);
+		referenceBean.setInvokerFactory(null);
+
+		executorBiz = (ExecutorBiz) referenceBean.getObject();
+
+		executorBizRepository.put(address, executorBiz);
+		return executorBiz;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/thread/JobFailMonitorHelper.java

+package com.xxl.job.admin.core.thread;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobLog;
+import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.core.biz.model.ReturnT;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.mail.javamail.MimeMessageHelper;
+
+import javax.mail.internet.MimeMessage;
+import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * job monitor instance
+ *
+ * @author xuxueli 2015-9-1 18:05:56
+ */
+public class JobFailMonitorHelper {
+	private static Logger logger = LoggerFactory.getLogger(JobFailMonitorHelper.class);
+
+	private static JobFailMonitorHelper instance = new JobFailMonitorHelper();
+
+	public static JobFailMonitorHelper getInstance() {
+		return instance;
+	}
+
+	// ---------------------- monitor ----------------------
+
+	private Thread monitorThread;
+	private volatile boolean toStop = false;
+
+	public void start() {
+		monitorThread = new Thread(new Runnable() {
+
+			@Override
+			public void run() {
+
+				// monitor
+				while (!toStop) {
+					try {
+
+						List<Long> failLogIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findFailJobLogIds(1000);
+						if (failLogIds != null && !failLogIds.isEmpty()) {
+							for (long failLogId : failLogIds) {
+
+								// lock log
+								int lockRet = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, 0, -1);
+								if (lockRet < 1) {
+									continue;
+								}
+								XxlJobLog log = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().load(failLogId);
+								XxlJobInfo info = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(log.getJobId());
+
+								// 1、fail retry monitor
+								if (log.getExecutorFailRetryCount() > 0) {
+									JobTriggerPoolHelper.trigger(log.getJobId(), TriggerTypeEnum.RETRY, (log.getExecutorFailRetryCount() - 1), log.getExecutorShardingParam(), log.getExecutorParam());
+									String retryMsg = "<br><br><span style=\"color:#F39C12;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_type_retry") + "<<<<<<<<<<< </span><br>";
+									log.setTriggerMsg(log.getTriggerMsg() + retryMsg);
+									XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(log);
+								}
+
+								// 2、fail alarm monitor
+								int newAlarmStatus = 0;        // 告警状态：0-默认、-1=锁定状态、1-无需告警、2-告警成功、3-告警失败
+								if (info != null && info.getAlarmEmail() != null && info.getAlarmEmail().trim().length() > 0) {
+									boolean alarmResult = true;
+									try {
+										alarmResult = failAlarm(info, log);
+									} catch (Exception e) {
+										alarmResult = false;
+										logger.error(e.getMessage(), e);
+									}
+									newAlarmStatus = alarmResult ? 2 : 3;
+								} else {
+									newAlarmStatus = 1;
+								}
+
+								XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateAlarmStatus(failLogId, -1, newAlarmStatus);
+							}
+						}
+
+					} catch (Exception e) {
+						if (!toStop) {
+							logger.error(">>>>>>>>>>> xxl-job, job fail monitor thread error:{}", e);
+						}
+					}
+
+					try {
+						TimeUnit.SECONDS.sleep(10);
+					} catch (Exception e) {
+						if (!toStop) {
+							logger.error(e.getMessage(), e);
+						}
+					}
+
+				}
+
+				logger.info(">>>>>>>>>>> xxl-job, job fail monitor thread stop");
+
+			}
+		});
+		monitorThread.setDaemon(true);
+		monitorThread.setName("xxl-job, admin JobFailMonitorHelper");
+		monitorThread.start();
+	}
+
+	public void toStop() {
+		toStop = true;
+		// interrupt and wait
+		monitorThread.interrupt();
+		try {
+			monitorThread.join();
+		} catch (InterruptedException e) {
+			logger.error(e.getMessage(), e);
+		}
+	}
+
+
+	// ---------------------- alarm ----------------------
+
+	// email alarm template
+	private static final String mailBodyTemplate = "<h5>" + I18nUtil.getString("jobconf_monitor_detail") + "：</span>" +
+			"<table border=\"1\" cellpadding=\"3\" style=\"border-collapse:collapse; width:80%;\" >\n" +
+			"   <thead style=\"font-weight: bold;color: #ffffff;background-color: #ff8c00;\" >" +
+			"      <tr>\n" +
+			"         <td width=\"20%\" >" + I18nUtil.getString("jobinfo_field_jobgroup") + "</td>\n" +
+			"         <td width=\"10%\" >" + I18nUtil.getString("jobinfo_field_id") + "</td>\n" +
+			"         <td width=\"20%\" >" + I18nUtil.getString("jobinfo_field_jobdesc") + "</td>\n" +
+			"         <td width=\"10%\" >" + I18nUtil.getString("jobconf_monitor_alarm_title") + "</td>\n" +
+			"         <td width=\"40%\" >" + I18nUtil.getString("jobconf_monitor_alarm_content") + "</td>\n" +
+			"      </tr>\n" +
+			"   </thead>\n" +
+			"   <tbody>\n" +
+			"      <tr>\n" +
+			"         <td>{0}</td>\n" +
+			"         <td>{1}</td>\n" +
+			"         <td>{2}</td>\n" +
+			"         <td>" + I18nUtil.getString("jobconf_monitor_alarm_type") + "</td>\n" +
+			"         <td>{3}</td>\n" +
+			"      </tr>\n" +
+			"   </tbody>\n" +
+			"</table>";
+
+	/**
+	 * fail alarm
+	 *
+	 * @param jobLog
+	 */
+	private boolean failAlarm(XxlJobInfo info, XxlJobLog jobLog) {
+		boolean alarmResult = true;
+
+		// send monitor email
+		if (info != null && info.getAlarmEmail() != null && info.getAlarmEmail().trim().length() > 0) {
+
+			// alarmContent
+			String alarmContent = "Alarm Job LogId=" + jobLog.getId();
+			if (jobLog.getTriggerCode() != ReturnT.SUCCESS_CODE) {
+				alarmContent += "<br>TriggerMsg=<br>" + jobLog.getTriggerMsg();
+			}
+			if (jobLog.getHandleCode() > 0 && jobLog.getHandleCode() != ReturnT.SUCCESS_CODE) {
+				alarmContent += "<br>HandleCode=" + jobLog.getHandleMsg();
+			}
+
+			// email info
+			XxlJobGroup group = XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().load(Integer.valueOf(info.getJobGroup()));
+			String personal = I18nUtil.getString("admin_name_full");
+			String title = I18nUtil.getString("jobconf_monitor");
+			String content = MessageFormat.format(mailBodyTemplate,
+					group != null ? group.getTitle() : "null",
+					info.getId(),
+					info.getJobDesc(),
+					alarmContent);
+
+			Set<String> emailSet = new HashSet<String>(Arrays.asList(info.getAlarmEmail().split(",")));
+			for (String email : emailSet) {
+
+				// make mail
+				try {
+					MimeMessage mimeMessage = XxlJobAdminConfig.getAdminConfig().getMailSender().createMimeMessage();
+
+					MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
+					helper.setFrom(XxlJobAdminConfig.getAdminConfig().getEmailUserName(), personal);
+					helper.setTo(email);
+					helper.setSubject(title);
+					helper.setText(content, true);
+
+					XxlJobAdminConfig.getAdminConfig().getMailSender().send(mimeMessage);
+				} catch (Exception e) {
+					logger.error(">>>>>>>>>>> xxl-job, job fail alarm email send error, JobLogId:{}", jobLog.getId(), e);
+
+					alarmResult = false;
+				}
+
+			}
+		}
+
+		// do something, custom alarm strategy, such as sms
+
+
+		return alarmResult;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/thread/JobLogReportHelper.java

+package com.xxl.job.admin.core.thread;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.model.XxlJobLogReport;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * job log report helper
+ *
+ * @author xuxueli 2019-11-22
+ */
+public class JobLogReportHelper {
+	private static Logger logger = LoggerFactory.getLogger(JobLogReportHelper.class);
+
+	private static JobLogReportHelper instance = new JobLogReportHelper();
+
+	public static JobLogReportHelper getInstance() {
+		return instance;
+	}
+
+
+	private Thread logrThread;
+	private volatile boolean toStop = false;
+
+	public void start() {
+		logrThread = new Thread(new Runnable() {
+
+			@Override
+			public void run() {
+
+				// last clean log time
+				long lastCleanLogTime = 0;
+
+
+				while (!toStop) {
+
+					// 1、log-report refresh: refresh log report in 3 days
+					try {
+
+						for (int i = 0; i < 3; i++) {
+
+							// today
+							Calendar itemDay = Calendar.getInstance();
+							itemDay.add(Calendar.DAY_OF_MONTH, -i);
+							itemDay.set(Calendar.HOUR_OF_DAY, 0);
+							itemDay.set(Calendar.MINUTE, 0);
+							itemDay.set(Calendar.SECOND, 0);
+							itemDay.set(Calendar.MILLISECOND, 0);
+
+							Date todayFrom = itemDay.getTime();
+
+							itemDay.set(Calendar.HOUR_OF_DAY, 23);
+							itemDay.set(Calendar.MINUTE, 59);
+							itemDay.set(Calendar.SECOND, 59);
+							itemDay.set(Calendar.MILLISECOND, 999);
+
+							Date todayTo = itemDay.getTime();
+
+							// refresh log-report every minute
+							XxlJobLogReport xxlJobLogReport = new XxlJobLogReport();
+							xxlJobLogReport.setTriggerDay(todayFrom);
+							xxlJobLogReport.setRunningCount(0);
+							xxlJobLogReport.setSucCount(0);
+							xxlJobLogReport.setFailCount(0);
+
+							Map<String, Object> triggerCountMap = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findLogReport(todayFrom, todayTo);
+							if (triggerCountMap != null && triggerCountMap.size() > 0) {
+								int triggerDayCount = triggerCountMap.containsKey("triggerDayCount") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCount"))) : 0;
+								int triggerDayCountRunning = triggerCountMap.containsKey("triggerDayCountRunning") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountRunning"))) : 0;
+								int triggerDayCountSuc = triggerCountMap.containsKey("triggerDayCountSuc") ? Integer.valueOf(String.valueOf(triggerCountMap.get("triggerDayCountSuc"))) : 0;
+								int triggerDayCountFail = triggerDayCount - triggerDayCountRunning - triggerDayCountSuc;
+
+								xxlJobLogReport.setRunningCount(triggerDayCountRunning);
+								xxlJobLogReport.setSucCount(triggerDayCountSuc);
+								xxlJobLogReport.setFailCount(triggerDayCountFail);
+							}
+
+							// do refresh
+							int ret = XxlJobAdminConfig.getAdminConfig().getXxlJobLogReportDao().update(xxlJobLogReport);
+							if (ret < 1) {
+								XxlJobAdminConfig.getAdminConfig().getXxlJobLogReportDao().save(xxlJobLogReport);
+							}
+						}
+
+					} catch (Exception e) {
+						if (!toStop) {
+							logger.error(">>>>>>>>>>> xxl-job, job log report thread error:{}", e);
+						}
+					}
+
+					// 2、log-clean: switch open & once each day
+					if (XxlJobAdminConfig.getAdminConfig().getLogretentiondays() > 0
+							&& System.currentTimeMillis() - lastCleanLogTime > 24 * 60 * 60 * 1000) {
+
+						// expire-time
+						Calendar expiredDay = Calendar.getInstance();
+						expiredDay.add(Calendar.DAY_OF_MONTH, -1 * XxlJobAdminConfig.getAdminConfig().getLogretentiondays());
+						expiredDay.set(Calendar.HOUR_OF_DAY, 0);
+						expiredDay.set(Calendar.MINUTE, 0);
+						expiredDay.set(Calendar.SECOND, 0);
+						expiredDay.set(Calendar.MILLISECOND, 0);
+						Date clearBeforeTime = expiredDay.getTime();
+
+						// clean expired log
+						List<Long> logIds = null;
+						do {
+							logIds = XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().findClearLogIds(0, 0, clearBeforeTime, 0, 1000);
+							if (logIds != null && logIds.size() > 0) {
+								XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().clearLog(logIds);
+							}
+						} while (logIds != null && logIds.size() > 0);
+
+						// update clean time
+						lastCleanLogTime = System.currentTimeMillis();
+					}
+
+					try {
+						TimeUnit.MINUTES.sleep(1);
+					} catch (Exception e) {
+						if (!toStop) {
+							logger.error(e.getMessage(), e);
+						}
+					}
+
+				}
+
+				logger.info(">>>>>>>>>>> xxl-job, job log report thread stop");
+
+			}
+		});
+		logrThread.setDaemon(true);
+		logrThread.setName("xxl-job, admin JobLogReportHelper");
+		logrThread.start();
+	}
+
+	public void toStop() {
+		toStop = true;
+		// interrupt and wait
+		logrThread.interrupt();
+		try {
+			logrThread.join();
+		} catch (InterruptedException e) {
+			logger.error(e.getMessage(), e);
+		}
+	}
+
+}

src/main/java/com/xxl/job/admin/core/thread/JobRegistryMonitorHelper.java

+package com.xxl.job.admin.core.thread;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobRegistry;
+import com.xxl.job.core.enums.RegistryConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * job registry instance
+ *
+ * @author xuxueli 2016-10-02 19:10:24
+ */
+public class JobRegistryMonitorHelper {
+	private static Logger logger = LoggerFactory.getLogger(JobRegistryMonitorHelper.class);
+
+	private static JobRegistryMonitorHelper instance = new JobRegistryMonitorHelper();
+
+	public static JobRegistryMonitorHelper getInstance() {
+		return instance;
+	}
+
+	private Thread registryThread;
+	private volatile boolean toStop = false;
+
+	public void start() {
+		registryThread = new Thread(new Runnable() {
+			@Override
+			public void run() {
+				while (!toStop) {
+					try {
+						// auto registry group
+						List<XxlJobGroup> groupList = XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().findByAddressType(0);
+						if (groupList != null && !groupList.isEmpty()) {
+
+							// remove dead address (admin/executor)
+							List<Integer> ids = XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().findDead(RegistryConfig.DEAD_TIMEOUT, new Date());
+							if (ids != null && ids.size() > 0) {
+								XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().removeDead(ids);
+							}
+
+							// fresh online address (admin/executor)
+							HashMap<String, List<String>> appAddressMap = new HashMap<String, List<String>>();
+							List<XxlJobRegistry> list = XxlJobAdminConfig.getAdminConfig().getXxlJobRegistryDao().findAll(RegistryConfig.DEAD_TIMEOUT, new Date());
+							if (list != null) {
+								for (XxlJobRegistry item : list) {
+									if (RegistryConfig.RegistType.EXECUTOR.name().equals(item.getRegistryGroup())) {
+										String appName = item.getRegistryKey();
+										List<String> registryList = appAddressMap.get(appName);
+										if (registryList == null) {
+											registryList = new ArrayList<String>();
+										}
+
+										if (!registryList.contains(item.getRegistryValue())) {
+											registryList.add(item.getRegistryValue());
+										}
+										appAddressMap.put(appName, registryList);
+									}
+								}
+							}
+
+							// fresh group address
+							for (XxlJobGroup group : groupList) {
+								List<String> registryList = appAddressMap.get(group.getAppName());
+								String addressListStr = null;
+								if (registryList != null && !registryList.isEmpty()) {
+									Collections.sort(registryList);
+									addressListStr = "";
+									for (String item : registryList) {
+										addressListStr += item + ",";
+									}
+									addressListStr = addressListStr.substring(0, addressListStr.length() - 1);
+								}
+								group.setAddressList(addressListStr);
+								XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().update(group);
+							}
+						}
+					} catch (Exception e) {
+						if (!toStop) {
+							logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}", e);
+						}
+					}
+					try {
+						TimeUnit.SECONDS.sleep(RegistryConfig.BEAT_TIMEOUT);
+					} catch (InterruptedException e) {
+						if (!toStop) {
+							logger.error(">>>>>>>>>>> xxl-job, job registry monitor thread error:{}", e);
+						}
+					}
+				}
+				logger.info(">>>>>>>>>>> xxl-job, job registry monitor thread stop");
+			}
+		});
+		registryThread.setDaemon(true);
+		registryThread.setName("xxl-job, admin JobRegistryMonitorHelper");
+		registryThread.start();
+	}
+
+	public void toStop() {
+		toStop = true;
+		// interrupt and wait
+		registryThread.interrupt();
+		try {
+			registryThread.join();
+		} catch (InterruptedException e) {
+			logger.error(e.getMessage(), e);
+		}
+	}
+
+}

src/main/java/com/xxl/job/admin/core/thread/JobTriggerPoolHelper.java

+package com.xxl.job.admin.core.thread;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
+import com.xxl.job.admin.core.trigger.XxlJobTrigger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * job trigger thread pool helper
+ *
+ * @author xuxueli 2018-07-03 21:08:07
+ */
+public class JobTriggerPoolHelper {
+	private static Logger logger = LoggerFactory.getLogger(JobTriggerPoolHelper.class);
+
+
+	// ---------------------- trigger pool ----------------------
+
+	// fast/slow thread pool
+	private ThreadPoolExecutor fastTriggerPool = null;
+	private ThreadPoolExecutor slowTriggerPool = null;
+
+	public void start() {
+		fastTriggerPool = new ThreadPoolExecutor(
+				10,
+				XxlJobAdminConfig.getAdminConfig().getTriggerPoolFastMax(),
+				60L,
+				TimeUnit.SECONDS,
+				new LinkedBlockingQueue<Runnable>(1000),
+				new ThreadFactory() {
+					@Override
+					public Thread newThread(Runnable r) {
+						return new Thread(r, "xxl-job, admin JobTriggerPoolHelper-fastTriggerPool-" + r.hashCode());
+					}
+				});
+
+		slowTriggerPool = new ThreadPoolExecutor(
+				10,
+				XxlJobAdminConfig.getAdminConfig().getTriggerPoolSlowMax(),
+				60L,
+				TimeUnit.SECONDS,
+				new LinkedBlockingQueue<Runnable>(2000),
+				new ThreadFactory() {
+					@Override
+					public Thread newThread(Runnable r) {
+						return new Thread(r, "xxl-job, admin JobTriggerPoolHelper-slowTriggerPool-" + r.hashCode());
+					}
+				});
+	}
+
+
+	public void stop() {
+		//triggerPool.shutdown();
+		fastTriggerPool.shutdownNow();
+		slowTriggerPool.shutdownNow();
+		logger.info(">>>>>>>>> xxl-job trigger thread pool shutdown success.");
+	}
+
+
+	// job timeout count
+	private volatile long minTim = System.currentTimeMillis() / 60000;     // ms > min
+	private volatile ConcurrentMap<Integer, AtomicInteger> jobTimeoutCountMap = new ConcurrentHashMap<>();
+
+
+	/**
+	 * add trigger
+	 */
+	public void addTrigger(final int jobId, final TriggerTypeEnum triggerType, final int failRetryCount, final String executorShardingParam, final String executorParam) {
+
+		// choose thread pool
+		ThreadPoolExecutor triggerPool_ = fastTriggerPool;
+		AtomicInteger jobTimeoutCount = jobTimeoutCountMap.get(jobId);
+		if (jobTimeoutCount != null && jobTimeoutCount.get() > 10) {      // job-timeout 10 times in 1 min
+			triggerPool_ = slowTriggerPool;
+		}
+
+		// trigger
+		triggerPool_.execute(new Runnable() {
+			@Override
+			public void run() {
+
+				long start = System.currentTimeMillis();
+
+				try {
+					// do trigger
+					XxlJobTrigger.trigger(jobId, triggerType, failRetryCount, executorShardingParam, executorParam);
+				} catch (Exception e) {
+					logger.error(e.getMessage(), e);
+				} finally {
+
+					// check timeout-count-map
+					long minTim_now = System.currentTimeMillis() / 60000;
+					if (minTim != minTim_now) {
+						minTim = minTim_now;
+						jobTimeoutCountMap.clear();
+					}
+
+					// incr timeout-count-map
+					long cost = System.currentTimeMillis() - start;
+					if (cost > 500) {       // ob-timeout threshold 500ms
+						AtomicInteger timeoutCount = jobTimeoutCountMap.putIfAbsent(jobId, new AtomicInteger(1));
+						if (timeoutCount != null) {
+							timeoutCount.incrementAndGet();
+						}
+					}
+
+				}
+
+			}
+		});
+	}
+
+
+	// ---------------------- helper ----------------------
+
+	private static JobTriggerPoolHelper helper = new JobTriggerPoolHelper();
+
+	public static void toStart() {
+		helper.start();
+	}
+
+	public static void toStop() {
+		helper.stop();
+	}
+
+	/**
+	 * @param jobId
+	 * @param triggerType
+	 * @param failRetryCount        >=0: use this param
+	 *                              <0: use param from job info config
+	 * @param executorShardingParam
+	 * @param executorParam         null: use job param
+	 *                              not null: cover job param
+	 */
+	public static void trigger(int jobId, TriggerTypeEnum triggerType, int failRetryCount, String executorShardingParam, String executorParam) {
+		helper.addTrigger(jobId, triggerType, failRetryCount, executorShardingParam, executorParam);
+	}
+
+}

src/main/java/com/xxl/job/admin/core/trigger/TriggerTypeEnum.java

+package com.xxl.job.admin.core.trigger;
+
+import com.xxl.job.admin.core.util.I18nUtil;
+
+/**
+ * trigger type enum
+ *
+ * @author xuxueli 2018-09-16 04:56:41
+ */
+public enum TriggerTypeEnum {
+
+	MANUAL(I18nUtil.getString("jobconf_trigger_type_manual")),
+	CRON(I18nUtil.getString("jobconf_trigger_type_cron")),
+	RETRY(I18nUtil.getString("jobconf_trigger_type_retry")),
+	PARENT(I18nUtil.getString("jobconf_trigger_type_parent")),
+	API(I18nUtil.getString("jobconf_trigger_type_api"));
+
+	private TriggerTypeEnum(String title) {
+		this.title = title;
+	}
+
+	private String title;
+
+	public String getTitle() {
+		return title;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/trigger/XxlJobTrigger.java

+package com.xxl.job.admin.core.trigger;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import com.xxl.job.admin.core.scheduler.XxlJobScheduler;
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobLog;
+import com.xxl.job.admin.core.route.ExecutorRouteStrategyEnum;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.core.biz.ExecutorBiz;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.biz.model.TriggerParam;
+import com.xxl.job.core.enums.ExecutorBlockStrategyEnum;
+import com.xxl.rpc.util.IpUtil;
+import com.xxl.rpc.util.ThrowableUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Date;
+
+/**
+ * xxl-job trigger
+ * Created by xuxueli on 17/7/13.
+ */
+public class XxlJobTrigger {
+	private static Logger logger = LoggerFactory.getLogger(XxlJobTrigger.class);
+
+	/**
+	 * trigger job
+	 *
+	 * @param jobId
+	 * @param triggerType
+	 * @param failRetryCount        >=0: use this param
+	 *                              <0: use param from job info config
+	 * @param executorShardingParam
+	 * @param executorParam         null: use job param
+	 *                              not null: cover job param
+	 */
+	public static void trigger(int jobId, TriggerTypeEnum triggerType, int failRetryCount, String executorShardingParam, String executorParam) {
+		// load data
+		XxlJobInfo jobInfo = XxlJobAdminConfig.getAdminConfig().getXxlJobInfoDao().loadById(jobId);
+		if (jobInfo == null) {
+			logger.warn(">>>>>>>>>>>> trigger fail, jobId invalid，jobId={}", jobId);
+			return;
+		}
+		if (executorParam != null) {
+			jobInfo.setExecutorParam(executorParam);
+		}
+		int finalFailRetryCount = failRetryCount >= 0 ? failRetryCount : jobInfo.getExecutorFailRetryCount();
+		XxlJobGroup group = XxlJobAdminConfig.getAdminConfig().getXxlJobGroupDao().load(jobInfo.getJobGroup());
+
+		// sharding param
+		int[] shardingParam = null;
+		if (executorShardingParam != null) {
+			String[] shardingArr = executorShardingParam.split("/");
+			if (shardingArr.length == 2 && isNumeric(shardingArr[0]) && isNumeric(shardingArr[1])) {
+				shardingParam = new int[2];
+				shardingParam[0] = Integer.valueOf(shardingArr[0]);
+				shardingParam[1] = Integer.valueOf(shardingArr[1]);
+			}
+		}
+		if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null)
+				&& group.getRegistryList() != null && !group.getRegistryList().isEmpty()
+				&& shardingParam == null) {
+			for (int i = 0; i < group.getRegistryList().size(); i++) {
+				processTrigger(group, jobInfo, finalFailRetryCount, triggerType, i, group.getRegistryList().size());
+			}
+		} else {
+			if (shardingParam == null) {
+				shardingParam = new int[]{0, 1};
+			}
+			processTrigger(group, jobInfo, finalFailRetryCount, triggerType, shardingParam[0], shardingParam[1]);
+		}
+
+	}
+
+	private static boolean isNumeric(String str) {
+		try {
+			int result = Integer.valueOf(str);
+			return true;
+		} catch (NumberFormatException e) {
+			return false;
+		}
+	}
+
+	/**
+	 * @param group               job group, registry list may be empty
+	 * @param jobInfo
+	 * @param finalFailRetryCount
+	 * @param triggerType
+	 * @param index               sharding index
+	 * @param total               sharding index
+	 */
+	private static void processTrigger(XxlJobGroup group, XxlJobInfo jobInfo, int finalFailRetryCount, TriggerTypeEnum triggerType, int index, int total) {
+
+		// param
+		ExecutorBlockStrategyEnum blockStrategy = ExecutorBlockStrategyEnum.match(jobInfo.getExecutorBlockStrategy(), ExecutorBlockStrategyEnum.SERIAL_EXECUTION);  // block strategy
+		ExecutorRouteStrategyEnum executorRouteStrategyEnum = ExecutorRouteStrategyEnum.match(jobInfo.getExecutorRouteStrategy(), null);    // route strategy
+		String shardingParam = (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) ? String.valueOf(index).concat("/").concat(String.valueOf(total)) : null;
+
+		// 1、save log-id
+		XxlJobLog jobLog = new XxlJobLog();
+		jobLog.setJobGroup(jobInfo.getJobGroup());
+		jobLog.setJobId(jobInfo.getId());
+		jobLog.setTriggerTime(new Date());
+		XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().save(jobLog);
+		logger.debug(">>>>>>>>>>> xxl-job trigger start, jobId:{}", jobLog.getId());
+
+		// 2、init trigger-param
+		TriggerParam triggerParam = new TriggerParam();
+		triggerParam.setJobId(jobInfo.getId());
+		triggerParam.setExecutorHandler(jobInfo.getExecutorHandler());
+		triggerParam.setExecutorParams(jobInfo.getExecutorParam());
+		triggerParam.setExecutorBlockStrategy(jobInfo.getExecutorBlockStrategy());
+		triggerParam.setExecutorTimeout(jobInfo.getExecutorTimeout());
+		triggerParam.setLogId(jobLog.getId());
+		triggerParam.setLogDateTime(jobLog.getTriggerTime().getTime());
+		triggerParam.setGlueType(jobInfo.getGlueType());
+		triggerParam.setGlueSource(jobInfo.getGlueSource());
+		triggerParam.setGlueUpdatetime(jobInfo.getGlueUpdatetime().getTime());
+		triggerParam.setBroadcastIndex(index);
+		triggerParam.setBroadcastTotal(total);
+
+		// 3、init address
+		String address = null;
+		ReturnT<String> routeAddressResult = null;
+		if (group.getRegistryList() != null && !group.getRegistryList().isEmpty()) {
+			if (ExecutorRouteStrategyEnum.SHARDING_BROADCAST == executorRouteStrategyEnum) {
+				if (index < group.getRegistryList().size()) {
+					address = group.getRegistryList().get(index);
+				} else {
+					address = group.getRegistryList().get(0);
+				}
+			} else {
+				routeAddressResult = executorRouteStrategyEnum.getRouter().route(triggerParam, group.getRegistryList());
+				if (routeAddressResult.getCode() == ReturnT.SUCCESS_CODE) {
+					address = routeAddressResult.getContent();
+				}
+			}
+		} else {
+			routeAddressResult = new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobconf_trigger_address_empty"));
+		}
+
+		// 4、trigger remote executor
+		ReturnT<String> triggerResult = null;
+		if (address != null) {
+			triggerResult = runExecutor(triggerParam, address);
+		} else {
+			triggerResult = new ReturnT<String>(ReturnT.FAIL_CODE, null);
+		}
+
+		// 5、collection trigger info
+		StringBuffer triggerMsgSb = new StringBuffer();
+		triggerMsgSb.append(I18nUtil.getString("jobconf_trigger_type")).append("：").append(triggerType.getTitle());
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_admin_adress")).append("：").append(IpUtil.getIp());
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regtype")).append("：")
+				.append((group.getAddressType() == 0) ? I18nUtil.getString("jobgroup_field_addressType_0") : I18nUtil.getString("jobgroup_field_addressType_1"));
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobconf_trigger_exe_regaddress")).append("：").append(group.getRegistryList());
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorRouteStrategy")).append("：").append(executorRouteStrategyEnum.getTitle());
+		if (shardingParam != null) {
+			triggerMsgSb.append("(" + shardingParam + ")");
+		}
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorBlockStrategy")).append("：").append(blockStrategy.getTitle());
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_timeout")).append("：").append(jobInfo.getExecutorTimeout());
+		triggerMsgSb.append("<br>").append(I18nUtil.getString("jobinfo_field_executorFailRetryCount")).append("：").append(finalFailRetryCount);
+
+		triggerMsgSb.append("<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_run") + "<<<<<<<<<<< </span><br>")
+				.append((routeAddressResult != null && routeAddressResult.getMsg() != null) ? routeAddressResult.getMsg() + "<br><br>" : "").append(triggerResult.getMsg() != null ? triggerResult.getMsg() : "");
+
+		// 6、save log trigger-info
+		jobLog.setExecutorAddress(address);
+		jobLog.setExecutorHandler(jobInfo.getExecutorHandler());
+		jobLog.setExecutorParam(jobInfo.getExecutorParam());
+		jobLog.setExecutorShardingParam(shardingParam);
+		jobLog.setExecutorFailRetryCount(finalFailRetryCount);
+		//jobLog.setTriggerTime();
+		jobLog.setTriggerCode(triggerResult.getCode());
+		jobLog.setTriggerMsg(triggerMsgSb.toString());
+		XxlJobAdminConfig.getAdminConfig().getXxlJobLogDao().updateTriggerInfo(jobLog);
+
+		logger.debug(">>>>>>>>>>> xxl-job trigger end, jobId:{}", jobLog.getId());
+	}
+
+	/**
+	 * run executor
+	 *
+	 * @param triggerParam
+	 * @param address
+	 * @return
+	 */
+	public static ReturnT<String> runExecutor(TriggerParam triggerParam, String address) {
+		ReturnT<String> runResult = null;
+		try {
+			ExecutorBiz executorBiz = XxlJobScheduler.getExecutorBiz(address);
+			runResult = executorBiz.run(triggerParam);
+		} catch (Exception e) {
+			logger.error(">>>>>>>>>>> xxl-job trigger error, please check if the executor[{}] is running.", address, e);
+			runResult = new ReturnT<String>(ReturnT.FAIL_CODE, ThrowableUtil.toString(e));
+		}
+
+		StringBuffer runResultSB = new StringBuffer(I18nUtil.getString("jobconf_trigger_run") + "：");
+		runResultSB.append("<br>address：").append(address);
+		runResultSB.append("<br>code：").append(runResult.getCode());
+		runResultSB.append("<br>msg：").append(runResult.getMsg());
+
+		runResult.setMsg(runResultSB.toString());
+		return runResult;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/util/CookieUtil.java

+package com.xxl.job.admin.core.util;
+
+import javax.servlet.http.Cookie;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * Cookie.Util
+ *
+ * @author xuxueli 2015-12-12 18:01:06
+ */
+public class CookieUtil {
+
+	// 默认缓存时间,单位/秒, 2H
+	private static final int COOKIE_MAX_AGE = Integer.MAX_VALUE;
+	// 保存路径,根路径
+	private static final String COOKIE_PATH = "/";
+
+	/**
+	 * 保存
+	 *
+	 * @param response
+	 * @param key
+	 * @param value
+	 * @param ifRemember
+	 */
+	public static void set(HttpServletResponse response, String key, String value, boolean ifRemember) {
+		int age = ifRemember ? COOKIE_MAX_AGE : -1;
+		set(response, key, value, null, COOKIE_PATH, age, true);
+	}
+
+	/**
+	 * 保存
+	 *
+	 * @param response
+	 * @param key
+	 * @param value
+	 * @param maxAge
+	 */
+	private static void set(HttpServletResponse response, String key, String value, String domain, String path, int maxAge, boolean isHttpOnly) {
+		Cookie cookie = new Cookie(key, value);
+		if (domain != null) {
+			cookie.setDomain(domain);
+		}
+		cookie.setPath(path);
+		cookie.setMaxAge(maxAge);
+		cookie.setHttpOnly(isHttpOnly);
+		response.addCookie(cookie);
+	}
+
+	/**
+	 * 查询value
+	 *
+	 * @param request
+	 * @param key
+	 * @return
+	 */
+	public static String getValue(HttpServletRequest request, String key) {
+		Cookie cookie = get(request, key);
+		if (cookie != null) {
+			return cookie.getValue();
+		}
+		return null;
+	}
+
+	/**
+	 * 查询Cookie
+	 *
+	 * @param request
+	 * @param key
+	 */
+	private static Cookie get(HttpServletRequest request, String key) {
+		Cookie[] arr_cookie = request.getCookies();
+		if (arr_cookie != null && arr_cookie.length > 0) {
+			for (Cookie cookie : arr_cookie) {
+				if (cookie.getName().equals(key)) {
+					return cookie;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * 删除Cookie
+	 *
+	 * @param request
+	 * @param response
+	 * @param key
+	 */
+	public static void remove(HttpServletRequest request, HttpServletResponse response, String key) {
+		Cookie cookie = get(request, key);
+		if (cookie != null) {
+			set(response, key, "", null, COOKIE_PATH, 0, true);
+		}
+	}
+
+}
\ No newline at end of file

src/main/java/com/xxl/job/admin/core/util/FtlUtil.java

+package com.xxl.job.admin.core.util;
+
+import freemarker.ext.beans.BeansWrapper;
+import freemarker.ext.beans.BeansWrapperBuilder;
+import freemarker.template.Configuration;
+import freemarker.template.TemplateHashModel;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * ftl util
+ *
+ * @author xuxueli 2018-01-17 20:37:48
+ */
+public class FtlUtil {
+	private static Logger logger = LoggerFactory.getLogger(FtlUtil.class);
+
+	private static BeansWrapper wrapper = new BeansWrapperBuilder(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS).build();     //BeansWrapper.getDefaultInstance();
+
+	public static TemplateHashModel generateStaticModel(String packageName) {
+		try {
+			TemplateHashModel staticModels = wrapper.getStaticModels();
+			TemplateHashModel fileStatics = (TemplateHashModel) staticModels.get(packageName);
+			return fileStatics;
+		} catch (Exception e) {
+			logger.error(e.getMessage(), e);
+		}
+		return null;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/util/I18nUtil.java

+package com.xxl.job.admin.core.util;
+
+import com.xxl.job.admin.core.conf.XxlJobAdminConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.EncodedResource;
+import org.springframework.core.io.support.PropertiesLoaderUtils;
+
+import java.io.IOException;
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * i18n util
+ *
+ * @author xuxueli 2018-01-17 20:39:06
+ */
+public class I18nUtil {
+	private static Logger logger = LoggerFactory.getLogger(I18nUtil.class);
+
+	private static Properties prop = null;
+
+	public static Properties loadI18nProp() {
+		if (prop != null) {
+			return prop;
+		}
+		try {
+			// build i18n prop
+			String i18n = XxlJobAdminConfig.getAdminConfig().getI18n();
+			i18n = (i18n != null && i18n.trim().length() > 0) ? ("_" + i18n) : i18n;
+			String i18nFile = MessageFormat.format("i18n/message{0}.properties", i18n);
+
+			// load prop
+			Resource resource = new ClassPathResource(i18nFile);
+			EncodedResource encodedResource = new EncodedResource(resource, "UTF-8");
+			prop = PropertiesLoaderUtils.loadProperties(encodedResource);
+		} catch (IOException e) {
+			logger.error(e.getMessage(), e);
+		}
+		return prop;
+	}
+
+	/**
+	 * get val of i18n key
+	 *
+	 * @param key
+	 * @return
+	 */
+	public static String getString(String key) {
+		return loadI18nProp().getProperty(key);
+	}
+
+	/**
+	 * get mult val of i18n mult key, as json
+	 *
+	 * @param keys
+	 * @return
+	 */
+	public static String getMultString(String... keys) {
+		Map<String, String> map = new HashMap<String, String>();
+
+		Properties prop = loadI18nProp();
+		if (keys != null && keys.length > 0) {
+			for (String key : keys) {
+				map.put(key, prop.getProperty(key));
+			}
+		} else {
+			for (String key : prop.stringPropertyNames()) {
+				map.put(key, prop.getProperty(key));
+			}
+		}
+
+		String json = JacksonUtil.writeValueAsString(map);
+		return json;
+	}
+
+}

src/main/java/com/xxl/job/admin/core/util/JacksonUtil.java

+package com.xxl.job.admin.core.util;
+
+import com.fasterxml.jackson.core.JsonGenerationException;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+/**
+ * Jackson util
+ * <p>
+ * 1、obj need private and set/get；
+ * 2、do not support inner class；
+ *
+ * @author xuxueli 2015-9-25 18:02:56
+ */
+public class JacksonUtil {
+	private static Logger logger = LoggerFactory.getLogger(JacksonUtil.class);
+
+	private final static ObjectMapper objectMapper = new ObjectMapper();
+
+	public static ObjectMapper getInstance() {
+		return objectMapper;
+	}
+
+	/**
+	 * bean、array、List、Map --> json
+	 *
+	 * @param obj
+	 * @return json string
+	 * @throws Exception
+	 */
+	public static String writeValueAsString(Object obj) {
+		try {
+			return getInstance().writeValueAsString(obj);
+		} catch (JsonGenerationException e) {
+			logger.error(e.getMessage(), e);
+		} catch (JsonMappingException e) {
+			logger.error(e.getMessage(), e);
+		} catch (IOException e) {
+			logger.error(e.getMessage(), e);
+		}
+		return null;
+	}
+
+	/**
+	 * string --> bean、Map、List(array)
+	 *
+	 * @param jsonStr
+	 * @param clazz
+	 * @return obj
+	 * @throws Exception
+	 */
+	public static <T> T readValue(String jsonStr, Class<T> clazz) {
+		try {
+			return getInstance().readValue(jsonStr, clazz);
+		} catch (JsonParseException e) {
+			logger.error(e.getMessage(), e);
+		} catch (JsonMappingException e) {
+			logger.error(e.getMessage(), e);
+		} catch (IOException e) {
+			logger.error(e.getMessage(), e);
+		}
+		return null;
+	}
+
+	/**
+	 * string --> List<Bean>...
+	 *
+	 * @param jsonStr
+	 * @param parametrized
+	 * @param parameterClasses
+	 * @param <T>
+	 * @return
+	 */
+	public static <T> T readValue(String jsonStr, Class<?> parametrized, Class<?>... parameterClasses) {
+		try {
+			JavaType javaType = getInstance().getTypeFactory().constructParametricType(parametrized, parameterClasses);
+			return getInstance().readValue(jsonStr, javaType);
+		} catch (JsonParseException e) {
+			logger.error(e.getMessage(), e);
+		} catch (JsonMappingException e) {
+			logger.error(e.getMessage(), e);
+		} catch (IOException e) {
+			logger.error(e.getMessage(), e);
+		}
+		return null;
+	}
+}

src/main/java/com/xxl/job/admin/core/util/LocalCacheUtil.java

+package com.xxl.job.admin.core.util;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * local cache tool
+ *
+ * @author xuxueli 2018-01-22 21:37:34
+ */
+public class LocalCacheUtil {
+
+	private static ConcurrentMap<String, LocalCacheData> cacheRepository = new ConcurrentHashMap<String, LocalCacheData>();   // 类型建议用抽象父类，兼容性更好；
+
+	private static class LocalCacheData {
+		private String key;
+		private Object val;
+		private long timeoutTime;
+
+		public LocalCacheData() {
+		}
+
+		public LocalCacheData(String key, Object val, long timeoutTime) {
+			this.key = key;
+			this.val = val;
+			this.timeoutTime = timeoutTime;
+		}
+
+		public String getKey() {
+			return key;
+		}
+
+		public void setKey(String key) {
+			this.key = key;
+		}
+
+		public Object getVal() {
+			return val;
+		}
+
+		public void setVal(Object val) {
+			this.val = val;
+		}
+
+		public long getTimeoutTime() {
+			return timeoutTime;
+		}
+
+		public void setTimeoutTime(long timeoutTime) {
+			this.timeoutTime = timeoutTime;
+		}
+	}
+
+
+	/**
+	 * set cache
+	 *
+	 * @param key
+	 * @param val
+	 * @param cacheTime
+	 * @return
+	 */
+	public static boolean set(String key, Object val, long cacheTime) {
+
+		// clean timeout cache, before set new cache (avoid cache too much)
+		cleanTimeoutCache();
+
+		// set new cache
+		if (key == null || key.trim().length() == 0) {
+			return false;
+		}
+		if (val == null) {
+			remove(key);
+		}
+		if (cacheTime <= 0) {
+			remove(key);
+		}
+		long timeoutTime = System.currentTimeMillis() + cacheTime;
+		LocalCacheData localCacheData = new LocalCacheData(key, val, timeoutTime);
+		cacheRepository.put(localCacheData.getKey(), localCacheData);
+		return true;
+	}
+
+	/**
+	 * remove cache
+	 *
+	 * @param key
+	 * @return
+	 */
+	public static boolean remove(String key) {
+		if (key == null || key.trim().length() == 0) {
+			return false;
+		}
+		cacheRepository.remove(key);
+		return true;
+	}
+
+	/**
+	 * get cache
+	 *
+	 * @param key
+	 * @return
+	 */
+	public static Object get(String key) {
+		if (key == null || key.trim().length() == 0) {
+			return null;
+		}
+		LocalCacheData localCacheData = cacheRepository.get(key);
+		if (localCacheData != null && System.currentTimeMillis() < localCacheData.getTimeoutTime()) {
+			return localCacheData.getVal();
+		} else {
+			remove(key);
+			return null;
+		}
+	}
+
+	/**
+	 * clean timeout cache
+	 *
+	 * @return
+	 */
+	public static boolean cleanTimeoutCache() {
+		if (!cacheRepository.keySet().isEmpty()) {
+			for (String key : cacheRepository.keySet()) {
+				LocalCacheData localCacheData = cacheRepository.get(key);
+				if (localCacheData != null && System.currentTimeMillis() >= localCacheData.getTimeoutTime()) {
+					cacheRepository.remove(key);
+				}
+			}
+		}
+		return true;
+	}
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobGroupDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobGroup;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * Created by xuxueli on 16/9/30.
+ */
+@Mapper
+public interface XxlJobGroupDao {
+
+	public List<XxlJobGroup> findAll();
+
+	public List<XxlJobGroup> findByAddressType(@Param("addressType") int addressType);
+
+	public int save(XxlJobGroup xxlJobGroup);
+
+	public int update(XxlJobGroup xxlJobGroup);
+
+	public int remove(@Param("id") int id);
+
+	public XxlJobGroup load(@Param("id") int id);
+}

src/main/java/com/xxl/job/admin/dao/XxlJobInfoDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+
+/**
+ * job info
+ *
+ * @author xuxueli 2016-1-12 18:03:45
+ */
+@Mapper
+public interface XxlJobInfoDao {
+
+	public List<XxlJobInfo> pageList(@Param("offset") int offset,
+	                                 @Param("pagesize") int pagesize,
+	                                 @Param("jobGroup") int jobGroup,
+	                                 @Param("triggerStatus") int triggerStatus,
+	                                 @Param("jobDesc") String jobDesc,
+	                                 @Param("executorHandler") String executorHandler,
+	                                 @Param("author") String author);
+
+	public int pageListCount(@Param("offset") int offset,
+	                         @Param("pagesize") int pagesize,
+	                         @Param("jobGroup") int jobGroup,
+	                         @Param("triggerStatus") int triggerStatus,
+	                         @Param("jobDesc") String jobDesc,
+	                         @Param("executorHandler") String executorHandler,
+	                         @Param("author") String author);
+
+	public int save(XxlJobInfo info);
+
+	public XxlJobInfo loadById(@Param("id") int id);
+
+	public int update(XxlJobInfo xxlJobInfo);
+
+	public int delete(@Param("id") long id);
+
+	public List<XxlJobInfo> getJobsByGroup(@Param("jobGroup") int jobGroup);
+
+	public int findAllCount();
+
+	public List<XxlJobInfo> scheduleJobQuery(@Param("maxNextTime") long maxNextTime, @Param("pagesize") int pagesize);
+
+	public int scheduleUpdate(XxlJobInfo xxlJobInfo);
+
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobLogDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobLog;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * job log
+ *
+ * @author xuxueli 2016-1-12 18:03:06
+ */
+@Mapper
+public interface XxlJobLogDao {
+
+	// exist jobId not use jobGroup, not exist use jobGroup
+	public List<XxlJobLog> pageList(@Param("offset") int offset,
+	                                @Param("pagesize") int pagesize,
+	                                @Param("jobGroup") int jobGroup,
+	                                @Param("jobId") int jobId,
+	                                @Param("triggerTimeStart") Date triggerTimeStart,
+	                                @Param("triggerTimeEnd") Date triggerTimeEnd,
+	                                @Param("logStatus") int logStatus);
+
+	public int pageListCount(@Param("offset") int offset,
+	                         @Param("pagesize") int pagesize,
+	                         @Param("jobGroup") int jobGroup,
+	                         @Param("jobId") int jobId,
+	                         @Param("triggerTimeStart") Date triggerTimeStart,
+	                         @Param("triggerTimeEnd") Date triggerTimeEnd,
+	                         @Param("logStatus") int logStatus);
+
+	public XxlJobLog load(@Param("id") long id);
+
+	public long save(XxlJobLog xxlJobLog);
+
+	public int updateTriggerInfo(XxlJobLog xxlJobLog);
+
+	public int updateHandleInfo(XxlJobLog xxlJobLog);
+
+	public int delete(@Param("jobId") int jobId);
+
+	public Map<String, Object> findLogReport(@Param("from") Date from,
+	                                         @Param("to") Date to);
+
+	public List<Long> findClearLogIds(@Param("jobGroup") int jobGroup,
+	                                  @Param("jobId") int jobId,
+	                                  @Param("clearBeforeTime") Date clearBeforeTime,
+	                                  @Param("clearBeforeNum") int clearBeforeNum,
+	                                  @Param("pagesize") int pagesize);
+
+	public int clearLog(@Param("logIds") List<Long> logIds);
+
+	public List<Long> findFailJobLogIds(@Param("pagesize") int pagesize);
+
+	public int updateAlarmStatus(@Param("logId") long logId,
+	                             @Param("oldAlarmStatus") int oldAlarmStatus,
+	                             @Param("newAlarmStatus") int newAlarmStatus);
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobLogGlueDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobLogGlue;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * job log for glue
+ *
+ * @author xuxueli 2016-5-19 18:04:56
+ */
+@Mapper
+public interface XxlJobLogGlueDao {
+
+	public int save(XxlJobLogGlue xxlJobLogGlue);
+
+	public List<XxlJobLogGlue> findByJobId(@Param("jobId") int jobId);
+
+	public int removeOld(@Param("jobId") int jobId, @Param("limit") int limit);
+
+	public int deleteByJobId(@Param("jobId") int jobId);
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobLogReportDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobLogReport;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * job log
+ *
+ * @author xuxueli 2019-11-22
+ */
+@Mapper
+public interface XxlJobLogReportDao {
+
+	public int save(XxlJobLogReport xxlJobLogReport);
+
+	public int update(XxlJobLogReport xxlJobLogReport);
+
+	public List<XxlJobLogReport> queryLogReport(@Param("triggerDayFrom") Date triggerDayFrom,
+	                                            @Param("triggerDayTo") Date triggerDayTo);
+
+	public XxlJobLogReport queryLogReportTotal();
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobRegistryDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobRegistry;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Created by xuxueli on 16/9/30.
+ */
+@Mapper
+public interface XxlJobRegistryDao {
+
+	public List<Integer> findDead(@Param("timeout") int timeout,
+	                              @Param("nowTime") Date nowTime);
+
+	public int removeDead(@Param("ids") List<Integer> ids);
+
+	public List<XxlJobRegistry> findAll(@Param("timeout") int timeout,
+	                                    @Param("nowTime") Date nowTime);
+
+	public int registryUpdate(@Param("registryGroup") String registryGroup,
+	                          @Param("registryKey") String registryKey,
+	                          @Param("registryValue") String registryValue,
+	                          @Param("updateTime") Date updateTime);
+
+	public int registrySave(@Param("registryGroup") String registryGroup,
+	                        @Param("registryKey") String registryKey,
+	                        @Param("registryValue") String registryValue,
+	                        @Param("updateTime") Date updateTime);
+
+	public int registryDelete(@Param("registryGroup") String registryGroup,
+	                          @Param("registryKey") String registryKey,
+	                          @Param("registryValue") String registryValue);
+
+}

src/main/java/com/xxl/job/admin/dao/XxlJobUserDao.java

+package com.xxl.job.admin.dao;
+
+import com.xxl.job.admin.core.model.XxlJobUser;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author xuxueli 2019-05-04 16:44:59
+ */
+@Mapper
+public interface XxlJobUserDao {
+
+	public List<XxlJobUser> pageList(@Param("offset") int offset,
+	                                 @Param("pagesize") int pagesize,
+	                                 @Param("username") String username,
+	                                 @Param("role") int role);
+
+	public int pageListCount(@Param("offset") int offset,
+	                         @Param("pagesize") int pagesize,
+	                         @Param("username") String username,
+	                         @Param("role") int role);
+
+	public XxlJobUser loadByUserName(@Param("username") String username);
+
+	public int save(XxlJobUser xxlJobUser);
+
+	public int update(XxlJobUser xxlJobUser);
+
+	public int delete(@Param("id") int id);
+
+}

src/main/java/com/xxl/job/admin/service/LoginService.java

+package com.xxl.job.admin.service;
+
+import com.xxl.job.admin.core.model.XxlJobUser;
+import com.xxl.job.admin.core.util.CookieUtil;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.core.util.JacksonUtil;
+import com.xxl.job.admin.dao.XxlJobUserDao;
+import com.xxl.job.core.biz.model.ReturnT;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.DigestUtils;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.math.BigInteger;
+
+/**
+ * @author xuxueli 2019-05-04 22:13:264
+ */
+@Configuration
+public class LoginService {
+
+	public static final String LOGIN_IDENTITY_KEY = "XXL_JOB_LOGIN_IDENTITY";
+
+	@Resource
+	private XxlJobUserDao xxlJobUserDao;
+
+
+	private String makeToken(XxlJobUser xxlJobUser) {
+		String tokenJson = JacksonUtil.writeValueAsString(xxlJobUser);
+		String tokenHex = new BigInteger(tokenJson.getBytes()).toString(16);
+		return tokenHex;
+	}
+
+	private XxlJobUser parseToken(String tokenHex) {
+		XxlJobUser xxlJobUser = null;
+		if (tokenHex != null) {
+			String tokenJson = new String(new BigInteger(tokenHex, 16).toByteArray());      // username_password(md5)
+			xxlJobUser = JacksonUtil.readValue(tokenJson, XxlJobUser.class);
+		}
+		return xxlJobUser;
+	}
+
+
+	public ReturnT<String> login(HttpServletRequest request, HttpServletResponse response, String username, String password, boolean ifRemember) {
+
+		// param
+		if (username == null || username.trim().length() == 0 || password == null || password.trim().length() == 0) {
+			return new ReturnT<String>(500, I18nUtil.getString("login_param_empty"));
+		}
+
+		// valid passowrd
+		XxlJobUser xxlJobUser = xxlJobUserDao.loadByUserName(username);
+		if (xxlJobUser == null) {
+			return new ReturnT<String>(500, I18nUtil.getString("login_param_unvalid"));
+		}
+		String passwordMd5 = DigestUtils.md5DigestAsHex(password.getBytes());
+		if (!passwordMd5.equals(xxlJobUser.getPassword())) {
+			return new ReturnT<String>(500, I18nUtil.getString("login_param_unvalid"));
+		}
+
+		String loginToken = makeToken(xxlJobUser);
+
+		// do login
+		CookieUtil.set(response, LOGIN_IDENTITY_KEY, loginToken, ifRemember);
+		return ReturnT.SUCCESS;
+	}
+
+	/**
+	 * logout
+	 *
+	 * @param request
+	 * @param response
+	 */
+	public ReturnT<String> logout(HttpServletRequest request, HttpServletResponse response) {
+		CookieUtil.remove(request, response, LOGIN_IDENTITY_KEY);
+		return ReturnT.SUCCESS;
+	}
+
+	/**
+	 * logout
+	 *
+	 * @param request
+	 * @return
+	 */
+	public XxlJobUser ifLogin(HttpServletRequest request, HttpServletResponse response) {
+		String cookieToken = CookieUtil.getValue(request, LOGIN_IDENTITY_KEY);
+		if (cookieToken != null) {
+			XxlJobUser cookieUser = null;
+			try {
+				cookieUser = parseToken(cookieToken);
+			} catch (Exception e) {
+				logout(request, response);
+			}
+			if (cookieUser != null) {
+				XxlJobUser dbUser = xxlJobUserDao.loadByUserName(cookieUser.getUsername());
+				if (dbUser != null) {
+					if (cookieUser.getPassword().equals(dbUser.getPassword())) {
+						return dbUser;
+					}
+				}
+			}
+		}
+		return null;
+	}
+
+
+}

src/main/java/com/xxl/job/admin/service/XxlJobService.java

+package com.xxl.job.admin.service;
+
+
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.core.biz.model.ReturnT;
+
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * core job action for xxl-job
+ *
+ * @author xuxueli 2016-5-28 15:30:33
+ */
+public interface XxlJobService {
+
+	/**
+	 * page list
+	 *
+	 * @param start
+	 * @param length
+	 * @param jobGroup
+	 * @param jobDesc
+	 * @param executorHandler
+	 * @param author
+	 * @return
+	 */
+	public Map<String, Object> pageList(int start, int length, int jobGroup, int triggerStatus, String jobDesc, String executorHandler, String author);
+
+	/**
+	 * add job
+	 *
+	 * @param jobInfo
+	 * @return
+	 */
+	public ReturnT<String> add(XxlJobInfo jobInfo);
+
+	/**
+	 * update job
+	 *
+	 * @param jobInfo
+	 * @return
+	 */
+	public ReturnT<String> update(XxlJobInfo jobInfo);
+
+	/**
+	 * remove job
+	 * *
+	 *
+	 * @param id
+	 * @return
+	 */
+	public ReturnT<String> remove(int id);
+
+	/**
+	 * start job
+	 *
+	 * @param id
+	 * @return
+	 */
+	public ReturnT<String> start(int id);
+
+	/**
+	 * stop job
+	 *
+	 * @param id
+	 * @return
+	 */
+	public ReturnT<String> stop(int id);
+
+	/**
+	 * dashboard info
+	 *
+	 * @return
+	 */
+	public Map<String, Object> dashboardInfo();
+
+	/**
+	 * chart info
+	 *
+	 * @param startDate
+	 * @param endDate
+	 * @return
+	 */
+	public ReturnT<Map<String, Object>> chartInfo(Date startDate, Date endDate);
+
+}

src/main/java/com/xxl/job/admin/service/impl/AdminBizImpl.java

+package com.xxl.job.admin.service.impl;
+
+import com.xxl.job.admin.core.model.XxlJobInfo;
+import com.xxl.job.admin.core.model.XxlJobLog;
+import com.xxl.job.admin.core.thread.JobTriggerPoolHelper;
+import com.xxl.job.admin.core.trigger.TriggerTypeEnum;
+import com.xxl.job.admin.core.util.I18nUtil;
+import com.xxl.job.admin.dao.XxlJobGroupDao;
+import com.xxl.job.admin.dao.XxlJobInfoDao;
+import com.xxl.job.admin.dao.XxlJobLogDao;
+import com.xxl.job.admin.dao.XxlJobRegistryDao;
+import com.xxl.job.core.biz.AdminBiz;
+import com.xxl.job.core.biz.model.HandleCallbackParam;
+import com.xxl.job.core.biz.model.RegistryParam;
+import com.xxl.job.core.biz.model.ReturnT;
+import com.xxl.job.core.handler.IJobHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import javax.annotation.Resource;
+import java.text.MessageFormat;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author xuxueli 2017-07-27 21:54:20
+ */
+@Service
+public class AdminBizImpl implements AdminBiz {
+	private static Logger logger = LoggerFactory.getLogger(AdminBizImpl.class);
+
+	@Resource
+	public XxlJobLogDao xxlJobLogDao;
+	@Resource
+	private XxlJobInfoDao xxlJobInfoDao;
+	@Resource
+	private XxlJobRegistryDao xxlJobRegistryDao;
+	@Resource
+	private XxlJobGroupDao xxlJobGroupDao;
+
+
+	@Override
+	public ReturnT<String> callback(List<HandleCallbackParam> callbackParamList) {
+		for (HandleCallbackParam handleCallbackParam : callbackParamList) {
+			ReturnT<String> callbackResult = callback(handleCallbackParam);
+			logger.debug(">>>>>>>>> JobApiController.callback {}, handleCallbackParam={}, callbackResult={}",
+					(callbackResult.getCode() == IJobHandler.SUCCESS.getCode() ? "success" : "fail"), handleCallbackParam, callbackResult);
+		}
+
+		return ReturnT.SUCCESS;
+	}
+
+	private ReturnT<String> callback(HandleCallbackParam handleCallbackParam) {
+		// valid log item
+		XxlJobLog log = xxlJobLogDao.load(handleCallbackParam.getLogId());
+		if (log == null) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "log item not found.");
+		}
+		if (log.getHandleCode() > 0) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "log repeate callback.");     // avoid repeat callback, trigger child job etc
+		}
+
+		// trigger success, to trigger child job
+		String callbackMsg = null;
+		if (IJobHandler.SUCCESS.getCode() == handleCallbackParam.getExecuteResult().getCode()) {
+			XxlJobInfo xxlJobInfo = xxlJobInfoDao.loadById(log.getJobId());
+			if (xxlJobInfo != null && xxlJobInfo.getChildJobId() != null && xxlJobInfo.getChildJobId().trim().length() > 0) {
+				callbackMsg = "<br><br><span style=\"color:#00c0ef;\" > >>>>>>>>>>>" + I18nUtil.getString("jobconf_trigger_child_run") + "<<<<<<<<<<< </span><br>";
+
+				String[] childJobIds = xxlJobInfo.getChildJobId().split(",");
+				for (int i = 0; i < childJobIds.length; i++) {
+					int childJobId = (childJobIds[i] != null && childJobIds[i].trim().length() > 0 && isNumeric(childJobIds[i])) ? Integer.valueOf(childJobIds[i]) : -1;
+					if (childJobId > 0) {
+
+						JobTriggerPoolHelper.trigger(childJobId, TriggerTypeEnum.PARENT, -1, null, null);
+						ReturnT<String> triggerChildResult = ReturnT.SUCCESS;
+
+						// add msg
+						callbackMsg += MessageFormat.format(I18nUtil.getString("jobconf_callback_child_msg1"),
+								(i + 1),
+								childJobIds.length,
+								childJobIds[i],
+								(triggerChildResult.getCode() == ReturnT.SUCCESS_CODE ? I18nUtil.getString("system_success") : I18nUtil.getString("system_fail")),
+								triggerChildResult.getMsg());
+					} else {
+						callbackMsg += MessageFormat.format(I18nUtil.getString("jobconf_callback_child_msg2"),
+								(i + 1),
+								childJobIds.length,
+								childJobIds[i]);
+					}
+				}
+
+			}
+		}
+
+		// handle msg
+		StringBuffer handleMsg = new StringBuffer();
+		if (log.getHandleMsg() != null) {
+			handleMsg.append(log.getHandleMsg()).append("<br>");
+		}
+		if (handleCallbackParam.getExecuteResult().getMsg() != null) {
+			handleMsg.append(handleCallbackParam.getExecuteResult().getMsg());
+		}
+		if (callbackMsg != null) {
+			handleMsg.append(callbackMsg);
+		}
+
+		// success, save log
+		log.setHandleTime(new Date());
+		log.setHandleCode(handleCallbackParam.getExecuteResult().getCode());
+		log.setHandleMsg(handleMsg.toString());
+		xxlJobLogDao.updateHandleInfo(log);
+
+		return ReturnT.SUCCESS;
+	}
+
+	private boolean isNumeric(String str) {
+		try {
+			int result = Integer.valueOf(str);
+			return true;
+		} catch (NumberFormatException e) {
+			return false;
+		}
+	}
+
+	@Override
+	public ReturnT<String> registry(RegistryParam registryParam) {
+
+		// valid
+		if (!StringUtils.hasText(registryParam.getRegistryGroup())
+				|| !StringUtils.hasText(registryParam.getRegistryKey())
+				|| !StringUtils.hasText(registryParam.getRegistryValue())) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "Illegal Argument.");
+		}
+
+		int ret = xxlJobRegistryDao.registryUpdate(registryParam.getRegistryGroup(), registryParam.getRegistryKey(), registryParam.getRegistryValue(), new Date());
+		if (ret < 1) {
+			xxlJobRegistryDao.registrySave(registryParam.getRegistryGroup(), registryParam.getRegistryKey(), registryParam.getRegistryValue(), new Date());
+
+			// fresh
+			freshGroupRegistryInfo(registryParam);
+		}
+		return ReturnT.SUCCESS;
+	}
+
+	@Override
+	public ReturnT<String> registryRemove(RegistryParam registryParam) {
+
+		// valid
+		if (!StringUtils.hasText(registryParam.getRegistryGroup())
+				|| !StringUtils.hasText(registryParam.getRegistryKey())
+				|| !StringUtils.hasText(registryParam.getRegistryValue())) {
+			return new ReturnT<String>(ReturnT.FAIL_CODE, "Illegal Argument.");
+		}
+
+		int ret = xxlJobRegistryDao.registryDelete(registryParam.getRegistryGroup(), registryParam.getRegistryKey(), registryParam.getRegistryValue());
+		if (ret > 0) {
+
+			// fresh
+			freshGroupRegistryInfo(registryParam);
+		}
+		return ReturnT.SUCCESS;
+	}
+
+	private void freshGroupRegistryInfo(RegistryParam registryParam) {
+		// Under consideration, prevent affecting core tables
+	}
+
+}