学习笔记---分布式调度之xxlJob任务自动生成与注册的改造

最新推荐文章于 2023-12-11 17:03:46 发布

lbingk

最新推荐文章于 2023-12-11 17:03:46 发布

阅读量4.7k

点赞数

分类专栏： xxlJob

本文链接：https://blog.csdn.net/u014461495/article/details/104744115

版权

xxlJob 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

在前面三篇的学习总结中，可以得到：

执行器端，通过由spring来管理job方法的类，从而在容器刷新后可以通过注解获取对应的相关的Job方法或者Job类，从而可以构建jobHander类存储起来，并且通过Http的方式将所属执行器以及所有的JobHandler信息注册到调度中心，并且开启后台线程来将队列的执行信息推送给调度中心；
调度中心，启动后开启线程load出执行失败的日志，通过分析日志来重新执行调度任务，通过动态代理与NettyClient结合，用集合来做到一个执行器地址一个netty客户端；以及开启了快慢线程池来处理调度任务；开启报表生成线程；开启获取jobInfo的线程，分析时间梯度，直接执行调度或者交由时间轮上，到点执行。整个过程就是通过异步+多线程来实现；
调度任务：在调度中心由日志或者时间到了触发（当然还有人工触发，不做分析），都是通过调用代理对象，封装请求对象，发送给执行器端，执行器端通过解析请求体信息，获取jobId从而在Map中获取JobHandler，从而创建唯一对应的JobThread，并用集合存储，从而保证JobHandler与JobThread一一对应，接着将请求信息放到队列，由JobThread不停的监控，如果有数据，则反射调用JobHandler来实现，执行的结果推到队列，由开启的后台线程执行主动推送；
优雅停机的话，都通过共享内存变量结合thread.interupt()来处理的；

那么，假如现在我们需要实现，已经存在的任务A，当任务A触发时需要生成任务B，而且任务A失效，当当网的ElasticJob是支持实现的，那么xxlJob如何实现呢？？
增加jobHandler：
通过对dubbo的spi自动生成的自适应类，存在通过内存编译的手动方式来生成代理类，笔者认为可以通过这个手段来动态生成Job,并且手动注册到spring上去，并且添加到存储JobHandler的集合中；
而对应到调度中心，则2.1.2版本暂无提供自动增加JobInfo功能，不过，在之前已经分析，调度中心暴露带有校验权限的api供执行器来注册以及推送执行结果，因此只需增加相关的api即可做到不改变其他的源码；
注销jobHandler：
那么如何注销呢，对于执行器端，通过前面的分析可以知道JobHandler与JobThread是一一对应的，销毁jobHandler同时必须销毁JobThread，以免浪费cpu资源，幸运的是，xxlJob以及停工的优雅停止的方法，只需调用即可；

依此思路，写了个demo，需要验证：

这个实在执行器端的；

package com.xxl.job.executor.core.config.custom;

import com.xxl.job.core.executor.XxlJobExecutor;
import com.xxl.job.core.util.XxlJobRemotingUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.util.CollectionUtils;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Classname JobHandlerUtills
 * @author: LUOBINGKAI
 * @Description 动态生成job工具类
 * @Date 2020/1/23 18:35
 */
public final class JobHandlerUtills {

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

    public static final AtomicInteger atomicInteger = new AtomicInteger(0);
    public static final Map<Integer, Class<?>> addClzMap = new TreeMap<>();

    public static Class<?> getClz() throws Exception {

        String code = "public class HelloWorld" + atomicInteger.incrementAndGet() + " {\n" +
                "    @com.xxl.job.core.handler.annotation.XxlJob(\"demoJobHandler" + atomicInteger.get() + "\")\n" +
                "    public com.xxl.job.core.biz.model.ReturnT<String> demoJobHandler" + atomicInteger.get() + "(String param) throws Exception {\n" +
                "\t\tfor(int i=0; i < 1; i++){\n" +
                "\t\t\t       System.out.println(\"Hello World!\");\n" +
                "\t\t}\n" +
                "   return com.xxl.job.core.biz.model.ReturnT.SUCCESS;\n" +
                "    }\n" +
                "}";
        CustomStringJavaCompiler compiler = new CustomStringJavaCompiler(code);
        if (!compiler.compiler()) {
            logger.error("JobHandlerUtills 执行编译失败：{}", compiler.getCompilerMessage());
            throw new Exception("编译失败  " + compiler.getCompilerMessage());
        }
        Class<?> clz = compiler.getClz();
        return clz;
    }

    public static void removePreClz() {
        if (CollectionUtils.isEmpty(addClzMap) || addClzMap.size() <= 1) {
            return;
        }
        // 保留最后一个
        Iterator<Map.Entry<Integer, Class<?>>> it = addClzMap.entrySet().iterator();
        int size = addClzMap.size();
        int i = 0;
        while (it.hasNext()) {
            if ((++i) > size - 1) {
                return;
            }
            Map.Entry<Integer, Class<?>> next = it.next();
            Integer jonInfoId = next.getKey();
            Class<?> oldClz = next.getValue();

            it.remove();
            // 将admin 旧的job删除
            String adminAddresses = ApplicationContextIni.getApplicationContext().getEnvironment().getProperty("xxl.job.admin.addresses");
            String accessToken = ApplicationContextIni.getApplicationContext().getEnvironment().getProperty("xxl.job.accessToken");
            String url = adminAddresses + "/api/remove";
            XxlJobRemotingUtil.postBody(url, accessToken, jonInfoId, 3);

            // 将对应的执行器的这层的对应的旧的线程删除
            XxlJobExecutor.removeJobThread(jonInfoId, "旧的jobThread需要删除，以免堆积占用线程资源");
            ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) ApplicationContextIni.getApplicationContext();
            DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
            defaultListableBeanFactory.removeBeanDefinition(oldClz.getSimpleName());
        }
    }
}

借鉴其他大神的内存编译代码：

package com.xxl.job.executor.core.config.custom;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Create by andy on 2018-12-06 21:25
 */
public class CustomStringJavaCompiler {
    //类全名
    private String fullClassName;
    private String sourceCode;
    //存放编译之后的字节码(key:类全名,value:编译之后输出的字节码)
    private Map<String, ByteJavaFileObject> javaFileObjectMap = new ConcurrentHashMap<>();
    //获取java的编译器
    private JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    //存放编译过程中输出的信息
    private DiagnosticCollector<JavaFileObject> diagnosticsCollector = new DiagnosticCollector<>();


    public CustomStringJavaCompiler(String sourceCode) {
        this.sourceCode = sourceCode;
        this.fullClassName = getFullClassName(sourceCode);
    }

    /**
     * 编译字符串源代码,编译失败在 diagnosticsCollector 中获取提示信息
     *
     * @return true:编译成功 false:编译失败
     */
    public boolean compiler() {
        //标准的内容管理器,更换成自己的实现，覆盖部分方法
        StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(diagnosticsCollector, null, null);
        JavaFileManager javaFileManager = new StringJavaFileManage(standardFileManager);
        //构造源代码对象
        JavaFileObject javaFileObject = new StringJavaFileObject(fullClassName, sourceCode);
        //获取一个编译任务
        JavaCompiler.CompilationTask task = compiler.getTask(null, javaFileManager, diagnosticsCollector, null, null, Arrays.asList(javaFileObject));
        //设置编译耗时
        return task.call();
    }


    public Class<?> getClz() throws ClassNotFoundException {
        return new StringClassLoader().findClass(fullClassName);
    }


    /**
     * @return 编译信息(错误 警告)
     */
    public String getCompilerMessage() {
        StringBuilder sb = new StringBuilder();
        List<Diagnostic<? extends JavaFileObject>> diagnostics = diagnosticsCollector.getDiagnostics();
        for (Diagnostic diagnostic : diagnostics) {
            sb.append(diagnostic.toString()).append("\r\n");
        }
        return sb.toString();
    }


    /**
     * 获取类的全名称
     *
     * @param sourceCode 源码
     * @return 类的全名称
     */
    public static String getFullClassName(String sourceCode) {
        String className = "";
        Pattern pattern = Pattern.compile("package\\s+\\S+\\s*;");
        Matcher matcher = pattern.matcher(sourceCode);
        if (matcher.find()) {
            className = matcher.group().replaceFirst("package", "").replace(";", "").trim() + ".";
        }

        pattern = Pattern.compile("class\\s+\\S+\\s+\\{");
        matcher = pattern.matcher(sourceCode);
        if (matcher.find()) {
            className += matcher.group().replaceFirst("class", "").replace("{", "").trim();
        }
        return className;
    }

    /**
     * 自定义一个字符串的源码对象
     */
    private class StringJavaFileObject extends SimpleJavaFileObject {
        //等待编译的源码字段
        private String contents;

        //java源代码 => StringJavaFileObject对象 的时候使用
        public StringJavaFileObject(String className, String contents) {
            super(URI.create("string:///" + className.replaceAll("\\.", "/") + Kind.SOURCE.extension), Kind.SOURCE);
            this.contents = contents;
        }

        //字符串源码会调用该方法
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return contents;
        }

    }

    /**
     * 自定义一个编译之后的字节码对象
     */
    private class ByteJavaFileObject extends SimpleJavaFileObject {
        //存放编译后的字节码
        private ByteArrayOutputStream outPutStream;

        public ByteJavaFileObject(String className, Kind kind) {
            super(URI.create("string:///" + className.replaceAll("\\.", "/") + Kind.SOURCE.extension), kind);
        }

        //StringJavaFileManage 编译之后的字节码输出会调用该方法（把字节码输出到outputStream）
        @Override
        public OutputStream openOutputStream() {
            outPutStream = new ByteArrayOutputStream();
            return outPutStream;
        }

        //在类加载器加载的时候需要用到
        public byte[] getCompiledBytes() {
            return outPutStream.toByteArray();
        }
    }

    /**
     * 自定义一个JavaFileManage来控制编译之后字节码的输出位置
     */
    private class StringJavaFileManage extends ForwardingJavaFileManager {
        StringJavaFileManage(JavaFileManager fileManager) {
            super(fileManager);
        }

        //获取输出的文件对象，它表示给定位置处指定类型的指定类。
        @Override
        public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
            ByteJavaFileObject javaFileObject = new ByteJavaFileObject(className, kind);
            javaFileObjectMap.put(className, javaFileObject);
            return javaFileObject;
        }
    }

    /**
     * 自定义类加载器, 用来加载动态的字节码
     */
    private class StringClassLoader extends ClassLoader {
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            ByteJavaFileObject fileObject = javaFileObjectMap.get(name);
            if (fileObject != null) {
                byte[] bytes = fileObject.getCompiledBytes();
                return defineClass(name, bytes, 0, bytes.length);
            }
            try {
                return ClassLoader.getSystemClassLoader().loadClass(name);
            } catch (Exception e) {
                return super.findClass(name);
            }
        }
    }
}

    /**
     * 1、简单任务示例（Bean模式）
     */
    @XxlJob("demoJobHandler")
    public ReturnT<String> demoJobHandler(String param) throws Exception {
        RegistXxlJob.regist();
        if(JobHandlerUtills.addClzMap.size()<=1){
            return ReturnT.SUCCESS;
        }
        // 执行删除之前自动生成的job
        JobHandlerUtills.removePreClz();
        return ReturnT.SUCCESS;
    }

这个是在调度中心的：

   /**
     * addStart
     *
     * @param data
     * @return
     */
    @RequestMapping("/addStart")
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT<String> addStart(HttpServletRequest request, @RequestBody(required = false) String data) {
        validAccessToken(request);
        ReturnT<String> addRe = xxlJobService.add((XxlJobInfo) parseParam(data, XxlJobInfo.class));
        if (addRe.getCode() != ReturnT.SUCCESS_CODE) {
            return addRe;
        }
        Integer jobId = Integer.valueOf(addRe.getContent());
        ReturnT<String> startRe = xxlJobService.start(jobId);
        if(startRe.getCode()!=ReturnT.SUCCESS_CODE){
            return startRe;
        }
        return new ReturnT<String>(String.valueOf(jobId));

    }

    @RequestMapping("/remove")
    @ResponseBody
    @PermissionLimit(limit = false)
    public ReturnT<String> remove(HttpServletRequest request,@RequestBody(required = false) String data) {
        validAccessToken(request);
        return xxlJobService.remove(Integer.valueOf(data));
    }
    // ---------------------- job biz ----------------------