XXL-JOB基本配置使用步骤

XXL-JOB基本配置使用步骤

XXL-JOB使用步骤 -- LiSanWei

1.找到项目doc/db/tables_xxl_job.sql运行sql脚本执行sql，同时注意版本对应
[码云sql脚本地址] https://gitee.com/xuxueli0323/xxl-job/tree/2.2.0/doc/db

引入Maven依赖

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

注意：xxl-job-admin版本需要和Maven版本绝对一致，不然可能会存在注册调度器错误*

2.xxl-job-admin为调度器操作页面，修改application.properties数据库地址可直接启动

3.启动成功：如图:

使用步骤:
①新建执行器，点击执行器管理
image.png image.png
②代码配置如图：

# xxl-job配置
xxl:
  job:
    admin:
      # 调度中心部署跟地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
      addresses: http://172.18.101.191:8080/xxl-job-admin
    executor:
      # 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
      address: http://172.18.101.191:8888
      # 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
      appname: my-application-task
      # 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
      ip: 172.18.101.191
      # 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
      port: 8888
      # 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
      logpath: /Users/luoyu/Documents/log/xxl-job/jobhandler
      # 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
      logretentiondays: 15
    # 执行器通讯TOKEN [选填]：非空时启用；
    accessToken:

4.新建一个config目录创建XxlJobConfig类

5.XxlJobConfig如图

package org.springcenter.sdk.ordercenter.config;

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

/**
* @author lisanwei24282
  */
  @Slf4j
  @Configuration
  public class XxlJobConfig {

  @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;

  @Bean
  public XxlJobSpringExecutor xxlJobExecutor() {
  log.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;
  }

  /**
    * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
    *
    *      1、引入依赖：
    *          <dependency>
    *             <groupId>org.springframework.cloud</groupId>
    *             <artifactId>spring-cloud-commons</artifactId>
    *             <version>${version}</version>
    *         </dependency>
    *
    *      2、配置文件，或者容器启动变量
    *          spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
    *
    *      3、获取IP
    *          String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
  */
  }

6.创建一个XxlJobService类

package org.springcenter.sdk.ordercenter.xxljob;

import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.xxl.job.core.util.ShardingUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.TimeUnit;

/**
* XxlJob开发示例（Bean模式）
* <p>
* 开发步骤：
* 1、在Spring Bean实例中，开发Job方法，方式格式要求为 "public ReturnT<String> execute(String param)"
* 2、为Job方法添加注解 "@XxlJob(value="自定义jobhandler名称", init = "JobHandler初始化方法", destroy = "JobHandler销毁方法")"，注解value值对应的是调度中心新建任务的JobHandler属性的值。
* 3、执行日志：需要通过 "log.info" 打印执行日志；
*
* @author xuxueli 2019-12-11 21:52:51
*/
@Slf4j
@Component
public class XxlJobService {

   /**
    * 1、简单任务示例（Bean模式）
    */
   @XxlJob("demoJobHandler")
   public ReturnT<String> demoJobHandler(String param) throws Exception {
       log.info("XXL-JOB, Hello World.");

       for (int i = 0; i < 5; i++) {
           log.info("beat at:" + i);
           TimeUnit.SECONDS.sleep(2);
       }
       return ReturnT.SUCCESS;
   }

   /**
    * 2、分片广播任务
    */
   @XxlJob("shardingJobHandler")
   public ReturnT<String> shardingJobHandler(String param) throws Exception {

       // 分片参数
       ShardingUtil.ShardingVO shardingVO = ShardingUtil.getShardingVo();
       log.info("分片参数：当前分片序号 = {}, 总分片数 = {}", shardingVO.getIndex(), shardingVO.getTotal());

       // 业务逻辑
       for (int i = 0; i < shardingVO.getTotal(); i++) {
           if (i == shardingVO.getIndex()) {
               log.info("第 {} 片, 命中分片开始处理", i);
           } else {
               log.info("第 {} 片, 忽略", i);
           }
       }

       return ReturnT.SUCCESS;
   }

   /**
    * 3、命令行任务
    */
   @XxlJob("commandJobHandler")
   public ReturnT<String> commandJobHandler(String param) throws Exception {
       String command = param;
       int exitValue = -1;

       BufferedReader bufferedReader = null;
       try {
           // command process
           Process process = Runtime.getRuntime().exec(command);
           BufferedInputStream bufferedInputStream = new BufferedInputStream(process.getInputStream());
           bufferedReader = new BufferedReader(new InputStreamReader(bufferedInputStream));

           // command log
           String line;
           while ((line = bufferedReader.readLine()) != null) {
               log.info(line);
           }

           // command exit
           process.waitFor();
           exitValue = process.exitValue();
       } catch (Exception e) {
           log.info(String.valueOf(e));
       } finally {
           if (bufferedReader != null) {
               bufferedReader.close();
           }
       }

       if (exitValue == 0) {
           return IJobHandler.SUCCESS;
       } else {
           return new ReturnT<String>(IJobHandler.FAIL.getCode(), "command exit value(" + exitValue + ") is failed");
       }
   }

   /**
    * 4、跨平台Http任务
    */
   @XxlJob("httpJobHandler")
   public ReturnT<String> httpJobHandler(String param) throws Exception {

       // request
       HttpURLConnection connection = null;
       BufferedReader bufferedReader = null;
       try {
           // connection
           URL realUrl = new URL(param);
           connection = (HttpURLConnection) realUrl.openConnection();

           // connection setting
           connection.setRequestMethod("GET");
           connection.setDoOutput(true);
           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();

           //Map<String, List<String>> map = connection.getHeaderFields();

           // 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();

           log.info(responseMsg);
           return ReturnT.SUCCESS;
       } catch (Exception e) {
           log.info(String.valueOf(e));
           return ReturnT.FAIL;
       } finally {
           try {
               if (bufferedReader != null) {
                   bufferedReader.close();
               }
               if (connection != null) {
                   connection.disconnect();
               }
           } catch (Exception e2) {
               log.info(String.valueOf(e2));
           }
       }

   }

   /**
    * 5、生命周期任务示例：任务初始化与销毁时，支持自定义相关逻辑；
    */
   @XxlJob(value = "demoJobHandler2", init = "init", destroy = "destroy")
   public ReturnT<String> demoJobHandler2(String param) throws Exception {
       log.info("XXL-JOB, Hello World.");
       return ReturnT.SUCCESS;
   }

   public void init() {
       log.info("init");
   }

   public void destroy() {
       log.info("destory");
   }

}

7.创建调度器并执行

8.启动