xxl-job对外接口（新增、编辑、删除、挂起任务）

最新推荐文章于 2024-01-26 21:07:23 发布
最新推荐文章于 2024-01-26 21:07:23 发布
阅读量2.3w 收藏 50
点赞数 9
分类专栏： XXL-JOB学习笔记 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37527542/article/details/104468785
版权

1.前言

由于xxl-job提供了图形化界面添加任务，所有针对业务系统如果是固定时间需要调度任务时，则可以用通过这种图形化界面方式添加，但是有些业务系统需要根据自己的业务去创建任务，这样图形化的添加方式就不满足使用了，所以需要提供对外接口供业务系统调用，例如新增，编辑，删除，挂起。下面就是操作过程。

2.编写对外接口

  1. 由于xxl-job-admin调用中心里面的接口都需要登录后携带cookie访问，所以需要业务系统先模拟登陆（掉登陆接口）获取到cookie值，然后再调用新增，编辑，删除，挂起接口的时候携带上cookie访问。具体操作如下：

2.编写对外接口

package com.xxl.job.admin.rest;

import com.xxl.job.admin.controller.annotation.PermissionLimit;
import com.xxl.job.admin.core.cron.CronExpression;
import com.xxl.job.admin.core.model.XxlJobInfo;
import com.xxl.job.admin.core.thread.JobScheduleHelper;
import com.xxl.job.admin.core.util.I18nUtil;
import com.xxl.job.admin.service.LoginService;
import com.xxl.job.admin.service.XxlJobService;
import com.xxl.job.core.biz.model.ReturnT;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.ParseException;
import java.util.Date;

/**
 * @Description TODO
 * @Author jiuwei
 * @Date Created in 下午8:13 2020/2/15
 * @Version 1.0
 */
@RestController
@RequestMapping("/api/jobinfo")
public class XxlJobAdminRestController {

    private static Logger logger = LoggerFactory.getLogger(XxlJobAdminRestController.class);

    @Autowired
    private XxlJobService xxlJobService;

    @Autowired
    private LoginService loginService;

    @RequestMapping(value = "/save",method = RequestMethod.POST)
    public ReturnT<String> add(@RequestBody(required = true)XxlJobInfo jobInfo) throws Exception {

        // next trigger time (5s后生效，避开预读周期)
        long nextTriggerTime = 0;
        try {
            Date nextValidTime = new CronExpression(jobInfo.getJobCron()).getNextValidTimeAfter(new Date(System.currentTimeMillis() + JobScheduleHelper.PRE_READ_MS));
            if (nextValidTime == null) {
                return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_never_fire"));
            }
            nextTriggerTime = nextValidTime.getTime();
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
            return new ReturnT<String>(ReturnT.FAIL_CODE, I18nUtil.getString("jobinfo_field_cron_unvalid")+" | "+ e.getMessage());
        }

        jobInfo.setTriggerStatus(1);
        jobInfo.setTriggerLastTime(0);
        jobInfo.setTriggerNextTime(nextTriggerTime);

        jobInfo.setUpdateTime(new Date());

        if(jobInfo.getId()==0){
            return xxlJobService.add(jobInfo);
        }else{
            return xxlJobService.update(jobInfo);
        }
    }

    @RequestMapping(value = "/delete",method = RequestMethod.GET)
    public ReturnT<String> delete(int id) {
       return xxlJobService.remove(id);
    }

    @RequestMapping(value = "/start",method = RequestMethod.GET)
    public ReturnT<String> start(int id) {
        return xxlJobService.start(id);
    }

    @RequestMapping(value = "/stop",method = RequestMethod.GET)
    public ReturnT<String> stop(int id) {
        return xxlJobService.stop(id);
    }

    @RequestMapping(value="login", method=RequestMethod.GET)
    @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;
        ReturnT<String> result= loginService.login(request, response, userName, password, ifRem);
        return result;
    }
}

3.编写HttpClient工具类

package com.xxl.job.executor.util;

import com.alibaba.dubbo.common.logger.Logger;
import com.alibaba.dubbo.common.logger.LoggerFactory;
import net.sf.json.JSONObject;
import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.apache.commons.httpclient.methods.StringRequestEntity;

import java.io.IOException;

/**
 * @Description TODO
 * @Author jiuwei
 * @Date Created in 下午8:13 2020/2/15
 * @Version 1.0
 */
public class ApiUtil {

	public static Logger logger =  LoggerFactory.getLogger(ApiUtil.class);

	private static String cookie="";

	/**
	 * 新增/编辑任务
	 * @param url
	 * @param requestInfo
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public static JSONObject addJob(String url,JSONObject requestInfo) throws HttpException, IOException {
		String path = "/api/jobinfo/save";
		String targetUrl = url + path;
		HttpClient httpClient = new HttpClient();
		PostMethod post = new PostMethod(targetUrl);
		RequestEntity requestEntity = new StringRequestEntity(requestInfo.toString(), "application/json", "utf-8");
		post.setRequestEntity(requestEntity);
		httpClient.executeMethod(post);
		JSONObject result = new JSONObject();
		result = getJsonObject(post, result);
		return result;
	}

	/**
	 * 删除任务
	 * @param url
	 * @param id
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public static JSONObject deleteJob(String url,int id) throws HttpException, IOException {
		String path = "/api/jobinfo/delete?id="+id;
		return doGet(url,path);
	}

	/**
	 * 开始任务
	 * @param url
	 * @param id
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public static JSONObject startJob(String url,int id) throws HttpException, IOException {
		String path = "/api/jobinfo/start?id="+id;
		return doGet(url,path);
	}

	/**
	 * 停止任务
	 * @param url
	 * @param id
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 */
	public static JSONObject stopJob(String url,int id) throws HttpException, IOException {
		String path = "/api/jobinfo/stop?id="+id;
		return doGet(url,path);
	}

	public static JSONObject doGet(String url,String path) throws HttpException, IOException {
		String targetUrl = url + path;
		HttpClient httpClient = new HttpClient();
		HttpMethod get = new GetMethod(targetUrl);
		get.setRequestHeader("cookie", cookie);
		httpClient.executeMethod(get);
		JSONObject result = new JSONObject();
		result = getJsonObject(get, result);
		return result;
	}

	private static JSONObject getJsonObject(HttpMethod get, JSONObject result) throws IOException {
		if (get.getStatusCode() == 200) {
			String responseBodyAsString = get.getResponseBodyAsString();
			result = JSONObject.fromObject(responseBodyAsString);
		} else {
			try {
				result = JSONObject.fromObject(get.getResponseBodyAsString());
			} catch (Exception e) {
				result.put("error", get.getResponseBodyAsString());
			}
		}
		return result;
	}


    public static String login(String url, String userName, String password) throws HttpException, IOException {
		String path = "/api/jobinfo/login?userName="+userName+"&password="+password;
		String targetUrl = url + path;
		HttpClient httpClient = new HttpClient();
		HttpMethod get = new GetMethod(targetUrl);
		httpClient.executeMethod(get);
		if (get.getStatusCode() == 200) {
			Cookie[] cookies = httpClient.getState().getCookies();
			StringBuffer tmpcookies = new StringBuffer();
			for (Cookie c : cookies) {
				tmpcookies.append(c.toString() + ";");
			}
			cookie = tmpcookies.toString();
		} else {
			try {
				cookie = "";
			} catch (Exception e) {
				cookie="";
			}
		}
		return cookie;
    }

}

4：编写测试接口

package com.xxl.job.executor.rest;

import com.xxl.job.executor.util.ApiUtil;
import net.sf.json.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import response.ResponseData;

import java.io.IOException;

/**
 * @Description TODO
 * @Author jiuwei
 * @Date Created in 下午8:13 2020/2/15
 * @Version 1.0
 */
@RestController
@RequestMapping("/taskDemo")
public class JobInfoRestResource {


	@Value("${xxl.job.admin.addresses}")
	private String adminAddresses;

	/**
	 * 添加任务
	 * @return
	 * @throws IOException
	 */
	@RequestMapping(value = "/add",method = RequestMethod.GET)
	public ResponseData add() throws IOException {
		JSONObject requestInfo = new JSONObject();
		requestInfo.put("jobGroup",1);
		requestInfo.put("jobDesc","我是任务");
		requestInfo.put("executorRouteStrategy","FIRST");
		requestInfo.put("cronGen_display","0 0/1 * * * ?");
		requestInfo.put("jobCron","0 0/1 * * * ?");
		requestInfo.put("glueType","BEAN");
		requestInfo.put("executorHandler","demoJobHandler");
		requestInfo.put("executorBlockStrategy","SERIAL_EXECUTION");
		requestInfo.put("executorTimeout",0);
		requestInfo.put("executorFailRetryCount",1);
		requestInfo.put("author","admin");
		requestInfo.put("alarmEmail","xxx@qq.com");
		requestInfo.put("executorParam","att");
		requestInfo.put("glueRemark","GLUE代码初始化");
		JSONObject response=ApiUtil.addJob(adminAddresses,requestInfo);
        if(response.containsKey("code")&&200==response.getInt("code")){
            return ResponseData.success();
        }else{
            return ResponseData.error("调用api接口失败！");
        }

	}

    /**
     * 删除任务
     * @param id
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/delete",method = RequestMethod.GET)
    public ResponseData delete(int id) throws IOException {
        JSONObject response=ApiUtil.deleteJob(adminAddresses,id);
        if(response.containsKey("code")&&200==response.getInt("code")){
            return ResponseData.success();
        }else{
            return ResponseData.error("调用api接口失败！");
        }

    }

    /**
     * 开始任务
     * @param id
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/start",method = RequestMethod.GET)
    public ResponseData start(int id) throws IOException {
        JSONObject response=ApiUtil.startJob(adminAddresses,id);
        if(response.containsKey("code")&&200==response.getInt("code")){
            return ResponseData.success();
        }else{
            return ResponseData.error("调用api接口失败！");
        }

    }

    /**
     * 挂起任务
     * @param id
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/stop",method = RequestMethod.GET)
    public ResponseData stop(int id) throws IOException {
        JSONObject response=ApiUtil.stopJob(adminAddresses,id);
        if(response.containsKey("code")&&200==response.getInt("code")){
            return ResponseData.success();
        }else{
            return ResponseData.error("调用api接口失败！");
        }

    }

    /**
     * 登陆
     * @param userName
     * @param password
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/login",method = RequestMethod.GET)
    public ResponseData login(String userName,String password) throws IOException {
        String cookie=ApiUtil.login(adminAddresses,userName,password);
        if(StringUtils.isNotBlank(cookie)){
            return ResponseData.success(cookie);
        }else{
            return ResponseData.error("调用api接口失败！");
        }

    }


	
}

5.封装返回实体类

package response;

/**
 * 请求失败的返回
 *
 */
public class ErrorResponseData<T> extends ResponseData<T> {
	/**
	 * 异常的具体类名称
	 */
	private String exceptionClazz;

	public ErrorResponseData(String message) {
		super(false, ResponseData.DEFAULT_ERROR_CODE, message, null);
	}

	public ErrorResponseData(Integer code, String message) {
		super(false, code, message, null);
	}

	public ErrorResponseData(Integer code, String message, String exceptionClazz) {
		super(false, code, message, null);
		this.exceptionClazz = exceptionClazz;
	}

	public ErrorResponseData(Integer code, String message, T object) {
		super(false, code, message, object);
	}

	public ErrorResponseData(Integer code, String message, T object, String exceptionClazz) {
		super(false, code, message, object);
		this.exceptionClazz = exceptionClazz;
	}

	public String getExceptionClazz() {
		return exceptionClazz;
	}

	public void setExceptionClazz(String exceptionClazz) {
		this.exceptionClazz = exceptionClazz;
	}

}

package response;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;

/**
 * 返回给前台的通用包装
 * 
 */
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class ResponseData<T> {

	public static final String DEFAULT_SUCCESS_MESSAGE = "请求成功";

	public static final String DEFAULT_ERROR_MESSAGE = "网络异常";

	public static final Integer DEFAULT_SUCCESS_CODE = 0;

	public static final Integer DEFAULT_ERROR_CODE = 500;

	/**
	 * 请求是否成功
	 */
	private Boolean success;

	/**
	 * 响应状态码
	 */
	private Integer errcode;

	/**
	 * 响应信息
	 */
	private String errmessage;

	/**
	 * 响应对象
	 */
	private T data;

	public ResponseData() {
	}

	public ResponseData(Boolean success, Integer code, String message, T data) {
		this.success = success;
		this.errcode = code;
		this.errmessage = message;
		this.data = data;
	}

	public static SuccessResponseData<?> success() {
		return new SuccessResponseData<>();
	}

	public static <T> SuccessResponseData<T> success(T object) {
		return new SuccessResponseData<T>(object);
	}

	public static <T> SuccessResponseData<T> success(Integer code, String message, T object) {
		return new SuccessResponseData<T>(code, message, object);
	}

	public static ErrorResponseData<?> error(String message) {
		return new ErrorResponseData<>(message);
	}

	public static ErrorResponseData<?> error(Integer code, String message) {
		return new ErrorResponseData<>(code, message);
	}

	public static <T> ErrorResponseData<T> error(Integer code, String message, T object) {
		return new ErrorResponseData<T>(code, message, object);
	}

	public Boolean getSuccess() {
		return success;
	}

	public void setSuccess(Boolean success) {
		this.success = success;
	}

	public Integer getErrcode() {
		return errcode;
	}

	public void setErrcode(Integer errcode) {
		this.errcode = errcode;
	}

	public String getErrmessage() {
		return errmessage;
	}

	public void setErrmessage(String errmessage) {
		this.errmessage = errmessage;
	}

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}

}

package response;

/**
 * 请求成功的返回
 *
 */
public class SuccessResponseData<T> extends ResponseData<T> {

	public SuccessResponseData() {
		super(true, DEFAULT_SUCCESS_CODE, DEFAULT_SUCCESS_MESSAGE, null);
	}

	public SuccessResponseData(T object) {
		super(true, DEFAULT_SUCCESS_CODE, DEFAULT_SUCCESS_MESSAGE, object);
	}

	public SuccessResponseData(Integer code, String message, T object) {
		super(true, code, message, object);
	}

}

到此，对外新增/编辑，删除，挂起等接口就已经写好了。

留一手wjw
关注
  • 9
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
分布式任务调度平台XXL-JOB（Oracle版）
07-14
这里分享自己已经跑起来的Oracle版本分布式任务调度平台XXL-JOB资源。 官方只有Mysql版本的DEMO，由于近期单位项目需要，将原来DEMO稍作修改后改成了oracle版本，主要修改工作包括修改配置文件，数据库连接方式，pom中引入ojdbc7的jar包等。 使用步骤： 1/ 代码使用时首先打开下载好的压缩包解压，找到文件xxl-job-mysql-oracle-master\doc\db\tables_xxl_job_oralce.sql，并在PLSQL中生成; 2/ 之后在IDEA中打开项目，设置下maven环境，打开xxl-job-admin模块里面的application.properties 配置自己的oracle数据库; 3/ 完成后直接启动项目，启动完成后直接打开浏览器输入：http://127.0.0.1:8088/xxl-job-admin，如能正确加载任务调度网页则证明已正确配置。
【xxl-job】使用restful api的方式管理任务（动态创建/编辑/删除/启停任务）
大胡子老哥的博客
05-30 2501
xxl-job 动态添加和管理任务
xxl-job之API的方式接入
最新发布
上善若泪
01-26 1427
xxl-job是一款非常优秀的任务调度中间件，轻量级、使用简单、支持分布式等优点，让它广泛应用在我们的项目中，解决了不少定时任务的调度问题。我们都知道，在使用过程中需要先到xxl-job的任务调度中心页面上，配置执行器executor和具体的任务job，这一过程如果项目中的定时任务数量不多还好说，如果任务多了的话还是挺费工夫的。
xxl-job：分布式任务调度框架。（分布式任务调度平台XXL-JOB）
02-04
XXL作业 XXL-JOB，一个分布式任务调度框架。 介绍 XXL-JOB是一个分布式任务调度框架。 它的核心设计目标是快速发展，学习简单，轻巧且易于扩展的内容。 现在，它已经是开源的，许多公司在生产环境中使用它，真正的“开箱即用”。 XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发Swift，学习简单，轻量级，易扩展。更换开放源代码并连接到公司线上产品线，开箱即用。 文献资料 通讯 产品特点 1，简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手； 2，动态：支持动态修改任务状态，启动/停止任务，以及终止运行中任务，即时生效； 3，调度中心HA（中心式）
XXL-JOB分布式任务调度系统培训PPT
08-09
XXL-JOB分布式任务调度系统培训PPT
xxl-job:xxl-job二次开发 定时任务，增加API接口添加任务、删除任务等操作
05-16
XXL-JOB是一个轻量级分布式任务调度框架，其核心设计目标是开发Swift、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 Documentation 二次开发内容 1、数据库连接池修改为druid 2、添加job的 Restful 接口服务，实现通过接口调用添加job Features 1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手； 2、动态：支持动态修改任务状态、暂停/恢复任务，以及终止运行中任务，即时生效； 3、调度中心HA（中心式）：调度采用中心式设计，“调度中心”基于集群Quartz实现并支持集群部署，可保证调度中心HA； 4、执行器HA（分布式）：任务分布式执行，任务"执行器"支持集群部署，可保证任务执行HA； 5、注册中心: 执行器会周期性自动注册任务, 调度中心将会自动发现注册的任务并触发执行。同时，也支持手动录入
Springboot 整合 xxljob 动态API调度任务(进阶篇)
默默不代表沉默
06-22 8967
xxl job 动态调度
快速学习-XXL-JOB调度中心/执行器 RESTful API
逍遥云恋
09-23 5355
六、调度中心/执行器 RESTful API XXL-JOB 目标是一种跨平台、跨语言的任务调度规范和协议。 针对Java应用，可以直接通过官方提供的调度中心与执行器，方便快速的接入和使用调度中心，可以参考上文 “快速入门” 章节。 针对非Java应用，可借助 XXL-JOB 的标准 RESTful API 方便的实现多语言支持。 调度中心 RESTful API： 说明：调度中心提供给执行器使用的API；不局限于官方执行器使用，第三方可使用该API来实现执行器； API列表：执行器注册、任务结果回调等
任务调度中心xxl-job对外接口使用
LXYuuuuu的博客
07-23 7864
xxl-job主要分为调度中心和执行器提供了图像化界面，操作简单上手快，基本实现定时任务自动执行，同时可以针对任务日志进行查看。具体xxl-job可以再github上下载：https://github.com/xuxueli/xxl-job。 本文主要描述xxl-job的接口调用 pom.xml引入 <!--针对自己项目的xxl-job-core进行引入即可--> <dependency> <groupId>com.test</gro
xxl-job定时任务配置应用以及添加到自己已有的springboot项目中实现动态API调用
fannan521的博客
09-06 3959
XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。本篇文章主要是对xuxueli的xxl-job做一个简单的配置，以及将其添加到自己已有的项目中进行api调用。
xxl-job-admin.jar
04-17
xxl-job-admin.jar运行文件
xxl-job-core-2.3.0-API文档-中文版.zip
03-30
赠送jar包：xxl-job-core-2.3.0.jar 赠送原API文档：xxl-job-core-2.3.0-javadoc.jar 赠送源代码：xxl-job-core-2.3.0-sources.jar 包含翻译后的API文档：xxl-job-core-2.3.0-javadoc-API文档-中文(简体)版.zip 对应Maven信息：groupId：com.xuxueli，artifactId：xxl-job-core，version：2.3.0 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
xxl-job2.3.0集成nacos配置,注册中心
05-11
xxl-job2.3.0任务调度中心集成nacos配置,注册中心,xxl-job是一款开源的分布式任务调度框架
xxl-job-executor:与xxl-job-executor的集成
04-19
xxl-job-executor的gin中间件背景xxl-job-executor-go是xxl-job的golang执行器，可以独立运行，有时候我们要与项目或者框架（如:gin框架）集成起来合并为一个服务，本项目因此而生。执行器项目地址与gin集成示例...
分布式调度任务XXL-JOB架构图
02-11
分布式调度任务XXL-JOB架构图
任务调度系统之XXL-JOB分享.pptx
07-29
这个ppt是自己调研任务调度框架，最后选型xxl-job框架编写的。主要是对比了目前主流的几个调度系统框架，各自的优缺点等。最后主要介绍了xxl-job的功能特性、框架原理和注意事项。该ppt总计30页，适合学习和技术分享...
xxl-job-admin-2.4.1-SNAPSHOT之oracle版
10-09
xxl-job-admin-2.4.1-SNAPSHOT之oracle版
xxl-job-admin-spring-boot:将xuxueli的xxl-job-admin改造到spring boot框架，公司在用
04-28
xxl-job-admin-spring-boot简介xuxueli的xxl-job-admin默认为war包发布，需要放置到容器中，而spring boot “not war， just run jar！”的口号使我们早已习惯了java -jar 启动web服务的清爽简洁，因此我将xxl-job-...
xxl-job 定时任务
09-13
xxl-job是一个分布式任务调度框架，可以用于实现定时任务的调度和执行。在xxl-job中，定时任务的配置和管理主要涉及到三个部分：xxl-job-admin、执行器组件和定时任务的数据处理。 1. xxl-job-admin是xxl-job的管理后台，可以通过调用com.xxl.job.admin.controller.JobApiController.callback接口来设置定时任务。这个接口可以用于添加、修改、删除定时任务，以及启动、停止定时任务的执行。 2. 执行器组件是用于执行定时任务的组件，其中的配置文件地址为/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/core/config/XxlJobConfig.java。在这个配置文件中，你可以设置定时任务的一些参数，比如调度线程池大小、任务执行器等。 3. 定时任务的数据处理需要在xxl-job-executor-sample-springboot项目中进行，这是业务代码所在的项目。在这个项目中，你可以使用BEAN模式来设置定时任务。BEAN模式是指通过在类中定义方法并使用@XxlJob注解来标识定时任务，然后在XxlJobConfig.java配置文件中将这个类注册为定时任务。这种方式比较简单，但在官网上没有提供具体的示例。 所以，如果你想使用xxl-job来实现定时任务，你可以先在xxl-job-admin中设置定时任务，然后在执行器组件中配置定时任务的相关参数，最后在xxl-job-executor-sample-springboot项目中使用BEAN模式设置定时任务。这样就能够实现定时任务的调度和执行了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值