Springboot 整合 xxljob 动态API调度任务(进阶篇)

转x33g5p2x  于2022-06-27 转载在 Spring  
字(17.9k)|赞(0)|评价(0)|浏览(1031)

前言

之前写了一篇 xxljob的新手入门篇：

Springboot 整合 xxljob 使用定时任务调度(新手入门篇)_小目标青年的博客-CSDN博客

这一篇非常非常简单，就是非常快速的springboot整合 xxljob，相当于拿来即用，能够通过页面配合代码去实现定时任务的使用。

这一篇，我们将在上一篇的基础上，做一些进阶使用，实现动态地调度定时任务。

我们平时工作经常会遇到这些业务使用场景（举例）：

执行某个业务后，需要产生一个定时任务；

怎么怎么判断成功后，需要停止某个任务；

怎么怎么判断符合条件后，需要重新执行某个任务；

怎么怎么....移除某个任务；

摊牌了，实现的效果就是：

通过API方式（或者方法函数），我们动态随意地去 增删改查、设置定时规则等等去调度任务。

上一篇几乎是基于HTML页面去对任务创建、启动、停在、删除等等， 非常需要有人去处理，这一篇就是解放我们双手！

正文

惯例，瞎话一张简图：

大致就是admin上面写一些开放接口，各个接入xxl job的demo服务都能通过接口调用，完成动态调度，至于啥时候调度，看自己的业务场景，自己使用。

① admin 服务 加接口，其实说实话，原先也提供了很多api接口，但是我这次非得自己搞一下。

提供的接口：

MyDynamicApiController.java ：
 

  1. import com.xxl.job.admin.controller.annotation.PermissionLimit;
  2. import com.xxl.job.admin.core.cron.CronExpression;
  3. import com.xxl.job.admin.core.model.XxlJobInfo;
  4. import com.xxl.job.admin.core.model.XxlJobQuery;
  5. import com.xxl.job.admin.core.thread.JobScheduleHelper;
  6. import com.xxl.job.admin.core.util.I18nUtil;
  7. import com.xxl.job.admin.service.LoginService;
  8. import com.xxl.job.admin.service.XxlJobService;
  9. import com.xxl.job.core.biz.model.ReturnT;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.web.bind.annotation.*;
  15. import javax.servlet.http.HttpServletRequest;
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.text.ParseException;
  18. import java.util.Date;
  19. import java.util.Map;
  21. /**
  22.  * @Author: JCccc
  23.  * @Date: 2022-6-2 14:23
  24.  * @Description: xxl job rest api
  25.  */
  26. @RestController
  27. @RequestMapping("/api/jobinfo")
  28. public class MyDynamicApiController {
  29.     private static Logger logger = LoggerFactory.getLogger(MyDynamicApiController.class);
  30.     @Autowired
  31.     private XxlJobService xxlJobService;
  32.     @Autowired
  33.     private LoginService loginService;
  35.     @RequestMapping(value = "/pageList",method = RequestMethod.POST)
  36.     public Map<String, Object> pageList(@RequestBody XxlJobQuery xxlJobQuery) {
  37.         return xxlJobService.pageList(
  38.                 xxlJobQuery.getStart(),
  39.                 xxlJobQuery.getLength(),
  40.                 xxlJobQuery.getJobGroup(),
  41.                 xxlJobQuery.getTriggerStatus(),
  42.                 xxlJobQuery.getJobDesc(),
  43.                 xxlJobQuery.getExecutorHandler(),
  44.                 xxlJobQuery.getAuthor());
  45.     }
  46.     @PostMapping("/save")
  47.     public ReturnT<String> add(@RequestBody(required = true)XxlJobInfo jobInfo) {
  49.         // next trigger time (5s后生效，避开预读周期)
  50.         long nextTriggerTime = 0;
  51.         try {
  52.             Date nextValidTime = new CronExpression(jobInfo.getJobCron()).getNextValidTimeAfter(new Date(System.currentTimeMillis() + JobScheduleHelper.PRE_READ_MS));
  53.             if (nextValidTime == null) {
  54.                 return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_never_fire"));
  55.             }
  56.             nextTriggerTime = nextValidTime.getTime();
  57.         } catch (ParseException e) {
  58.             logger.error(e.getMessage(), e);
  59.             return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_unvalid")+" | "+ e.getMessage());
  60.         }
  62.         jobInfo.setTriggerStatus(1);
  63.         jobInfo.setTriggerLastTime(0);
  64.         jobInfo.setTriggerNextTime(nextTriggerTime);
  66.         jobInfo.setUpdateTime(new Date());
  68.         if(jobInfo.getId()==0){
  69.             return xxlJobService.add(jobInfo);
  70.         }else{
  71.             return xxlJobService.update(jobInfo);
  72.         }
  73.     }
  74.     @RequestMapping(value = "/delete",method = RequestMethod.GET)
  75.     public ReturnT<String> delete(int id) {
  76.         return xxlJobService.remove(id);
  77.     }
  78.     @RequestMapping(value = "/start",method = RequestMethod.GET)
  79.     public ReturnT<String> start(int id) {
  80.         return xxlJobService.start(id);
  81.     }
  82.     @RequestMapping(value = "/stop",method = RequestMethod.GET)
  83.     public ReturnT<String> stop(int id) {
  84.         return xxlJobService.stop(id);
  85.     }
  86.     @RequestMapping(value="login", method=RequestMethod.GET)
  87.     @PermissionLimit(limit=false)
  88.     public ReturnT<String> loginDo(HttpServletRequest request, HttpServletResponse response, String userName, String password, String ifRemember){
  89.         boolean ifRem = (ifRemember!=null && ifRemember.trim().length()>0 && "on".equals(ifRemember))?true:false;
  90.         ReturnT<String> result= loginService.login(request, response, userName, password, ifRem);
  91.         return result;
  92.     }
  93. }

XxlJobQuery.java  

（这里有说法，为什么我这篇特意写了一个这个查询类，抛砖引玉，在新手篇里面我介绍过，xxl job 是有数据库的，意味着我们可以很容易拓展）

  1. /**
  2.  * @Author: JCccc
  3.  * @Date: 2022-6-2 14:23
  4.  * @Description: xxl job rest api
  5.  */
  6. public class XxlJobQuery {
  8. 	private	int start;
  9. 	private int length;
  10. 	private int triggerStatus;
  11. 	private String jobDesc;
  12. 	private String executorHandler;
  13. 	private String author;
  14. 	private int jobGroup;
  16. 	public int getStart() {
  17. 		return start;
  18. 	}
  20. 	public void setStart(int start) {
  21. 		this.start = start;
  22. 	}
  24. 	public int getLength() {
  25. 		return length;
  26. 	}
  28. 	public void setLength(int length) {
  29. 		this.length = length;
  30. 	}
  32. 	public int getTriggerStatus() {
  33. 		return triggerStatus;
  34. 	}
  36. 	public void setTriggerStatus(int triggerStatus) {
  37. 		this.triggerStatus = triggerStatus;
  38. 	}
  40. 	public String getJobDesc() {
  41. 		return jobDesc;
  42. 	}
  44. 	public void setJobDesc(String jobDesc) {
  45. 		this.jobDesc = jobDesc;
  46. 	}
  48. 	public String getExecutorHandler() {
  49. 		return executorHandler;
  50. 	}
  52. 	public void setExecutorHandler(String executorHandler) {
  53. 		this.executorHandler = executorHandler;
  54. 	}
  56. 	public String getAuthor() {
  57. 		return author;
  58. 	}
  60. 	public void setAuthor(String author) {
  61. 		this.author = author;
  62. 	}
  64. 	public int getJobGroup() {
  65. 		return jobGroup;
  66. 	}
  68. 	public void setJobGroup(int jobGroup) {
  69. 		this.jobGroup = jobGroup;
  70. 	}
  71. }

② 在接入xxl job 的demo上 开始玩动态调度，其实就是调用admin里我们刚才写的提供的接口

PS： 本篇里面有些不好的编码习惯，例如返回值用Map；打印用的输出，没用log； 接口返回没有统一返回数据等等， 因为我该篇是为了传递 怎么动态调度使用，具体细节大家自行调整就行，我们都是成年人，不要在意我这些点。

先是pom.xml 引入使用的一些jar：

（一个是fastjson，大家别学我，我是为了实战示例图方便，用的JsonObject来传参）

（一个是httpClient ，用于调用admin服务的api接口）

  1. <dependency>
  2.             <groupId>commons-httpclient</groupId>
  3.             <artifactId>commons-httpclient</artifactId>
  4.             <version>3.1</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>com.alibaba</groupId>
  8.             <artifactId>fastjson</artifactId>
  9.             <version>1.2.47</version>
  10.         </dependency>

XxlJobInfo.java 

这个是原作者的其实，因为我们本质还是调用了作者xxl job提供的  XxlJobService 里面的方法。

  1. import java.util.Date;
  3. /**
  4.  * xxl-job info
  5.  *
  6.  * @author xuxueli  2016-1-12 18:25:49
  7.  */
  8. public class XxlJobInfo {
  9. 	
  10. 	private int id;				// 主键ID
  11. 	private int jobGroup;		// 执行器主键ID
  12. 	private String jobDesc;     // 备注
  13. 	private String jobCron;
  14. 	private Date addTime;
  15. 	private Date updateTime;
  16. 	private String author;		// 负责人
  17. 	private String alarmEmail;	// 报警邮件
  18. 	private String scheduleType;			// 调度类型
  19. 	private String scheduleConf;			// 调度配置，值含义取决于调度类型
  20. 	private String misfireStrategy;			// 调度过期策略
  21. 	private String executorRouteStrategy;	// 执行器路由策略
  22. 	private String executorHandler;		    // 执行器，任务Handler名称
  23. 	private String executorParam;		    // 执行器，任务参数
  24. 	private String executorBlockStrategy;	// 阻塞处理策略
  25. 	private int executorTimeout;     		// 任务执行超时时间，单位秒
  26. 	private int executorFailRetryCount;		// 失败重试次数
  27. 	private String glueType;		// GLUE类型	#com.xxl.job.core.glue.GlueTypeEnum
  28. 	private String glueSource;		// GLUE源代码
  29. 	private String glueRemark;		// GLUE备注
  30. 	private Date glueUpdatetime;	// GLUE更新时间
  31. 	private String childJobId;		// 子任务ID，多个逗号分隔
  32. 	private int triggerStatus;		// 调度状态：0-停止，1-运行
  33. 	private long triggerLastTime;	// 上次调度时间
  34. 	private long triggerNextTime;	// 下次调度时间
  36. 	public String getJobCron() {
  37. 		return jobCron;
  38. 	}
  40. 	public void setJobCron(String jobCron) {
  41. 		this.jobCron = jobCron;
  42. 	}
  44. 	public int getId() {
  45. 		return id;
  46. 	}
  48. 	public void setId(int id) {
  49. 		this.id = id;
  50. 	}
  52. 	public int getJobGroup() {
  53. 		return jobGroup;
  54. 	}
  56. 	public void setJobGroup(int jobGroup) {
  57. 		this.jobGroup = jobGroup;
  58. 	}
  60. 	public String getJobDesc() {
  61. 		return jobDesc;
  62. 	}
  64. 	public void setJobDesc(String jobDesc) {
  65. 		this.jobDesc = jobDesc;
  66. 	}
  68. 	public Date getAddTime() {
  69. 		return addTime;
  70. 	}
  72. 	public void setAddTime(Date addTime) {
  73. 		this.addTime = addTime;
  74. 	}
  76. 	public Date getUpdateTime() {
  77. 		return updateTime;
  78. 	}
  80. 	public void setUpdateTime(Date updateTime) {
  81. 		this.updateTime = updateTime;
  82. 	}
  84. 	public String getAuthor() {
  85. 		return author;
  86. 	}
  88. 	public void setAuthor(String author) {
  89. 		this.author = author;
  90. 	}
  92. 	public String getAlarmEmail() {
  93. 		return alarmEmail;
  94. 	}
  96. 	public void setAlarmEmail(String alarmEmail) {
  97. 		this.alarmEmail = alarmEmail;
  98. 	}
  100. 	public String getScheduleType() {
  101. 		return scheduleType;
  102. 	}
  104. 	public void setScheduleType(String scheduleType) {
  105. 		this.scheduleType = scheduleType;
  106. 	}
  108. 	public String getScheduleConf() {
  109. 		return scheduleConf;
  110. 	}
  112. 	public void setScheduleConf(String scheduleConf) {
  113. 		this.scheduleConf = scheduleConf;
  114. 	}
  116. 	public String getMisfireStrategy() {
  117. 		return misfireStrategy;
  118. 	}
  120. 	public void setMisfireStrategy(String misfireStrategy) {
  121. 		this.misfireStrategy = misfireStrategy;
  122. 	}
  124. 	public String getExecutorRouteStrategy() {
  125. 		return executorRouteStrategy;
  126. 	}
  128. 	public void setExecutorRouteStrategy(String executorRouteStrategy) {
  129. 		this.executorRouteStrategy = executorRouteStrategy;
  130. 	}
  132. 	public String getExecutorHandler() {
  133. 		return executorHandler;
  134. 	}
  136. 	public void setExecutorHandler(String executorHandler) {
  137. 		this.executorHandler = executorHandler;
  138. 	}
  140. 	public String getExecutorParam() {
  141. 		return executorParam;
  142. 	}
  144. 	public void setExecutorParam(String executorParam) {
  145. 		this.executorParam = executorParam;
  146. 	}
  148. 	public String getExecutorBlockStrategy() {
  149. 		return executorBlockStrategy;
  150. 	}
  152. 	public void setExecutorBlockStrategy(String executorBlockStrategy) {
  153. 		this.executorBlockStrategy = executorBlockStrategy;
  154. 	}
  156. 	public int getExecutorTimeout() {
  157. 		return executorTimeout;
  158. 	}
  160. 	public void setExecutorTimeout(int executorTimeout) {
  161. 		this.executorTimeout = executorTimeout;
  162. 	}
  164. 	public int getExecutorFailRetryCount() {
  165. 		return executorFailRetryCount;
  166. 	}
  168. 	public void setExecutorFailRetryCount(int executorFailRetryCount) {
  169. 		this.executorFailRetryCount = executorFailRetryCount;
  170. 	}
  172. 	public String getGlueType() {
  173. 		return glueType;
  174. 	}
  176. 	public void setGlueType(String glueType) {
  177. 		this.glueType = glueType;
  178. 	}
  180. 	public String getGlueSource() {
  181. 		return glueSource;
  182. 	}
  184. 	public void setGlueSource(String glueSource) {
  185. 		this.glueSource = glueSource;
  186. 	}
  188. 	public String getGlueRemark() {
  189. 		return glueRemark;
  190. 	}
  192. 	public void setGlueRemark(String glueRemark) {
  193. 		this.glueRemark = glueRemark;
  194. 	}
  196. 	public Date getGlueUpdatetime() {
  197. 		return glueUpdatetime;
  198. 	}
  200. 	public void setGlueUpdatetime(Date glueUpdatetime) {
  201. 		this.glueUpdatetime = glueUpdatetime;
  202. 	}
  204. 	public String getChildJobId() {
  205. 		return childJobId;
  206. 	}
  208. 	public void setChildJobId(String childJobId) {
  209. 		this.childJobId = childJobId;
  210. 	}
  212. 	public int getTriggerStatus() {
  213. 		return triggerStatus;
  214. 	}
  216. 	public void setTriggerStatus(int triggerStatus) {
  217. 		this.triggerStatus = triggerStatus;
  218. 	}
  220. 	public long getTriggerLastTime() {
  221. 		return triggerLastTime;
  222. 	}
  224. 	public void setTriggerLastTime(long triggerLastTime) {
  225. 		this.triggerLastTime = triggerLastTime;
  226. 	}
  228. 	public long getTriggerNextTime() {
  229. 		return triggerNextTime;
  230. 	}
  232. 	public void setTriggerNextTime(long triggerNextTime) {
  233. 		this.triggerNextTime = triggerNextTime;
  234. 	}
  235. }

XxlJobUtil.java 

  1. import com.alibaba.fastjson.JSONObject;
  2. import org.apache.commons.httpclient.*;
  3. import org.apache.commons.httpclient.methods.GetMethod;
  4. import org.apache.commons.httpclient.methods.PostMethod;
  5. import org.apache.commons.httpclient.methods.RequestEntity;
  6. import org.apache.commons.httpclient.methods.StringRequestEntity;
  8. import java.io.BufferedReader;
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.InputStreamReader;
  13. /**
  14.  * @Author: JCccc
  15.  * @Date: 2022-6-22 9:51
  16.  * @Description:
  17.  */
  18. public class XxlJobUtil {
  19.     private static String cookie="";
  21.     /**
  22.      * 查询现有的任务（可以关注这个整个调用链，可以自己模仿着写其他的拓展接口）
  23.      * @param url
  24.      * @param requestInfo
  25.      * @return
  26.      * @throws HttpException
  27.      * @throws IOException
  28.      */
  29.     public static JSONObject pageList(String url,JSONObject requestInfo) throws HttpException, IOException {
  30.         String path = "/api/jobinfo/pageList";
  31.         String targetUrl = url + path;
  32.         HttpClient httpClient = new HttpClient();
  33.         PostMethod post = new PostMethod(targetUrl);
  34.         post.setRequestHeader("cookie", cookie);
  35.         RequestEntity requestEntity = new StringRequestEntity(requestInfo.toString(), "application/json", "utf-8");
  36.         post.setRequestEntity(requestEntity);
  37.         httpClient.executeMethod(post);
  38.         JSONObject result = new JSONObject();
  39.         result = getJsonObject(post, result);
  40.         System.out.println(result.toJSONString());
  41.         return result;
  42.     }
  45.     /**
  46.      * 新增/编辑任务
  47.      * @param url
  48.      * @param requestInfo
  49.      * @return
  50.      * @throws HttpException
  51.      * @throws IOException
  52.      */
  53.     public static JSONObject addJob(String url,JSONObject requestInfo) throws HttpException, IOException {
  54.         String path = "/api/jobinfo/save";
  55.         String targetUrl = url + path;
  56.         HttpClient httpClient = new HttpClient();
  57.         PostMethod post = new PostMethod(targetUrl);
  58.         post.setRequestHeader("cookie", cookie);
  59.         RequestEntity requestEntity = new StringRequestEntity(requestInfo.toString(), "application/json", "utf-8");
  60.         post.setRequestEntity(requestEntity);
  61.         httpClient.executeMethod(post);
  62.         JSONObject result = new JSONObject();
  63.         result = getJsonObject(post, result);
  64.         System.out.println(result.toJSONString());
  65.         return result;
  66.     }
  68.     /**
  69.      * 删除任务
  70.      * @param url
  71.      * @param id
  72.      * @return
  73.      * @throws HttpException
  74.      * @throws IOException
  75.      */
  76.     public static JSONObject deleteJob(String url,int id) throws HttpException, IOException {
  77.         String path = "/api/jobinfo/delete?id="+id;
  78.         return doGet(url,path);
  79.     }
  81.     /**
  82.      * 开始任务
  83.      * @param url
  84.      * @param id
  85.      * @return
  86.      * @throws HttpException
  87.      * @throws IOException
  88.      */
  89.     public static JSONObject startJob(String url,int id) throws HttpException, IOException {
  90.         String path = "/api/jobinfo/start?id="+id;
  91.         return doGet(url,path);
  92.     }
  94.     /**
  95.      * 停止任务
  96.      * @param url
  97.      * @param id
  98.      * @return
  99.      * @throws HttpException
  100.      * @throws IOException
  101.      */
  102.     public static JSONObject stopJob(String url,int id) throws HttpException, IOException {
  103.         String path = "/api/jobinfo/stop?id="+id;
  104.         return doGet(url,path);
  105.     }
  107.     public static JSONObject doGet(String url,String path) throws HttpException, IOException {
  108.         String targetUrl = url + path;
  109.         HttpClient httpClient = new HttpClient();
  110.         HttpMethod get = new GetMethod(targetUrl);
  111.         get.setRequestHeader("cookie", cookie);
  112.         httpClient.executeMethod(get);
  113.         JSONObject result = new JSONObject();
  114.         result = getJsonObject(get, result);
  115.         return result;
  116.     }
  118.     private static JSONObject getJsonObject(HttpMethod postMethod, JSONObject result) throws IOException {
  119.         if (postMethod.getStatusCode() == HttpStatus.SC_OK) {
  120.             InputStream inputStream = postMethod.getResponseBodyAsStream();
  121.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
  122.             StringBuffer stringBuffer = new StringBuffer();
  123.             String str;
  124.             while((str = br.readLine()) != null){
  125.                 stringBuffer.append(str);
  126.             }
  127.             String response = new String(stringBuffer);
  128.             br.close();
  130.             return (JSONObject) JSONObject.parse(response);
  131.         } else {
  132.             return null;
  133.         }
  135.     }
  137.     /**
  138.      * 登录
  139.      * @param url
  140.      * @param userName
  141.      * @param password
  142.      * @return
  143.      * @throws HttpException
  144.      * @throws IOException
  145.      */
  147.     public static String login(String url, String userName, String password) throws HttpException, IOException {
  148.         String path = "/api/jobinfo/login?userName="+userName+"&password="+password;
  149.         String targetUrl = url + path;
  150.         HttpClient httpClient = new HttpClient();
  151.         HttpMethod get = new GetMethod((targetUrl));
  152.         httpClient.executeMethod(get);
  153.         if (get.getStatusCode() == 200) {
  154.             Cookie[] cookies = httpClient.getState().getCookies();
  155.             StringBuffer tmpcookies = new StringBuffer();
  156.             for (Cookie c : cookies) {
  157.                 tmpcookies.append(c.toString() + ";");
  158.             }
  159.             cookie = tmpcookies.toString();
  160.         } else {
  161.             try {
  162.                 cookie = "";
  163.             } catch (Exception e) {
  164.                 cookie="";
  165.             }
  166.         }
  167.         return cookie;
  168.     }
  169. }

XxlJobController.java

（用于模拟触发我们的任务创建、编辑、删除、停止等等）

  1. import java.util.Date;
  2. import com.alibaba.fastjson.JSONObject;
  3. import org.springframework.web.bind.annotation.*;
  4. import java.io.IOException;
  6. /**
  7.  * @Author: JCccc
  8.  * @Date: 2022-6-22 9:26
  9.  * @Description:
  10.  */
  11. @RestController
  12. public class XxlJobController {
  14.     @RequestMapping(value = "/pageList",method = RequestMethod.GET)
  15.     public Object pageList() throws IOException {
  16.         //int jobGroup, int triggerStatus, String jobDesc, String executorHandler, String author
  17.         JSONObject test=new JSONObject();
  18.         test.put("length",10);
  19.         XxlJobUtil.login("http://127.0.0.1:8961/xxl-job-admin","admin","123456");
  20.         JSONObject response = XxlJobUtil.pageList("http://127.0.0.1:8961/xxl-job-admin", test);
  21.         return  response.get("data");
  22.     }
  24.     @RequestMapping(value = "/add",method = RequestMethod.GET)
  25.     public void add() throws IOException {
  26.         XxlJobInfo xxlJobInfo=new XxlJobInfo();
  27.         xxlJobInfo.setJobCron("0/5 * * * * ?");
  28.         xxlJobInfo.setJobGroup(3);
  29.         xxlJobInfo.setJobDesc("我来试试");
  30.         xxlJobInfo.setAddTime(new Date());
  31.         xxlJobInfo.setUpdateTime(new Date());
  32.         xxlJobInfo.setAuthor("JCccc");
  33.         xxlJobInfo.setAlarmEmail("864477182@com");
  34.         xxlJobInfo.setScheduleType("CRON");
  35.         xxlJobInfo.setScheduleConf("0/5 * * * * ?");
  36.         xxlJobInfo.setMisfireStrategy("DO_NOTHING");
  37.         xxlJobInfo.setExecutorRouteStrategy("FIRST");
  38.         xxlJobInfo.setExecutorHandler("clockInJobHandler");
  39.         xxlJobInfo.setExecutorParam("att");
  40.         xxlJobInfo.setExecutorBlockStrategy("SERIAL_EXECUTION");
  41.         xxlJobInfo.setExecutorTimeout(0);
  42.         xxlJobInfo.setExecutorFailRetryCount(1);
  43.         xxlJobInfo.setGlueType("BEAN");
  44.         xxlJobInfo.setGlueSource("");
  45.         xxlJobInfo.setGlueRemark("GLUE代码初始化");
  46.         xxlJobInfo.setGlueUpdatetime(new Date());
  47.         JSONObject test = (JSONObject) JSONObject.toJSON(xxlJobInfo);
  48.         XxlJobUtil.login("http://127.0.0.1:8961/xxl-job-admin","admin","123456");
  49.         JSONObject response = XxlJobUtil.addJob("http://127.0.0.1:8961/xxl-job-admin", test);
  50.         if (response.containsKey("code") && 200 == (Integer) response.get("code")) {
  51.             System.out.println("新增成功");
  52.         } else {
  53.             System.out.println("新增失败");
  54.         }
  56.     }
  58.     @RequestMapping(value = "/stop/{jobId}",method = RequestMethod.GET)
  59.     public void stop(@PathVariable("jobId") Integer jobId) throws IOException {
  61.         XxlJobUtil.login("http://127.0.0.1:8961/xxl-job-admin","admin","123456");
  62.         JSONObject response = XxlJobUtil.stopJob("http://127.0.0.1:8961/xxl-job-admin", jobId);
  63.         if (response.containsKey("code") && 200 == (Integer) response.get("code")) {
  64.             System.out.println("任务停止成功");
  65.         } else {
  66.             System.out.println("任务停止失败");
  67.         }
  68.     }
  70.     @RequestMapping(value = "/delete/{jobId}",method = RequestMethod.GET)
  71.     public void delete(@PathVariable("jobId") Integer jobId) throws IOException {
  73.         XxlJobUtil.login("http://127.0.0.1:8961/xxl-job-admin","admin","123456");
  74.         JSONObject response = XxlJobUtil.deleteJob("http://127.0.0.1:8961/xxl-job-admin", jobId);
  75.         if (response.containsKey("code") && 200 == (Integer) response.get("code")) {
  76.             System.out.println("任务移除成功");
  77.         } else {
  78.             System.out.println("任务移除失败");
  79.         }
  80.     }
  82.     @RequestMapping(value = "/start/{jobId}",method = RequestMethod.GET)
  83.     public void start(@PathVariable("jobId") Integer jobId) throws IOException {
  85.         XxlJobUtil.login("http://127.0.0.1:8961/xxl-job-admin","admin","123456");
  86.         JSONObject response = XxlJobUtil.startJob("http://127.0.0.1:8961/xxl-job-admin", jobId);
  87.         if (response.containsKey("code") && 200 == (Integer) response.get("code")) {
  88.             System.out.println("任务启动成功");
  89.         } else {
  90.             System.out.println("任务启动失败");
  91.         }
  92.     }
  93.     
  94. }

开始验证测试

创建任务：

打开admin的HTML页面，这是原来上次我们手动创建的任务：

现在我们通过api调用创建一个新的任务：

调用接口后，可以看的任务创建出来了，按照我们的cron和其他调度规则开始跑了：

然后我们调用停止任务接口（通过任务ID停止）：

停在成功：

那么玩到这，可能大伙会有疑问，我怎么知道哪个我要停止的任务的任务ID是哪个？

所以我抛砖引玉写了个查询列表接口，大家可以意会一下，数据都在的，数据还不好拓展么，什么业务场景，怎么使用怎么调度，都可以自由发挥啊：

数据就在库里，自己查不就好了：

剩下还有启动 start接口，删除delete接口，修改update接口，我就不一一展示测试了。

这些增删改查，怎么组合使用，什么业务使用，大家自己玩起来就行。

好吧，该篇就到这。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_35387940/article/details/125410895

内容来源于网络，如有侵权，请联系作者删除！

JavaspringbootApixxljob定时任务动态调度

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com