三方通过接口创建xxl-job任务调度（支持GLUE）

依赖

        <!--xxljob-->
        <!-- https://mvnrepository.com/artifact/com.xuxueli/xxl-job-core -->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!--org.apache.commons.httpclient-->
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>

1、XxlJobClient-模拟登录

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.xxljob.config.XxlJobClientConfigProperties;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @Author ygq
 * @Date 2024年4月24日
 */
@Component
public class XxlJobClient {
    private String COOKIE = "";
    private HttpClient httpClient;
    private static final String POST_FORM_CONTENT_TYPE = "application/x-www-form-urlencoded; charset=UTF-8";
    private static final Header POST_FORM_CONTENT_TYPE_HEADER = new Header("Content-Type", POST_FORM_CONTENT_TYPE);
    @Autowired
    private XxlJobClientConfigProperties clientConfigProperties;

    private final Logger log = LoggerFactory.getLogger(getClass());


    @PostConstruct
    public void init() throws IOException {
        log.debug("xxl JOB 初始化配置：{}", clientConfigProperties.toString());
        httpClient = new HttpClient();
        login();
    }

    /**
     * 登录获取 cookie
     *
     * @throws IOException
     */
    private void login() throws IOException {
        HttpMethod postMethod = new PostMethod(clientConfigProperties.getLoginUrl());
        httpClient.executeMethod(postMethod);
        if (postMethod.getStatusCode() == 200) {
            Cookie[] cookies = httpClient.getState().getCookies();
            StringBuilder tmpCookies = new StringBuilder();
            for (Cookie c : cookies) {
                tmpCookies.append(c.toString()).append(";");
            }
            COOKIE = tmpCookies.toString();
            log.debug("xxlJob 登录成功");
        } else {
            log.debug("xxlJob 登录失败:{}", postMethod.getStatusCode());
        }
    }

    /**
     * 创建任务
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject createJob(JSONObject params) throws IOException {
        return doPost(clientConfigProperties.getJobInfoAddUrl(), params);
    }

    /**
     * 更新任务
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject updateJob(JSONObject params) throws IOException {
        return doPost(clientConfigProperties.getJobInfoUpdateUrl(), params);
    }

    /**
     * 根据任务 ID 加载
     *
     * @param id
     * @return
     * @throws IOException
     */
    public JSONObject loadById(int id) throws IOException {
        log.info("loadById: {}", id);
        return doGet(String.format(clientConfigProperties.getJobInfoLoadByIdUrl(), id));
    }

    /**
     * 删除任务
     *
     * @param id 任务 ID
     * @return
     * @throws IOException
     */
    public JSONObject deleteJob(int id) throws IOException {
        log.info("deleteJob: {}", id);
        return doGet(String.format(clientConfigProperties.getJobInfoDeleteUrl(), id));
    }

    /**
     * 开启任务
     *
     * @param id 任务 ID
     * @return
     * @throws IOException
     */
    public JSONObject startJob(int id) throws IOException {
        log.info("startJob: {}", id);
        return doGet(String.format(clientConfigProperties.getJobInfoStartJobUrl(), id));
    }

    /**
     * 执行一次
     *
     * @param id 任务 ID
     * @return
     * @throws IOException
     */
    public JSONObject startJobOnce(JSONObject params) throws IOException {
        return doGet(String.format(clientConfigProperties.getJhobInfoTriggerUrl(), params));
    }


    /**
     * 停止任务
     *
     * @param id 任务 ID
     * @return
     * @throws IOException
     */
    public JSONObject stopJob(int id) throws IOException {
        log.info("stopJob: {}", id);
        return doGet(String.format(clientConfigProperties.getJobInfoStopJobUrl(), id));
    }


    /**
     * 创建执行器
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject createJobGroup(JSONObject params) throws IOException {
        return doPost(clientConfigProperties.getJobGroupSaveUrl(), params);
    }

    /**
     * 删除执行器
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject removeJobGroup(JSONObject params) throws IOException {
        return doPost(clientConfigProperties.getJobGroupRemoveUrl(), params);
    }

    /**
     * 执行器列表
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject jobGroupPageList(JSONObject params) throws IOException {
        params.put("start", Optional.ofNullable(params.getInteger("start")).orElse(0));
        params.put("length", Optional.ofNullable(params.getInteger("length")).orElse(10));
        return doPost(clientConfigProperties.getJobGroupPageListUrl(), params);
    }

    /**
     * 根据appname获取执行器Id
     *
     * @param appName
     * @return
     * @throws IOException
     */
    public JSONObject getJobGroupByAppName(String appName) throws IOException {
        return doPost(clientConfigProperties.getJobGroupGetByAppNameUrl()+"?appName="+appName, new JSONObject());
    }

    /**
     * 任务列表
     *
     * @param params
     * @return
     * @throws IOException
     */
    public JSONObject jobInfoPageList(JSONObject params) throws IOException {
        params.put("start", Optional.ofNullable(params.getInteger("start")).orElse(0));
        params.put("length", Optional.ofNullable(params.getInteger("length")).orElse(10));
        return doPost(clientConfigProperties.getJobInfoPageListUrl(), params);
    }

    /**
     * 发起 GET 请求
     *
     * @param url
     * @return
     * @throws IOException
     */
    private JSONObject doGet(String url) throws IOException {
        GetMethod get = new GetMethod(url);
        get.setRequestHeader("cookie", COOKIE);
        httpClient.executeMethod(get);
        return readResponse(get);
    }

    /**
     * post 请求
     *
     * @param url
     * @param params
     * @return
     * @throws IOException
     */
    private JSONObject doPost(String url, JSONObject params) throws IOException {
        PostMethod post = new PostMethod(url);
        post.setRequestHeader("cookie", COOKIE);
        List<NameValuePair> pairList = new ArrayList<>();
        params.forEach((k, v) -> pairList.add(new NameValuePair(k, v.toString())));
        NameValuePair[] arr = pairList.toArray(new NameValuePair[0]);
        post.setRequestBody(arr);
        post.setRequestHeader(POST_FORM_CONTENT_TYPE_HEADER);
        httpClient.executeMethod(post);
        return readResponse(post);
    }

    /**
     * 处理响应内容
     *
     * @param httpMethod
     * @return
     * @throws IOException
     */
    private JSONObject readResponse(HttpMethod httpMethod) {
        if (httpMethod.getStatusCode() == HttpStatus.SC_OK) {
            try (InputStream inputStream = httpMethod.getResponseBodyAsStream();
                 InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
                 BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {
                return JSON.parseObject(bufferedReader.lines().collect(Collectors.joining(System.lineSeparator())));
            } catch (IOException e) {
                log.error("读取响应失败：{}", e.getMessage(), e);
                JSONObject error = new JSONObject();
                error.put("code", HttpStatus.SC_INTERNAL_SERVER_ERROR);
                error.put("msg", "响应内容读取失败：" + e.getMessage());
                return error;
            }
        }
        return new JSONObject();
    }
}

2、configproperties-配置基础接口地址

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @Author ygq
 * @Date 2024年4月24日
 */
@Configuration
@Data
public class XxlJobClientConfigProperties {

    @Value("${xxl.job.admin.addresses}/login?userName=admin&password=123456")
    private String loginUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/add")
    private String jobInfoAddUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/remove?id=%s")
    private String jobInfoDeleteUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/start?id=%s")
    private String jobInfoStartJobUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/stop?id=%s")
    private String jobInfoStopJobUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/update")
    private String jobInfoUpdateUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/loadById/%s")
    private String jobInfoLoadByIdUrl;
    @Value("${xxl.job.admin.addresses}/jobinfo/trigger")
    private String jhobInfoTriggerUrl;
    /**
     * 任务列表
     */
    @Value("${xxl.job.admin.addresses}/jobinfo/pageList")
    private String jobInfoPageListUrl;
    /**
     * 执行器列表
     */
    @Value("${xxl.job.admin.addresses}/jobgroup/pageList")
    private String jobGroupPageListUrl;
    /**
     * 执行器创建 URL
     */
    @Value("${xxl.job.admin.addresses}/jobgroup/save")
    private String jobGroupSaveUrl;
    /**
     * 执行器删除 URL
     */
    @Value("${xxl.job.admin.addresses}/jobgroup/remove")
    private String jobGroupRemoveUrl;

    @Value("${xxl.job.admin.addresses}/jobgroup/getJobGroupByAppName")
    private String jobGroupGetByAppNameUrl;



}

3、xxljobconfig-配置xxljob平台基础信息

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.io.File;

/**
 * xxl-job config
 *
 */
@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

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

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

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

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

    @Value("${file.sub.excel.path}")
    private     String subFilePath;
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }



}

4、service-具体实现业务

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import com.xxl.job.core.context.XxlJobHelper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.apache.tomcat.jni.FileInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestClientException;
import org.springframework.web.client.RestTemplate;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.*;

@Slf4j
@Service
public class XxljobService {


    @Value("${xxl.job.executor.appname}")
    private String appname;
    @Autowired
    private XxlJobClient xxlJobClient;

    @Autowired
    RestTemplate restTemplate;

    /**
     * 封装glueSource脚本
     *
     * @param xxlJobInfoVO
     * @return
     */
    @Override
    public String getGlueSourceStr(XxlJobInfoVO xxlJobInfoVO) {
      return "";
    }


    /**
     * 分页查询执行器列表
     *
     * @param page       当前页码
     * @param rows       每页数量
     * @param direction  排序规则
     * @param properties 排序规则
     * @param appname
     * @param title
     * @return
     */
    @Override
    public JsonResponse getJobGroupPageList(int page, int rows, String direction, String properties, String title) {
        Pageable pageable = getPageable(page, rows, direction, properties);
        Map<String, Object> param = new HashMap<>();
        page -= 1;
        param.put("start", page < 0 ? "0" : page);
        param.put("length", rows);
        param.put("appname", appname);
        if (StringUtils.isNotBlank(title)) {
            param.put("title", title);
        }
        JSONObject paramObject = new JSONObject(param);
        try {
            JSONObject jobGroupMsg = xxlJobClient.jobGroupPageList(paramObject);
            Object data = jobGroupMsg.get("data");
            if (data != null) {
                List<Object> list = new ArrayList<Object>();
                if (data instanceof ArrayList<?>) {
                    for (Object o : (List<?>) data) {
                        list.add(o);
                    }
                }
                Object recordsTotal = jobGroupMsg.get("recordsTotal");
                Page<Map<String, Object>> result = new PageImpl(list, pageable, Integer.valueOf(recordsTotal == null ? "0" : recordsTotal + ""));
                return JsonResponse.success(result);
            }
            return JsonResponse.fail("执行器查询异常！" + jobGroupMsg.get("msg"));
        } catch (IOException e) {
            return JsonResponse.fail("执行器查询异常！" + e);
        }
    }


    /**
     * 分页查询任务列表
     *
     * @param page            当前页码
     * @param rows            每页数量
     * @param direction       排序规则
     * @param properties      排序规则
     * @param jobGroup        执行器id
     * @param triggerStatus   状态（-1 全部，0 停止，1 启动）
     * @param jobDesc         任务描述
     * @param executorHandler handler
     * @return
     */
    @Override
    public JsonResponse jobInfoPageList(int page, int rows, String direction, String properties, String jobGroup, String triggerStatus, String jobDesc, String executorHandler) {
        Pageable pageable = getPageable(page, rows, direction, properties);
        Map<String, Object> param = new HashMap<>();
        page -= 1;
        param.put("start", page < 0 ? "0" : page);
        param.put("length", rows);
        if (StringUtils.isBlank(jobGroup)) {
            return JsonResponse.fail("未选择执行器！");
        }
        param.put("jobGroup", Integer.valueOf(jobGroup));
        param.put("triggerStatus", Integer.valueOf(triggerStatus));
        if (StringUtils.isNotBlank(jobDesc)) {
            param.put("jobDesc", jobDesc);
        }
        if (StringUtils.isNotBlank(executorHandler)) {
            param.put("executorHandler", executorHandler);
        }

        JSONObject paramObject = new JSONObject(param);
        try {
            JSONObject jobGroupMsg = xxlJobClient.jobInfoPageList(paramObject);//向xxljob发送请求
            Object data = jobGroupMsg.get("data");
            if (data != null) {
                List<Object> list = new ArrayList<Object>();
                if (data instanceof ArrayList<?>) {
                    for (Object o : (List<?>) data) {
                        list.add(o);
                    }
                }
                Object recordsTotal = jobGroupMsg.get("recordsTotal");
                Page<Map<String, Object>> result = new PageImpl(list, pageable, Integer.valueOf(recordsTotal == null ? "0" : recordsTotal + ""));
                return JsonResponse.success(result);
            }
            log.error("分页查询任务列表接口调用xxljob异常{}", jobGroupMsg.get("msg"));
            return JsonResponse.fail("任务列表查询异常_xxljob " + jobGroupMsg.get("msg"));
        } catch (IOException e) {
            log.error("分页查询任务列表接口异常{}", e);
            return JsonResponse.fail("任务查询异常！" + e);
        }
    }

    @Override
    public JsonResponse createTask(XxlJobInfoVO xxlJobInfoVO) {
        Map<String, Object> map = (Map<String, Object>) MapUtil.objectToMap(xxlJobInfoVO);

        map.put("schedule_conf_FIX_RATE", "");
        map.put("schedule_conf_FIX_DELAY", "");
        switch (xxlJobInfoVO.getGlueType()) {
            case "BEAN": {//BEAN
            }
            case "GLUE_GROOVY": {//GLUE_JAVA
                if (StringUtils.isEmpty(xxlJobInfoVO.getGlueSource())) {
                    map.put("glueSource", getGlueSourceStr(xxlJobInfoVO));//待执行代码块初始化置空
                }
            }
        }

        JSONObject jsonObject = new JSONObject(map);
        try {
            JSONObject clientResp = xxlJobClient.createJob(jsonObject);//返回任务id，删除执行器时，要用此id,根据你的业务保存在业务库
            if (clientResp.get("code") == null || !"200".equals(clientResp.get("code").toString())) {
                return JsonResponse.fail("任务创建失败!" + clientResp.get("msg"));
            }
            Object taskId = clientResp.get("content");
            System.out.println("任务Id:" + taskId);
            return JsonResponse.success(taskId, "任务创建成功！");
        } catch (IOException e) {

            return JsonResponse.fail("任务创建失败!");
        }
    }

    /**
     * @param appName
     * @return
     */
    @Override
    public Integer getJobGroupByAppName(String appName) {

        JSONObject clientResp = null;
        try {
            clientResp = xxlJobClient.getJobGroupByAppName(appName);//返回任务id，删除执行器时，要用此id,根据你的业务保存在业务库
        } catch (IOException e) {
            log.error("getJobGroupByAppName 执行器查询失败，{}", e);
            return null;
        }
        if (clientResp.get("code") == null || !"200".equals(clientResp.get("code").toString())) {
            log.error("getJobGroupByAppName xxljob调度请求失败，{}", clientResp.get("msg"));
            return null;
        }
        Object content = clientResp.get("content");
        return Integer.valueOf(content + "");
    }

    @Override
    public JsonResponse createExecutor(String executorName) {
        Map<String, Object> map = new HashMap<>();
        map.put("title", executorName);
        map.put("appname", appname);
        map.put("addressType", 0);
        JSONObject jsonObject = new JSONObject(map);
        try {
            JSONObject jobGroupMsg = xxlJobClient.createJobGroup(jsonObject);
            Object code = jobGroupMsg.get("code");
            if (code != null && StrUtil.equals(code.toString(), "200")) {
                Object executorId = jobGroupMsg.get("content");
                return JsonResponse.success(executorId);
            }
            return JsonResponse.fail("执行器创建异常！" + jobGroupMsg.get("msg"));
        } catch (IOException e) {
            log.error("--->>>创建执行器_createExecutor 异常{}", e);
            return JsonResponse.fail("执行器创建异常！");
        }
    }

    @Override
    public JsonResponse startJobOnce(String id, String executorParam, String addressList) {
        Map<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("executorParam", executorParam);
        map.put("addressList", addressList);
        JSONObject jsonObject = new JSONObject(map);
        JSONObject jobGroupMsg = null;
        try {
            jobGroupMsg = xxlJobClient.startJobOnce(jsonObject);
        } catch (IOException e) {
            log.error("startJobOnce执行失败，{}", e);
            return JsonResponse.fail("执行失败！");
        }
        Object code = jobGroupMsg.get("code");
        if (code != null && StrUtil.equals(code.toString(), "200")) {
            return JsonResponse.success("任务启动成功！");
        }
        return JsonResponse.fail(jobGroupMsg.get("msg"));
    }

    @Override
    public JsonResponse startTask(String taskId) {
        if (StringUtils.isEmpty(taskId)) {
            return JsonResponse.fail("任务id不能为空！");
        }
        Map<String, Object> map = new HashMap<>();
        map.put("id", taskId);//第二步，创建任务返回的taskId
        try {
            xxlJobClient.startJob(Integer.valueOf(taskId));
        } catch (IOException e) {
            return JsonResponse.success("任务启动失败！");
        }
        return JsonResponse.success("任务启动成功！");
    }

    @Override
    public JsonResponse deleteTask(String taskId) {
        Map<String, Object> map = new HashMap<>();
        map.put("id", taskId);//第二步，创建任务返回的taskId
        try {
            xxlJobClient.deleteJob(Integer.valueOf(taskId));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return JsonResponse.success("任务删除成功！");
    }

    @Override
    public JsonResponse stopTask(String taskId) {
        JSONObject jsonObject = null;
        try {
             jsonObject = xxlJobClient.stopJob(Integer.valueOf(taskId));
        } catch (IOException e) {
            log.error("任务停止失败，{}", e);
        }
        return JsonResponse.success(jsonObject);
    }
    

    /**
     * http请求统一方法
     *
     * @param url
     * @param method
     * @param data
     */
    private void getRequest(String url, String method, String data) {
        // request
        HttpURLConnection connection = null;
        BufferedReader bufferedReader = null;
        try {
            // connection
            URL realUrl = new URL(url);
            connection = (HttpURLConnection) realUrl.openConnection();
            boolean isPostMethod = method.equals("POST");
            // connection setting
            connection.setRequestMethod(method);
            connection.setDoOutput(isPostMethod);
            connection.setDoInput(true);
            connection.setUseCaches(false);
            connection.setReadTimeout(5 * 1000);
            connection.setConnectTimeout(3 * 1000);
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
            connection.setRequestProperty("Accept-Charset", "application/json;charset=UTF-8");

            // do connection
            connection.connect();

            // data
            if (isPostMethod && data != null && data.trim().length() > 0) {
                DataOutputStream dataOutputStream = new DataOutputStream(connection.getOutputStream());
                dataOutputStream.write(data.getBytes("UTF-8"));
                dataOutputStream.flush();
                dataOutputStream.close();
            }

            // valid StatusCode
            int statusCode = connection.getResponseCode();
            if (statusCode != 200) {
                throw new RuntimeException("Http Request StatusCode(" + statusCode + ") Invalid.");
            }

            // result
            bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
            StringBuilder result = new StringBuilder();
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                result.append(line);
            }
            String responseMsg = result.toString();

            XxlJobHelper.log(responseMsg);

            return;
        } catch (Exception e) {
            XxlJobHelper.log(e);

            XxlJobHelper.handleFail();
            return;
        } finally {
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
                if (connection != null) {
                    connection.disconnect();
                }
            } catch (Exception e2) {
                XxlJobHelper.log(e2);
            }
        }

    }


    /**
     * get 请求（请求头，参数，url）
     *
     * @param url          请求地址
     * @param param        请求参数
     * @param headersParam 请求头参数
     */
    private ResponseEntity<String> doGetRequest(String url, Map<String, Objects> param, Map<String, Objects> headersParam) {
        //封装请求参数
        try {
            if (param.size() > 0) {
                url += "?";
                int i = 0;
                for (String key : param.keySet()) {
                    Objects value = param.get(key);
                    if (i < param.size() - 1) {
                        url += key + ":" + value + "&";
                    } else {
                        url += key + ":" + value;
                    }
                }
            }
            //封装请求头
            HttpHeaders headers = new HttpHeaders();
            headers.add("connection", "Keep-Alive");
            headers.add("Content-Type", "application/json;charset=UTF-8");
            headers.add("Accept-Charset", "application/json;charset=UTF-8");
            for (String key : headersParam.keySet()) {
                headers.add(key, headersParam.get(key) + "");
            }
            //封装请求头
            HttpEntity<MultiValueMap<String, Object>> formEntity = new HttpEntity<MultiValueMap<String, Object>>(headers);
            ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, formEntity, String.class);
            return response;
        } catch (RestClientException e) {
            log.error("doGetRequest 请求异常！{}", e);
            return new ResponseEntity<String>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }


    /**
     * @param url
     * @param param
     * @param headersParam
     * @param body
     */
    private ResponseEntity<String> doPostRequest(String url, Map<String, Objects> param, Map<String, Objects> headersParam, String body) {
        // 1.请求参数
        if (param.size() > 0) {
            url += "?";
            int i = 0;
            for (String key : param.keySet()) {
                Objects value = param.get(key);
                if (i < param.size() - 2) {
                    url += key + ":" + value + "&";
                } else {
                    url += key + ":" + value;
                }

            }
        }

        // 2.请求头
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.add("connection", "Keep-Alive");
        httpHeaders.add("Content-Type", "application/json;charset=UTF-8");
        httpHeaders.add("Accept-Charset", "application/json;charset=UTF-8");
        for (String paramKey : headersParam.keySet()) {
            httpHeaders.add(paramKey, headersParam.get(paramKey) + "");
        }
        // 3.请求头 & 请求体
        HttpEntity<String> fromEntity = new HttpEntity<>(body, httpHeaders);
        return restTemplate.exchange(url, HttpMethod.POST, fromEntity, String.class);

    }


    /**
     * form-data的post 请求
     *
     * @param params
     * @param url
     * @param resourcesUrl
     * @param fileName
     * @return
     */
    private ResponseEntity<String> doPostFormDataRequest(MultiValueMap<String, Object> params, String url, String resourcesUrl, String fileName) {

        //通过url获取文件资源
        ByteArrayResource contentsAsResource = null;
        try {
//            contentsAsResource = getResourceByUrl("http://192.168.1.1:9300/statics/project_61/safety/2021/12/22/cfc8b2e9-4536-44cb-a098-25cc6ed84e6b.jpg","ces.jpg");
            contentsAsResource = getResourceByUrl(resourcesUrl, fileName);
        } catch (IOException e) {

        }
        params.add("files", contentsAsResource);
        List<FileInfo> fileInfos = new ArrayList<>();
        // 同上面指定的文件名
//        fileInfos.add(FileInfo.builder().fileName("ces.jpg").documentType("GC0013001")
//                .unitProjectId("dc77d2c538cb4491a4b6aea006f9e48f").documentDirectoryId("3015").build());
        params.add("fileInfos", fileInfos);


        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<MultiValueMap<String, Object>>(params, headers);
        return restTemplate.postForEntity(url, httpEntity, String.class);
    }


    /**
     * 通过url获取文件资源
     *
     * @param url
     * @param fileName
     * @return
     * @throws IOException
     */
    private ByteArrayResource getResourceByUrl(String url, String fileName) throws IOException {
        // 通过url获取输入流
        InputStream inputStream = getFileInputStream(url);
        // 读取输入流到字节数组
        byte[] bytes = readBytes(inputStream);
        // 将自己数组转为文件资源
        return new ByteArrayResource(bytes) {
            @Override
            public String getFilename() {
                // 指定文件名称
                return fileName;
            }
        };
    }

    /*读取网络文件*/
    private InputStream getFileInputStream(String path) {
        URL url = null;
        try {
            url = new URL(path);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            //设置超时间为3秒
            conn.setConnectTimeout(3 * 1000);
            //防止屏蔽程序抓取而返回403错误
            conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
            //得到输入流
            return conn.getInputStream();
        } catch (Exception e) {
            log.error("读取网络文件异常:" + path);
        }
        return null;
    }

    /**
     * 读取输入流到字节数组
     *
     * @param in
     * @return
     * @throws IOException
     */
    private byte[] readBytes(InputStream in) throws IOException {
        //读取字节的缓冲
        byte[] buffer = new byte[1024];
        //最终的数据
        byte[] result = new byte[0];
        int size = 0;
        while ((size = in.read(buffer)) != -1) {
            int oldLen = result.length;
            byte[] tmp = new byte[oldLen + size];
            if (oldLen > 0) {//copy 旧字节
                System.arraycopy(result, 0, tmp, 0, oldLen);
            }
            //copy 新字节
            System.arraycopy(buffer, 0, tmp, oldLen, size);

            result = tmp;
        }
        return result;
    }


}

本机xxljob配置

xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin
xxl.job.accessToken=default_token
xxl.job.executor.appname=deaiop-executor
xxl.job.executor.port=9985
xxl.job.executor.logpath=logs/applogs/xxl-job/jobhandler
xxl.job.executor.logretentiondays=30
xxl.job.executor.address=
xxl.job.executor.ip=