springboot：通过http动态操作xxl-job任务

已于 2022-09-16 11:07:36 修改
阅读量2.1k 收藏 9
点赞数 1
分类专栏： springboot 文章标签： spring boot http okhttp
于 2022-08-03 09:34:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296313/article/details/126134145
版权

springboot：通过http动态操作xxl-job任务

一、maven依赖

        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.8.1</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.6.4</version>
        </dependency>

        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.2.0</version>
        </dependency>

		<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

二、配置文件

xxl:
  job:
    login:
      address: http://192.168.31.91:18080/xxl-job-admin
      username: admin
      password: 123456

三、xxl-job实体类

XxlJobActuatorManagerInfo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class XxlJobActuatorManagerInfo {

    private Integer recordsFiltered;
    private Integer recordsTotal;
    private List<XxlJobGroup> data;
}

XxlJobGroup

@Data
@NoArgsConstructor
@AllArgsConstructor
public class XxlJobGroup {

    private int id;
    private String appname;
    private String title;
    private int addressType;        // 执行器地址类型：0=自动注册、1=手动录入
    private String addressList;     // 执行器地址列表，多地址逗号分隔(手动录入)
    private Date updateTime;

    // 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;
    }
}

XxlJobInfo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class XxlJobInfo {
	
	private int id;				// 主键ID
	
	private int jobGroup;		// 执行器主键ID
	private String jobDesc;
	private String jobCron;		//corn表达式
	
	private Date addTime;
	private Date updateTime;
	
	private String author;		// 负责人
	private String alarmEmail;	// 报警邮件

	private String scheduleType;			// 调度类型
	private String scheduleConf;			// 调度配置，值含义取决于调度类型
	private String misfireStrategy;			// 调度过期策略

	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;	// 下次调度时间
}

XxlJobResponseInfo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class XxlJobResponseInfo {

    private Integer code;
    private String msg;
    private String content;
}

XxlJobTaskManagerInfo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class XxlJobTaskManagerInfo {

    private Integer recordsFiltered;
    private Integer recordsTotal;
    private List<XxlJobInfo> data;
}

四、工具类

HttpClientConfig

@Data
@NoArgsConstructor
@AllArgsConstructor
public class HttpClientConfig {

    private String url;
    private String username;
    private String password;
    private String oauthToken;
    private int connectionTimeout = 60000;
    private int requestTimeout = 60000;
    private int webSocketPingInterval;
    private int maxConcurrentRequestsPerHost = 30;
    private int maxConnection = 40;

    private String httpProxy;
    private String httpsProxy;
    private String proxyUsername;
    private String proxyPassword;
    private String userAgent;
    private TlsVersion[] tlsVersions = new TlsVersion[]{TLS_1_2};
    private String[] noProxy;

    public static final String HTTP_PROTOCOL_PREFIX = "http://";
    public static final String HTTPS_PROTOCOL_PREFIX = "https://";
    
}

HttpClientUtils

package com.mye.xxljobtest.util;

import okhttp3.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpMethod;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Proxy;
import java.net.URL;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static okhttp3.ConnectionSpec.CLEARTEXT;


public class HttpClientUtils {

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

    /**
     * json传输方式
     */
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    private static volatile OkHttpClient client;

    public static Headers doLoginRequest(HttpClientConfig config, Map<String, String> params) {
        try {
            OkHttpClient client = getInstance(config);
            FormBody.Builder builder = new FormBody.Builder();
            for (Map.Entry<String, String> param : params.entrySet()) {
                builder.add(param.getKey(), param.getValue());
            }
            FormBody formBody = builder.build();
            Request request = new Request.Builder().url(config.getUrl()).post(formBody).build();
            Response response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                System.out.println(JsonUtil.objectToJson(response));
                return response.headers();
            } else if (response.body() != null){
                return null;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String doFormRequest(HttpClientConfig config, Map<String, String> params, String cookie) {
        try {
            OkHttpClient client = getInstance(config);
            FormBody.Builder builder = new FormBody.Builder();
            for (Map.Entry<String, String> param : params.entrySet()) {
                builder.add(param.getKey(), param.getValue());
            }
            FormBody formBody = builder.build();
            Request request = new Request.Builder().url(config.getUrl()).header("Cookie", cookie).post(formBody).build();
            Response response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                System.out.println(JsonUtil.objectToJson(response));
                return response.body().string();
            } else if (response.body() != null){
                return response.body().string();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String doRequest(HttpClientConfig config, HttpMethod method, Map<String, String> headers, String body) {
        try {
            OkHttpClient client = getInstance(config);
            //创建请求
            RequestBody requestBody = RequestBody.create(JSON, StringUtils.isEmpty(body) ? "" : body);

            Request.Builder builder = new Request.Builder();
            if (!CollectionUtils.isEmpty(headers)) {
                logger.info("headers : " + headers);
                builder.headers(Headers.of(headers));
            }

            Request request = builder.method(method.name(), requestBody).url(config.getUrl()).build();

            Response response = client.newCall(request).execute();
            if (response.isSuccessful() && response.body() != null) {
                return response.body().string();
            } else if (response.body() != null){
                return response.body().string();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 双重检查单例
     * @param config OkHttpClient配置
     * @return okHttpClient
     */
    public static OkHttpClient getInstance(HttpClientConfig config) {
        if (client == null) {
            synchronized (OkHttpClient.class) {
                if (client == null) {
                    client = createHttpClient(config);
                }
            }
        }
        //拿到client之后把认证信息重新加一遍
        client.newBuilder().addInterceptor(chain -> {
            Request request = chain.request();
            if (StringUtils.hasText(config.getUsername()) && StringUtils.hasText(config.getPassword())) {
                Request authReq = chain.request().newBuilder().addHeader("Authorization", Credentials.basic(config.getUsername(), config.getPassword())).build();
                return chain.proceed(authReq);
            } else if (StringUtils.hasText( config.getOauthToken())) {
                Request authReq = chain.request().newBuilder().addHeader("Authorization", "Bearer " + config.getOauthToken()).build();
                return chain.proceed(authReq);
            }
            return chain.proceed(request);
        });
        return client;
    }

    private static OkHttpClient createHttpClient(final HttpClientConfig config) {
        try {
            OkHttpClient.Builder httpClientBuilder = new OkHttpClient.Builder();
            httpClientBuilder.followRedirects(true);
            httpClientBuilder.followSslRedirects(true);
            if (config.getConnectionTimeout() > 0) {
                httpClientBuilder.connectTimeout(config.getConnectionTimeout(), TimeUnit.MILLISECONDS);
            }
            if (config.getRequestTimeout() > 0) {
                httpClientBuilder.readTimeout(config.getRequestTimeout(), TimeUnit.MILLISECONDS);
            }
            if (config.getWebSocketPingInterval() > 0) {
                httpClientBuilder.pingInterval(config.getWebSocketPingInterval(), TimeUnit.MILLISECONDS);
            }
            if (config.getMaxConcurrentRequestsPerHost() > 0) {
                Dispatcher dispatcher = new Dispatcher();
                dispatcher.setMaxRequestsPerHost(config.getMaxConcurrentRequestsPerHost());
                httpClientBuilder.dispatcher(dispatcher);
            }
            if (config.getMaxConnection() > 0) {
                ConnectionPool connectionPool = new ConnectionPool(config.getMaxConnection(), 60, TimeUnit.SECONDS);
                httpClientBuilder.connectionPool(connectionPool);
            }
            // Only check proxy if it's a full URL with protocol
            if (config.getUrl().toLowerCase().startsWith(HttpClientConfig.HTTP_PROTOCOL_PREFIX) || config.getUrl().startsWith(HttpClientConfig.HTTPS_PROTOCOL_PREFIX)) {
                try {
                    URL proxyUrl = getProxyUrl(config);
                    if (proxyUrl != null) {
                        httpClientBuilder.proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyUrl.getHost(), proxyUrl.getPort())));
                        if (config.getProxyUsername() != null) {
                            httpClientBuilder.proxyAuthenticator((route, response) -> {
                                String credential = Credentials.basic(config.getProxyUsername(), config.getProxyPassword());
                                return response.request().newBuilder().header("Proxy-Authorization", credential).build();
                            });
                        }
                    }
                } catch (MalformedURLException e) {
                    throw new IllegalArgumentException("Invalid proxy server configuration", e);
                }
            }
            if (config.getUserAgent() != null && !config.getUserAgent().isEmpty()) {
                httpClientBuilder.addNetworkInterceptor(chain -> {
                    Request agent = chain.request().newBuilder().header("User-Agent", config.getUserAgent()).build();
                    return chain.proceed(agent);
                });
            }
            if (config.getTlsVersions() != null && config.getTlsVersions().length > 0) {
                ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
                        .tlsVersions(config.getTlsVersions())
                        .build();
                httpClientBuilder.connectionSpecs(Arrays.asList(spec, CLEARTEXT));
            }
            return httpClientBuilder.build();
        } catch (Exception e) {
            throw new IllegalArgumentException("创建OKHTTPClient错误", e);
        }
    }

    private static URL getProxyUrl(HttpClientConfig config) throws MalformedURLException {
        URL master = new URL(config.getUrl());
        String host = master.getHost();
        if (config.getNoProxy() != null) {
            for (String noProxy : config.getNoProxy()) {
                if (host.endsWith(noProxy)) {
                    return null;
                }
            }
        }
        String proxy = config.getHttpsProxy();
        String http = "http";
        if (http.equals(master.getProtocol())) {
            proxy = config.getHttpProxy();
        }
        if (proxy != null) {
            return new URL(proxy);
        }
        return null;
    }

}

XxlJobApiUtils

package com.mye.xxljobtest.util;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.mye.xxljobtest.jobcore.*;
import okhttp3.Headers;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * xxl-job api 操作工具类
 * @author hl
 * @date 2022/8/1 14:05
 */
@Component
public class XxlJobApiUtils {

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


    @Value("${xxl.job.login.address}")
    private String xxlJobLoginAddress;

    @Value("${xxl.job.login.username}")
    private String xxlJobLoginUserName;

    @Value("${xxl.job.login.password}")
    private String xxlJobLoginPassword;


    /**
     * 启动xxl-job任务管理
     * @param taskId 任务管理id
     */
    public void startTask(Integer taskId){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建参数
        Map<String, String> form = new HashMap<>();
        form.put("id", "" + taskId);

        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/start");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);

        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }
    }

    /**
     * 删除 xxl-job任务管理
     * @param id 任务id
     */
    public void deleteTask(Integer id){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建任务管理参数
        Map<String, String> form = new HashMap<>();
        form.put("id", id + "");


        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/remove");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);

        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);

        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }
    }

    /**
     * 编辑 xxl-job任务管理
     * @param xxlJobInfo 查询参数
     */
    public void editTask(XxlJobInfo xxlJobInfo){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建任务管理参数
        Map<String, String> form = new HashMap<>();
        form.put("id",xxlJobInfo.getId() + "");
        //注意这里需要先创建执行器，然后拿到执行器的id赋值给JobGroup
        form.put("jobGroup", xxlJobInfo.getJobGroup() + "");
        form.put("jobDesc", xxlJobInfo.getJobDesc());
        form.put("executorRouteStrategy", "ROUND");
        form.put("jobCron", xxlJobInfo.getJobCorn());
        form.put("glueType", "BEAN");
        form.put("executorHandler", xxlJobInfo.getExecutorHandler());
        form.put("executorBlockStrategy", "SERIAL_EXECUTION");
        form.put("author", "mye");


        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/update");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);

        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }
    }

    /**
     * 查询所有的task
     * @param xxlJobInfo
     * @return
     */
    public XxlJobTaskManagerInfo selectAllTask(XxlJobInfo xxlJobInfo) {
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建任务管理参数
        Map<String, String> form = new HashMap<>();
        form.put("jobGroup", xxlJobInfo.getJobGroup() + "");
        form.put("triggerStatus", "-1");


        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/pageList");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        return JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobTaskManagerInfo.class);
    }

    /**
     * 查询 xxl-job任务管理
     * @param xxlJobInfo 查询参数
     */
    public XxlJobTaskManagerInfo selectTask(XxlJobInfo xxlJobInfo){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建任务管理参数
        Map<String, String> form = new HashMap<>();
        form.put("jobGroup", xxlJobInfo.getJobGroup() + "");
        form.put("jobDesc", xxlJobInfo.getJobDesc());
        form.put("executorHandler", xxlJobInfo.getExecutorHandler());
        form.put("author", xxlJobInfo.getAuthor());
        form.put("triggerStatus", "-1");


        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/pageList");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        XxlJobTaskManagerInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobTaskManagerInfo.class);

        if (ObjectUtil.isNull(info) || CollectionUtil.isEmpty(info.getData())){
            logger.error("xxl-job任务管理不存在",new RuntimeException());
        }

        return info;
    }


    /**
     * 创建任务管理
     * @param xxlJobInfo 创建参数
     */
    public XxlJobResponseInfo createTask(XxlJobInfo xxlJobInfo){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建任务管理参数
        Map<String, String> form = new HashMap<>();

        form.put("jobGroup", xxlJobInfo.getJobGroup() + "");
        form.put("jobDesc", xxlJobInfo.getJobDesc());
        form.put("executorRouteStrategy", "ROUND");
        form.put("jobCron", xxlJobInfo.getJobCorn());
        form.put("glueType", "BEAN");
        form.put("executorHandler", xxlJobInfo.getExecutorHandler());
        form.put("executorBlockStrategy", "SERIAL_EXECUTION");
        form.put("author", "mye");


        //创建任务管理
        clientConfig.setUrl(xxlJobLoginAddress + "/jobinfo/add");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);

        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }

        return info;
    }

    /**
     * 删除执行器
     */
    public void deleteActuator(XxlJobGroup xxlJobGroup) {
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建查询执行器管理器参数
        Map<String, String> form = new HashMap<>();
        form.put("id", xxlJobGroup.getId() + "");

        //创建执行器管理器地址
        clientConfig.setUrl(xxlJobLoginAddress + "/jobgroup/remove");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);

        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);
        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()) {
            logger.error(info.getMsg(), new RuntimeException());
        }
    }


    /**
     * 编辑执行器
     */
    public void editActuator(XxlJobGroup xxlJobGroup){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建查询执行器管理器参数
        Map<String, String> form = new HashMap<>();
        form.put("appname", xxlJobGroup.getAppname());
        form.put("title", xxlJobGroup.getTitle());
        form.put("addressType", xxlJobGroup.getAddressType() + "");
        form.put("id", xxlJobGroup.getId() + "");

        //创建执行器管理器地址
        clientConfig.setUrl(xxlJobLoginAddress + "/jobgroup/update");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);

        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);
        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }
    }

    /**
     * 查询执行器 (appname 和 title 都是模糊查询)
     * @param xxlJobGroup XxlJobGroup
     * @return xxlJobGroup 集合
     */
    public List<XxlJobGroup> selectActuator(XxlJobGroup xxlJobGroup){
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建查询执行器管理器参数
        Map<String, String> form = new HashMap<>();
        form.put("appname", xxlJobGroup.getAppname());
        form.put("title", xxlJobGroup.getTitle());

        //创建执行器管理器地址
        clientConfig.setUrl(xxlJobLoginAddress + "/jobgroup/pageList");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);

        XxlJobActuatorManagerInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobActuatorManagerInfo.class);
        if (CollectionUtil.isEmpty(info.getData())){
            throw new RuntimeException("该执行器管理器不存在:" + xxlJobGroup.getAppname());
        }

        return info.getData();
    }


    /**
     * 创建执行器
     *
     * @param xxlJobGroup 创建参数
     */
    public XxlJobResponseInfo createActuator(XxlJobGroup xxlJobGroup) {
        //获取登录cookie
        HttpClientConfig clientConfig = new HttpClientConfig();
        String cookie = loginTaskCenter(clientConfig);

        //创建执行器管理器参数
        Map<String, String> form = new HashMap<>();
        form.put("appname", xxlJobGroup.getAppname());
        form.put("title", xxlJobGroup.getTitle());
        form.put("addressType", xxlJobGroup.getAddressType() + "");

        //创建执行器管理器地址
        clientConfig.setUrl(xxlJobLoginAddress + "/jobgroup/save");
        String result = HttpClientUtils.doFormRequest(clientConfig, form, cookie);
        XxlJobResponseInfo info = JSONUtil.toBean(JSONUtil.parseObj(result), XxlJobResponseInfo.class);

        if (ObjectUtil.isNull(info) || info.getCode() != HttpStatus.OK.value()){
            logger.error(info.getMsg(),new RuntimeException());
        }
        return info;
    }


    /**
     * 登录任务调度平台
     *
     * @param clientConfig clientConfig
     * @return cookie
     */
    public String loginTaskCenter(HttpClientConfig clientConfig) {
        Map<String, String> loginForm = new HashMap<>();
        clientConfig.setUrl(xxlJobLoginAddress + "/login");
        clientConfig.setUsername(xxlJobLoginUserName);
        clientConfig.setPassword(xxlJobLoginPassword);
        loginForm.put("userName", xxlJobLoginUserName);
        loginForm.put("password", xxlJobLoginPassword);
        Headers headers = HttpClientUtils.doLoginRequest(clientConfig, loginForm);
        assert headers != null;
        return headers.get("Set-Cookie");
    }
}
yololee_
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
xxl-job本地jar包
06-30
xxl-job，在页面管理定时任务，启动或者停止定时任务。本地程序启动时连接本地的xxl-job方便进行调试
SpringBoot工具篇--XXL-JOB 分布式任务调度平台
拾一二的博客
02-10 6260
XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。
springboot+xxl-job+httpclient实现服务端远程进行任务调度
最新发布
zy11517的博客
03-05 1076
定时任务是指在预定的时间间隔或特定时间点执行的任务或操作。这些任务通常用于自动化处理重复性、周期性的工作，减轻人工干预的负担，提高效率和准确性。最好的例子就是闹钟，你提前定好时间，他到了时间会自动触发。还有一种是根据时间间隔来的，依旧是闹钟，我第一次关闭之后，他会每隔10分钟后再启动。xxl-job是一个简单易上手的分布式任务调度框架，虽然本身不支持远程调用，但可以使用httpclient或者restTemple等远程连接工具进行连接。
分布式任务调度平台XXL-JOB应用.docx
05-20
springboot 接入分布式任务调度平台XXL-JOB应用
springboot集成xxl-job #资源达人分享计划#
08-05
这是springboot集成xxl-job案例，适合对分布定时任务感兴趣的开发者
xxl-job集成springboot实战代码
01-17
xxl-job集成springboot实战，xxl-job定时任务详解 博客地址：https://blog.csdn.net/qq_38105536/article/details/122544713
xxl-job的http任务和command任务
jasnet_u的博客
08-14 4527
在官方提供的sample示例代码中，还提供了两种特殊的bean类型的任务http (bean的名称为：httpJobHandler) 和command （bean的名称为：commandJobHandler）。 1、xxl-job的http任务 在控制台新增一个任务，选择运行模式为：bean，jobHandler的名称为：httpJobHandler ，调度类型：选择无或CRON均可。 执行时，填入相应执行参数即可，例如： url:http://tingcream.com/user_aboutU.
xxl-job动态传递参数
进行中
09-13 7466
xxl-job
spring boot调用xxl-job对外接口
lyt的博客
01-19 5642
pom文件 <dependency> <groupId>com.xuxueli</groupId> <artifactId>xxl-job-core</artifactId> <version>${xxl-job.version}</version> </dependency> <dependency> <groupId>commons-httpclien
springboot整合XXL-JOB实行动态定时任务
枯葉
05-13 3537
春才刚到，忽而夏至——南方 前言 定时任务，相信很多人都用过吧？方法无非就是那几种而已，也有很多人写出了各式各样的框架，比如XXL-JOB XXL-JOB出自大众点评，是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展、开箱即用 官方文档地址：点击此处访问官方文档 下载xxlJob 源码仓库地址： github地址 ，下载地址 gitee地址，下载地址 中央仓库地址： <!-- http://repo1.maven.org/maven2/com/xuxue
xxl-job架构篇 - 初识分布式任务调度xxl-job
The Secret
12-20 829
本文介绍XXL-JOB的相关知识。
xxl-job-admin:xxl-job-admin 任务调度平台 Spring Boot 版本[后台部分] ，统一改为rest接口
05-14
xxl-job-admin 任务调度服务(后台部分) 依赖更新 SpringBoot 1.5.6 JDK 1.8 Doc Blog 后台URL 任务管理 默认(/jobinfo) 搜索(/jobinfo/pageList) 新增任务-保存(/jobinfo/add) 执行(/jobinfo/trigger/{id}) 暂停(/jobinfo/pause/{id}) 日志(/joblog?jobId=) 编辑-保存(/jobinfo/reschedule) 删除(/jobinfo/remove/{id}) 调度日志 默认(/joblog) 搜索(/joblog/pageList) 清理(/joblog/clearLog) 执行器管理 默认(/jobgroup) 新增执行器(/jobgroup/save) 编辑-保存(/jobgroup/update) 删除(/jobgroup/remove/
XXL-Job动态添加任务
fajing_feiyue的博客
06-22 1万+
前言 最近项目中涉及到了定时任务相关需求，最终选择了分布式任务调度框架xxl-job，由于我们在使用xxl-job。这里对xxl-job 一些使用做一下简单介绍。 实践 xxl-job 主要分为一个展示web的独立服务，另外一个是我们项目引入xxl-job依赖，对定时任务做监听。这里不对xxl-job 部署独立服务做介绍，主要介绍如何引入xxl-job依赖进行创建定时任务。 一、配置yml # 定时任务中心配置信息 job: server: enabled: true # 校验令牌，和
xxl-job系列（3）- 几种任务调度形式
知秋的博客
12-22 3915
1 BEAN模式（类形式） Bean模式任务，支持基于类的开发方式，每个任务对应一个Java类。 优点：不限制项目环境，兼容性好。即使是无框架项目，如main方法直接启动的项目也可以提供支持，可以参考示例项目 “xxl-job-executor-sample-frameless”； 缺点： 每个任务需要占用一个Java类，造成类的浪费； 不支持自动扫描任务并注入到执行器容器，需要手动注入。 步骤一：执行器项目中，开发Job类： 1、开发一个继承自"com.xxl.job.core.handler.
自己项目使用http请求远程调用xxljob项目
一天不写代码难受的博客
09-30 770
http
学习笔记---分布式调度之xxlJob的调度任务源码分析
u014461495的博客
03-08 1061
在学习笔记—分布式调度之xxlJob执行器的启动源码解析以及学习笔记—分布式调度之xxlJob调度中心的启动源码解析中可以知道，执行器已经开始nettyServer时刻等待任务调度并且开启了后台线程时刻监视着回调队列是否有数据，有数据则立马执行http调用调度中心的对外暴露http接口，而调度中心也在后台开启了日志线程监视是否有失败执行日志，有则生成代理对象，并且打开nettyClient来走rp...
SpringBoot2 集成 xxl-job任务调度中心_参数传递
热门推荐
Gblfy_Blog
02-15 1万+
SpringBoot2 集成 xxl-job任务调度中心_参数传递
让定时任务 xxl job 里面的任务灵活起来
carl.zhao的专栏
06-30 1633
在项目当中使用定时任务进行业务补偿是一种很常见的需求。对于一个任务，我们常常把开始时间或者结束时间固定在代码里面。如果出现了定时任务漏掉了数据。比如： 定时任务：查询 1 天前到当前系统时间 遗漏的数据：在 3 天前有一些数据还没有执行完成 如果你没有把开始时间设置成动态变量这个问题就无法解决。你可以通过把开始时间配置在注册中心当中，查询时间就是：3天前 ~ 系统当前时间。这个 SQL 的查询系统就比较低下了。 还有一种方式就是开始时间与结束时间都设置成变量配置在注册中心当中，这样就可以动态定制你的任务
XXL-JOB详解（整合springboot）保姆级教程
gb4215287的博客
09-13 9532
XXL-JOB详解（整合springboot）保姆级教程
springboot单服务怎么使用xxl-job，详细
06-09
使用xxl-job来实现分布式任务调度可以分为以下几个步骤： 1. 集成xxl-job 在pom.xml文件中添加xxl-job-core依赖： ```xml <dependency> <groupId>com.xxl-job</groupId> <artifactId>xxl-job-core</artifactId> <version>2.3.0</version> </dependency> ``` 2. 配置xxl-job 在application.yml文件中添加xxl-job的配置： ```yaml xxl: job: # 调度中心配置 admin: addresses: http://localhost:8080/xxl-job-admin accessToken: # 执行器配置 executor: appname: executor-demo address: localhost:9999 ip: port: 9999 accessToken: logPath: /data/applogs/xxl-job/jobhandler logRetentionDays: 30 ``` 其中，调度中心地址为http://localhost:8080/xxl-job-admin，执行器地址为localhost:9999。 3. 创建任务 在Spring Boot应用中创建任务需要遵循以下规则： 1. 使用@XxlJob注解标注任务方法； 2. 方法必须是public修饰符、void返回类型、只有一个JobParameter参数； 3. 方法名称可以自定义，但是需要保证在同一个执行器中唯一。 示例代码如下： ```java @Service public class DemoJobHandler { @XxlJob("demoJobHandler") public void demoJobHandler(JobParameter param) throws Exception { // 业务逻辑 } } ``` 4. 启动任务执行器 在Spring Boot应用中启动任务执行器需要在启动类上添加@EnableXxlJob注解，并且实现XxlJobSpringExecutorConfigurer接口： ```java @SpringBootApplication @EnableXxlJob public class Application implements XxlJobSpringExecutorConfigurer { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Override public void configureXxlJobExecutor(XxlJobSpringExecutor executor) { executor.setAppname("executor-demo"); executor.setAddress("localhost:9999"); executor.setIp(null); executor.setPort(9999); executor.setLogPath("/data/applogs/xxl-job/jobhandler"); executor.setLogRetentionDays(30); } } ``` 5. 登录xxl-job调度中心 在浏览器中输入http://localhost:8080/xxl-job-admin，使用默认账号密码admin/123456登录xxl-job调度中心。 6. 创建任务 在xxl-job调度中心中创建任务，填写任务信息、执行器信息、调度策略和触发器信息，最后保存并启动任务即可。 以上就是使用xxl-job实现分布式任务调度的详细步骤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值