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

    前言

    之前写了一篇 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.*;
    14.  
    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;
    20.  
    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;
    34.  
    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) {
    48.  
    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.         }
    61.  
    62.         jobInfo.setTriggerStatus(1);
    63.         jobInfo.setTriggerLastTime(0);
    64.         jobInfo.setTriggerNextTime(nextTriggerTime);
    65.  
    66.         jobInfo.setUpdateTime(new Date());
    67.  
    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 {
    7.  
    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;
    15.  
    16. 	public int getStart() {
    17. 		return start;
    18. 	}
    19.  
    20. 	public void setStart(int start) {
    21. 		this.start = start;
    22. 	}
    23.  
    24. 	public int getLength() {
    25. 		return length;
    26. 	}
    27.  
    28. 	public void setLength(int length) {
    29. 		this.length = length;
    30. 	}
    31.  
    32. 	public int getTriggerStatus() {
    33. 		return triggerStatus;
    34. 	}
    35.  
    36. 	public void setTriggerStatus(int triggerStatus) {
    37. 		this.triggerStatus = triggerStatus;
    38. 	}
    39.  
    40. 	public String getJobDesc() {
    41. 		return jobDesc;
    42. 	}
    43.  
    44. 	public void setJobDesc(String jobDesc) {
    45. 		this.jobDesc = jobDesc;
    46. 	}
    47.  
    48. 	public String getExecutorHandler() {
    49. 		return executorHandler;
    50. 	}
    51.  
    52. 	public void setExecutorHandler(String executorHandler) {
    53. 		this.executorHandler = executorHandler;
    54. 	}
    55.  
    56. 	public String getAuthor() {
    57. 		return author;
    58. 	}
    59.  
    60. 	public void setAuthor(String author) {
    61. 		this.author = author;
    62. 	}
    63.  
    64. 	public int getJobGroup() {
    65. 		return jobGroup;
    66. 	}
    67.  
    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;
    2.  
    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;	// 下次调度时间
    35.  
    36. 	public String getJobCron() {
    37. 		return jobCron;
    38. 	}
    39.  
    40. 	public void setJobCron(String jobCron) {
    41. 		this.jobCron = jobCron;
    42. 	}
    43.  
    44. 	public int getId() {
    45. 		return id;
    46. 	}
    47.  
    48. 	public void setId(int id) {
    49. 		this.id = id;
    50. 	}
    51.  
    52. 	public int getJobGroup() {
    53. 		return jobGroup;
    54. 	}
    55.  
    56. 	public void setJobGroup(int jobGroup) {
    57. 		this.jobGroup = jobGroup;
    58. 	}
    59.  
    60. 	public String getJobDesc() {
    61. 		return jobDesc;
    62. 	}
    63.  
    64. 	public void setJobDesc(String jobDesc) {
    65. 		this.jobDesc = jobDesc;
    66. 	}
    67.  
    68. 	public Date getAddTime() {
    69. 		return addTime;
    70. 	}
    71.  
    72. 	public void setAddTime(Date addTime) {
    73. 		this.addTime = addTime;
    74. 	}
    75.  
    76. 	public Date getUpdateTime() {
    77. 		return updateTime;
    78. 	}
    79.  
    80. 	public void setUpdateTime(Date updateTime) {
    81. 		this.updateTime = updateTime;
    82. 	}
    83.  
    84. 	public String getAuthor() {
    85. 		return author;
    86. 	}
    87.  
    88. 	public void setAuthor(String author) {
    89. 		this.author = author;
    90. 	}
    91.  
    92. 	public String getAlarmEmail() {
    93. 		return alarmEmail;
    94. 	}
    95.  
    96. 	public void setAlarmEmail(String alarmEmail) {
    97. 		this.alarmEmail = alarmEmail;
    98. 	}
    99.  
    100. 	public String getScheduleType() {
    101. 		return scheduleType;
    102. 	}
    103.  
    104. 	public void setScheduleType(String scheduleType) {
    105. 		this.scheduleType = scheduleType;
    106. 	}
    107.  
    108. 	public String getScheduleConf() {
    109. 		return scheduleConf;
    110. 	}
    111.  
    112. 	public void setScheduleConf(String scheduleConf) {
    113. 		this.scheduleConf = scheduleConf;
    114. 	}
    115.  
    116. 	public String getMisfireStrategy() {
    117. 		return misfireStrategy;
    118. 	}
    119.  
    120. 	public void setMisfireStrategy(String misfireStrategy) {
    121. 		this.misfireStrategy = misfireStrategy;
    122. 	}
    123.  
    124. 	public String getExecutorRouteStrategy() {
    125. 		return executorRouteStrategy;
    126. 	}
    127.  
    128. 	public void setExecutorRouteStrategy(String executorRouteStrategy) {
    129. 		this.executorRouteStrategy = executorRouteStrategy;
    130. 	}
    131.  
    132. 	public String getExecutorHandler() {
    133. 		return executorHandler;
    134. 	}
    135.  
    136. 	public void setExecutorHandler(String executorHandler) {
    137. 		this.executorHandler = executorHandler;
    138. 	}
    139.  
    140. 	public String getExecutorParam() {
    141. 		return executorParam;
    142. 	}
    143.  
    144. 	public void setExecutorParam(String executorParam) {
    145. 		this.executorParam = executorParam;
    146. 	}
    147.  
    148. 	public String getExecutorBlockStrategy() {
    149. 		return executorBlockStrategy;
    150. 	}
    151.  
    152. 	public void setExecutorBlockStrategy(String executorBlockStrategy) {
    153. 		this.executorBlockStrategy = executorBlockStrategy;
    154. 	}
    155.  
    156. 	public int getExecutorTimeout() {
    157. 		return executorTimeout;
    158. 	}
    159.  
    160. 	public void setExecutorTimeout(int executorTimeout) {
    161. 		this.executorTimeout = executorTimeout;
    162. 	}
    163.  
    164. 	public int getExecutorFailRetryCount() {
    165. 		return executorFailRetryCount;
    166. 	}
    167.  
    168. 	public void setExecutorFailRetryCount(int executorFailRetryCount) {
    169. 		this.executorFailRetryCount = executorFailRetryCount;
    170. 	}
    171.  
    172. 	public String getGlueType() {
    173. 		return glueType;
    174. 	}
    175.  
    176. 	public void setGlueType(String glueType) {
    177. 		this.glueType = glueType;
    178. 	}
    179.  
    180. 	public String getGlueSource() {
    181. 		return glueSource;
    182. 	}
    183.  
    184. 	public void setGlueSource(String glueSource) {
    185. 		this.glueSource = glueSource;
    186. 	}
    187.  
    188. 	public String getGlueRemark() {
    189. 		return glueRemark;
    190. 	}
    191.  
    192. 	public void setGlueRemark(String glueRemark) {
    193. 		this.glueRemark = glueRemark;
    194. 	}
    195.  
    196. 	public Date getGlueUpdatetime() {
    197. 		return glueUpdatetime;
    198. 	}
    199.  
    200. 	public void setGlueUpdatetime(Date glueUpdatetime) {
    201. 		this.glueUpdatetime = glueUpdatetime;
    202. 	}
    203.  
    204. 	public String getChildJobId() {
    205. 		return childJobId;
    206. 	}
    207.  
    208. 	public void setChildJobId(String childJobId) {
    209. 		this.childJobId = childJobId;
    210. 	}
    211.  
    212. 	public int getTriggerStatus() {
    213. 		return triggerStatus;
    214. 	}
    215.  
    216. 	public void setTriggerStatus(int triggerStatus) {
    217. 		this.triggerStatus = triggerStatus;
    218. 	}
    219.  
    220. 	public long getTriggerLastTime() {
    221. 		return triggerLastTime;
    222. 	}
    223.  
    224. 	public void setTriggerLastTime(long triggerLastTime) {
    225. 		this.triggerLastTime = triggerLastTime;
    226. 	}
    227.  
    228. 	public long getTriggerNextTime() {
    229. 		return triggerNextTime;
    230. 	}
    231.  
    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;
    7.  
    8. import java.io.BufferedReader;
    9. import java.io.IOException;
    10. import java.io.InputStream;
    11. import java.io.InputStreamReader;
    12.  
    13. /**
    14.  * @Author: JCccc
    15.  * @Date: 2022-6-22 9:51
    16.  * @Description:
    17.  */
    18. public class XxlJobUtil {
    19.     private static String cookie="";
    20.  
    21.  
    22.     /**
    23.      * 查询现有的任务（可以关注这个整个调用链，可以自己模仿着写其他的拓展接口）
    24.      * @param url
    25.      * @param requestInfo
    26.      * @return
    27.      * @throws HttpException
    28.      * @throws IOException
    29.      */
    30.     public static JSONObject pageList(String url,JSONObject requestInfo) throws HttpException, IOException {
    31.         String path = "/api/jobinfo/pageList";
    32.         String targetUrl = url + path;
    33.         HttpClient httpClient = new HttpClient();
    34.         PostMethod post = new PostMethod(targetUrl);
    35.         post.setRequestHeader("cookie", cookie);
    36.         RequestEntity requestEntity = new StringRequestEntity(requestInfo.toString(), "application/json", "utf-8");
    37.         post.setRequestEntity(requestEntity);
    38.         httpClient.executeMethod(post);
    39.         JSONObject result = new JSONObject();
    40.         result = getJsonObject(post, result);
    41.         System.out.println(result.toJSONString());
    42.         return result;
    43.     }
    44.  
    45.  
    46.  
    47.     /**
    48.      * 新增/编辑任务
    49.      * @param url
    50.      * @param requestInfo
    51.      * @return
    52.      * @throws HttpException
    53.      * @throws IOException
    54.      */
    55.     public static JSONObject addJob(String url,JSONObject requestInfo) throws HttpException, IOException {
    56.         String path = "/api/jobinfo/save";
    57.         String targetUrl = url + path;
    58.         HttpClient httpClient = new HttpClient();
    59.         PostMethod post = new PostMethod(targetUrl);
    60.         post.setRequestHeader("cookie", cookie);
    61.         RequestEntity requestEntity = new StringRequestEntity(requestInfo.toString(), "application/json", "utf-8");
    62.         post.setRequestEntity(requestEntity);
    63.         httpClient.executeMethod(post);
    64.         JSONObject result = new JSONObject();
    65.         result = getJsonObject(post, result);
    66.         System.out.println(result.toJSONString());
    67.         return result;
    68.     }
    69.  
    70.     /**
    71.      * 删除任务
    72.      * @param url
    73.      * @param id
    74.      * @return
    75.      * @throws HttpException
    76.      * @throws IOException
    77.      */
    78.     public static JSONObject deleteJob(String url,int id) throws HttpException, IOException {
    79.         String path = "/api/jobinfo/delete?id="+id;
    80.         return doGet(url,path);
    81.     }
    82.  
    83.     /**
    84.      * 开始任务
    85.      * @param url
    86.      * @param id
    87.      * @return
    88.      * @throws HttpException
    89.      * @throws IOException
    90.      */
    91.     public static JSONObject startJob(String url,int id) throws HttpException, IOException {
    92.         String path = "/api/jobinfo/start?id="+id;
    93.         return doGet(url,path);
    94.     }
    95.  
    96.     /**
    97.      * 停止任务
    98.      * @param url
    99.      * @param id
    100.      * @return
    101.      * @throws HttpException
    102.      * @throws IOException
    103.      */
    104.     public static JSONObject stopJob(String url,int id) throws HttpException, IOException {
    105.         String path = "/api/jobinfo/stop?id="+id;
    106.         return doGet(url,path);
    107.     }
    108.  
    109.     public static JSONObject doGet(String url,String path) throws HttpException, IOException {
    110.         String targetUrl = url + path;
    111.         HttpClient httpClient = new HttpClient();
    112.         HttpMethod get = new GetMethod(targetUrl);
    113.         get.setRequestHeader("cookie", cookie);
    114.         httpClient.executeMethod(get);
    115.         JSONObject result = new JSONObject();
    116.         result = getJsonObject(get, result);
    117.         return result;
    118.     }
    119.  
    120.     private static JSONObject getJsonObject(HttpMethod postMethod, JSONObject result) throws IOException {
    121.         if (postMethod.getStatusCode() == HttpStatus.SC_OK) {
    122.             InputStream inputStream = postMethod.getResponseBodyAsStream();
    123.             BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
    124.             StringBuffer stringBuffer = new StringBuffer();
    125.             String str;
    126.             while((str = br.readLine()) != null){
    127.                 stringBuffer.append(str);
    128.             }
    129.             String response = new String(stringBuffer);
    130.             br.close();
    131.  
    132.             return (JSONObject) JSONObject.parse(response);
    133.         } else {
    134.             return null;
    135.         }
    136.  
    137.  
    138.     }
    139.  
    140.     /**
    141.      * 登录
    142.      * @param url
    143.      * @param userName
    144.      * @param password
    145.      * @return
    146.      * @throws HttpException
    147.      * @throws IOException
    148.      */
    149.  
    150.     public static String login(String url, String userName, String password) throws HttpException, IOException {
    151.         String path = "/api/jobinfo/login?userName="+userName+"&password="+password;
    152.         String targetUrl = url + path;
    153.         HttpClient httpClient = new HttpClient();
    154.         HttpMethod get = new GetMethod((targetUrl));
    155.         httpClient.executeMethod(get);
    156.         if (get.getStatusCode() == 200) {
    157.             Cookie[] cookies = httpClient.getState().getCookies();
    158.             StringBuffer tmpcookies = new StringBuffer();
    159.             for (Cookie c : cookies) {
    160.                 tmpcookies.append(c.toString() + ";");
    161.             }
    162.             cookie = tmpcookies.toString();
    163.         } else {
    164.             try {
    165.                 cookie = "";
    166.             } catch (Exception e) {
    167.                 cookie="";
    168.             }
    169.         }
    170.         return cookie;
    171.     }
    172. }

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



    开始验证测试



    创建任务：

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

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

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

     

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

     

    停在成功：

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

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

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

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

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

    好吧，该篇就到这。

  • 相关阅读:
    xss盲打
    【SQL】新建库表时，报错attempt to write a readonly database
    【​毕业季·进击的技术er​】--毕业到工作小结
    Plink常见命令 --bfile --freq--recode --make-bed
    基于springboot实现民宿管理平台项目【项目源码+论文说明】计算机毕业设计
    RTOS 中 Task 之间资源共享示例
    transformer的理解
    Ubuntu扩容lvm空间
    【第6篇】AI语音测试简介
    如何找回回收站清空的文件?
  • 原文地址：https://blog.csdn.net/qq_35387940/article/details/125410895