在前面三篇的学习总结中,可以得到:
- 执行器端,通过由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:https:///" + 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:https:///" + 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 ----------------------