XXL-Job启动源码详解，一份字节跳动面试官给你的Java技术面试指南

// start

@Override

public void afterSingletonsInstantiated() {

// 扫描xxl-job注解，进行任务加载和管理

initJobHandlerMethodRepository(applicationContext);

// refresh GlueFactory

GlueFactory.refreshInstance(1);

// super start

try {

super.start();

} catch (Exception e) {

throw new RuntimeException(e);

}

}

initJobHandlerMethodRepository方法主要如下

该方法主要是通过获取Spring管理的容器bean，然后扫描带有xxljob注解的方法，将他们保存在jobHandlerRepository对象中

private void initJobHandlerMethodRepository(ApplicationContext applicationContext) {

if (applicationContext == null) {

return;

}

// 扫描Spring管理的bean

String[] beanDefinitionNames = applicationContext.getBeanNamesForType(Object.class, false, true);

for (String beanDefinitionName : beanDefinitionNames) {

Object bean = applicationContext.getBean(beanDefinitionName);

Map<Method, XxlJob> annotatedMethods = null; // referred to ：org.springframework.context.event.EventListenerMethodProcessor.processBean

try {

annotatedMethods = MethodIntrospector.selectMethods(bean.getClass(),

new MethodIntrospector.MetadataLookup<XxlJob>() {

@Override

public XxlJob inspect(Method method) {

// 获取注解为XxlJob的方法，并保存在annotatedMethods

return AnnotatedElementUtils.findMergedAnnotation(method, XxlJob.class);

}

});

} catch (Throwable ex) {

logger.error(“xxl-job method-jobhandler resolve error for bean[” + beanDefinitionName + “].”, ex);

}

if (annotatedMethods==null || annotatedMethods.isEmpty()) {

continue;

}

//获取方法属性，并存储在jobHandlerRepository对象中

for (Map.Entry<Method, XxlJob> methodXxlJobEntry : annotatedMethods.entrySet()) {

Method method = methodXxlJobEntry.getKey();

XxlJob xxlJob = methodXxlJobEntry.getValue();

if (xxlJob == null) {

continue;

}

String name = xxlJob.value();

if (name.trim().length() == 0) {

throw new RuntimeException(“xxl-job method-jobhandler name invalid, for[” + bean.getClass() + “#” + method.getName() + “] .”);

}

if (loadJobHandler(name) != null) {

throw new RuntimeException(“xxl-job jobhandler[” + name + “] naming conflicts.”);

}

// execute method

if (!(method.getParameterTypes().length == 1 && method.getParameterTypes()[0].isAssignableFrom(String.class))) {

throw new RuntimeException(“xxl-job method-jobhandler param-classtype invalid, for[” + bean.getClass() + “#” + method.getName() + "] , " +

“The correct method format like " public ReturnT<String> execute(String param) " .”);

}

if (!method.getReturnType().isAssignableFrom(ReturnT.class)) {

throw new RuntimeException(“xxl-job method-jobhandler return-classtype invalid, for[” + bean.getClass() + “#” + method.getName() + "] , " +

“The correct method format like " public ReturnT<String> execute(String param) " .”);

}

method.setAccessible(true);

// init and destory

Method initMethod = null;

Method destroyMethod = null;

if (xxlJob.init().trim().length() > 0) {

try {

initMethod = bean.getClass().getDeclaredMethod(xxlJob.init());

initMethod.setAccessible(true);

} catch (NoSuchMethodException e) {

throw new RuntimeException(“xxl-job method-jobhandler initMethod invalid, for[” + bean.getClass() + “#” + method.getName() + “] .”);

}

}

if (xxlJob.destroy().trim().length() > 0) {

try {

destroyMethod = bean.getClass().getDeclaredMethod(xxlJob.destroy());

destroyMethod.setAccessible(true);

} catch (NoSuchMethodException e) {

throw new RuntimeException(“xxl-job method-jobhandler destroyMethod invalid, for[” + bean.getClass() + “#” + method.getName() + “] .”);

}

}

// registry jobhandler

//将任务存储在jobHandlerRepository对象中，后续下发任务使用

registJobHandler(name, new MethodJobHandler(bean, method, initMethod, destroyMethod));

}

}

}

之后执行super.start()，执行父类XxlJobExecutor的start方法。该方法主要有日志初始化，日志清理任务初始化，RPC调用触发器回调线程启动，调度中心列表初始化以及执行器端口初始化。

public void start() throws Exception { // init logpath

//初始化任务执行日志路径

XxlJobFileAppender.initLogPath(logPath);

// 日志定时清理任务

JobLogFileCleanThread.getInstance().start(logRetentionDays);

// 初始化触发器回调线程(用RPC回调调度中心接口)

TriggerCallbackThread.getInstance().start();

//初始化调度中心列表

initAdminBizList( adminAddresses, accessToken);

// init executor-server 执行器端口启动

initEmbedServer(address, ip, port, appname, accessToken);

}

XxlJobFileAppender.initLogPath(logPath)和JobLogFileCleanThread.getInstance().start(logRetentionDays)主要对执行日志进行初始化，就不多解释了，直接往下看。

TriggerCallbackThread.getInstance().start();

public void start() {

// 调度中心注册表会否为空

if (XxlJobExecutor.getAdminBizList() == null) {

logger.warn(“>>>>>>>>>>> xxl-job, executor callback config fail, adminAddresses is null.”);

return;

}

// callback

triggerCallbackThread = new Thread(new Runnable() {

@Override

public void run() {

// 监听阻塞队列

while(!toStop){

try {

HandleCallbackParam callback = getInstance().callBackQueue.take();

if (callback != null) {

// 组装callback返回的参数

List<HandleCallbackParam> callbackParamList = new ArrayList<HandleCallbackParam>();

int drainToNum = getInstance().callBackQueue.drainTo(callbackParamList);

callbackParamList.add(callback);

// 执行回调

if (callbackParamList!=null && callbackParamList.size()>0) {

doCallback(callbackParamList);

}

}

} catch (Exception e) {

if (!toStop) {

logger.error(e.getMessage(), e);

}

}

}

// last callback

try {

List<HandleCallbackParam> callbackParamList = new ArrayList<HandleCallbackParam>();

int drainToNum = getInstance().callBackQueue.drainTo(callbackParamList);

if (callbackParamList!=null && callbackParamList.size()>0) {

doCallback(callbackParamList);

}

} catch (Exception e) {

if (!toStop) {

logger.error(e.getMessage(), e);

}

}

logger.info(“>>>>>>>>>>> xxl-job, executor callback thread destory.”);

}

});

triggerCallbackThread.setDaemon(true);

triggerCallbackThread.setName(“xxl-job, executor TriggerCallbackThread”);

triggerCallbackThread.start();

// retry

triggerRetryCallbackThread = new Thread(new Runnable() {

@Override

public void run() {

while(!toStop){

try {

retryFailCallbackFile();

} catch (Exception e) {

if (!toStop) {

logger.error(e.getMessage(), e);

}

}

try {

TimeUnit.SECONDS.sleep(RegistryConfig.BEAT_TIMEOUT);

} catch (InterruptedException e) {

if (!toStop) {

logger.error(e.getMessage(), e);

}

}

}

logger.info(“>>>>>>>>>>> xxl-job, executor retry callback thread destory.”);

}

});

triggerRetryCallbackThread.setDaemon(true);

triggerRetryCallbackThread.start();

}

doCallback(callbackParamList)如下

/**

• do callback, will retry if error

• @param callbackParamList

*/

private void doCallback(List<HandleCallbackParam> callbackParamList){

boolean callbackRet = false;

// 向所有的调度中心发送回调信息

for (AdminBiz adminBiz: XxlJobExecutor.getAdminBizList()) {

try {

//本质上是调用注册中心的api/callback接口。记录调用结果。

ReturnT<String> callbackResult = adminBiz.callback(callbackParamList);

if (callbackResult!=null && ReturnT.SUCCESS_CODE == callbackResult.getCode()) {

callbackLog(callbackParamList, “<br>----------- xxl-job job callback finish.”);

callbackRet = true;

break;

} else {

callbackLog(callbackParamList, “<br>----------- xxl-job job callback fail, callbackResult:” + callbackResult);

}

} catch (Exception e) {

callbackLog(callbackParamList, “<br>----------- xxl-job job callback error, errorMsg:” + e.getMessage());

}

}

if (!callbackRet) {

appendFailCallbackFile(callbackParamList);

}

}

adminBiz.callback(callbackParamList)

调用注册中心api接口

@Override

public ReturnT<String> callback(List<HandleCallbackParam> callbackParamList) {

return XxlJobRemotingUtil.postBody(addressUrl+“api/callback”, accessToken, timeout, callbackParamList, String.class);

}

initAdminBizList( adminAddresses, accessToken); 初始化注册中心列表，用于后期和注册中心交互

//扫描xxl.job.admin.addresses配置，将他们加入注册中心列表adminBizList对象中。用于后期发送回调

private void initAdminBizList(String adminAddresses, String accessToken) throws Exception {

if (adminAddresses!=null && adminAddresses.trim().length()>0) {

for (String address: adminAddresses.trim().split(“,”)) {

if (address!=null && address.trim().length()>0) {

AdminBiz adminBiz = new AdminBizClient(address.trim(), accessToken);

if (adminBizList == null) {

adminBizList = new ArrayList<AdminBiz>();

}

adminBizList.add(adminBiz);

}

}

}

}

// init executor-server

initEmbedServer(address, ip, port, appname, accessToken);<核心>

//初始化xxljob执行器服务

private void initEmbedServer(String address, String ip, int port, String appname, String accessToken) throws Exception {

//初始化ip和端口，如果没有ip则自动获取本地ip

port = port>0?port: NetUtil.findAvailablePort(9999);

ip = (ip!=null&&ip.trim().length()>0)?ip: IpUtil.getIp();

// generate address

if (address==null || address.trim().length()==0) {

String ip_port_address = IpUtil.getIpPort(ip, port); // registry-address：default use address to registry , otherwise use ip:port if address is null

address = “http://{ip_port}/”.replace(“{ip_port}”, ip_port_address);

}

// 启动服务

embedServer = new EmbedServer();

embedServer.start(address, port, appname, accessToken);

}

embedServer.start(address, port, appname, accessToken); 本质上是一个Netty服务，标准的Netty服务启动，我们只看EmbedHttpServerHandler，Netty处理请求的handler

public void start(final String address, final int port, final String appname, final String accessToken) {

executorBiz = new ExecutorBizImpl();

thread = new Thread(new Runnable() {

@Override

public void run() {

// param

EventLoopGroup bossGroup = new NioEventLoopGroup();

EventLoopGroup workerGroup = new NioEventLoopGroup();

ThreadPoolExecutor bizThreadPool = new ThreadPoolExecutor(

0,

200,

60L,

TimeUnit.SECONDS,

new LinkedBlockingQueue<Runnable>(2000),

new ThreadFactory() {

@Override

public Thread newThread(Runnable r) {

return new Thread(r, “xxl-rpc, EmbedServer bizThreadPool-” + r.hashCode());

}

},

new RejectedExecutionHandler() {

@Override

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

throw new RuntimeException(“xxl-job, EmbedServer bizThreadPool is EXHAUSTED!”);

}

});

try {

// start server

ServerBootstrap bootstrap = new ServerBootstrap();

bootstrap.group(bossGroup, workerGroup)

.channel(NioServerSocketChannel.class)

.childHandler(new ChannelInitializer<SocketChannel>() {

@Override

public void initChannel(SocketChannel channel) throws Exception {

channel.pipeline()

.addLast(new IdleStateHandler(0, 0, 30 * 3, TimeUnit.SECONDS)) // beat 3N, close if idle

.addLast(new HttpServerCodec())

.addLast(new HttpObjectAggregator(5 * 1024 * 1024)) // merge request & reponse to FULL

.addLast(new EmbedHttpServerHandler(executorBiz, accessToken, bizThreadPool));

}

})

.childOption(ChannelOption.SO_KEEPALIVE, true);

// bind

ChannelFuture future = bootstrap.bind(port).sync();

logger.info(“>>>>>>>>>>> xxl-job remoting server start success, nettype = {}, port = {}”, EmbedServer.class, port);

//注册到调度中心

startRegistry(appname, address);

// wait util stop

future.channel().closeFuture().sync();

} catch (InterruptedException e) {

if (e instanceof InterruptedException) {

logger.info(“>>>>>>>>>>> xxl-job remoting server stop.”);

} else {

logger.error(“>>>>>>>>>>> xxl-job remoting server error.”, e);

}

} finally {

// stop

try {

workerGroup.shutdownGracefully();

bossGroup.shutdownGracefully();

} catch (Exception e) {

logger.error(e.getMessage(), e);

}

}

}

});

thread.setDaemon(true); // daemon, service jvm, user thread leave >>> daemon leave >>> jvm leave

thread.start();

}

public static class EmbedHttpServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

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

private ExecutorBiz executorBiz; //执行器

private String accessToken; //token

private ThreadPoolExecutor bizThreadPool;//执行器线程池

public EmbedHttpServerHandler(ExecutorBiz executorBiz, String accessToken, ThreadPoolExecutor bizThreadPool) {

this.executorBiz = executorBiz;

this.accessToken = accessToken;

this.bizThreadPool = bizThreadPool;

}

@Override

protected void channelRead0(final ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {

// request parse

//final byte[] requestBytes = ByteBufUtil.getBytes(msg.content()); // byteBuf.toString(io.netty.util.CharsetUtil.UTF_8);

String requestData = msg.content().toString(CharsetUtil.UTF_8);//获取请求数据

String uri = msg.uri();

HttpMethod httpMethod = msg.method();

boolean keepAlive = HttpUtil.isKeepAlive(msg);

String accessTokenReq = msg.headers().get(XxlJobRemotingUtil.XXL_JOB_ACCESS_TOKEN);

// invoke

bizThreadPool.execute(new Runnable() {

@Override

public void run() {

// 处理请求

Object responseObj = process(httpMethod, uri, requestData, accessTokenReq);

// 格式化为JSON

String responseJson = GsonTool.toJson(responseObj);

// 写回客户端

writeResponse(ctx, keepAlive, responseJson);

}

});

}

private Object process(HttpMethod httpMethod, String uri, String requestData, String accessTokenReq) {

// valid

if (HttpMethod.POST != httpMethod) {

return new ReturnT<String>(ReturnT.FAIL_CODE, “invalid request, HttpMethod not support.”);

}

if (uri==null || uri.trim().length()==0) {

return new ReturnT<String>(ReturnT.FAIL_CODE, “invalid request, uri-mapping empty.”);

}

if (accessToken!=null

&& accessToken.trim().length()>0

&& !accessToken.equals(accessTokenReq)) {

return new ReturnT<String>(ReturnT.FAIL_CODE, “The access token is wrong.”);

}

// services mapping

try {

//接收注册中心请求接口处理

if (“/beat”.equals(uri)) {

return executorBiz.beat();

} else if (“/idleBeat”.equals(uri)) {

IdleBeatParam idleBeatParam = GsonTool.fromJson(requestData, IdleBeatParam.class);

return executorBiz.idleBeat(idleBeatParam);

} else if (“/run”.equals(uri)) { //注册中心执行接口

TriggerParam triggerParam = GsonTool.fromJson(requestData, TriggerParam.class);

return executorBiz.run(triggerParam);

} else if (“/kill”.equals(uri)) {

KillParam killParam = GsonTool.fromJson(requestData, KillParam.class);

return executorBiz.kill(killParam);

} else if (“/log”.equals(uri)) {

LogParam logParam = GsonTool.fromJson(requestData, LogParam.class);

return executorBiz.log(logParam);

} else {

return new ReturnT<String>(ReturnT.FAIL_CODE, “invalid request, uri-mapping(”+ uri +“) not found.”);

}

} catch (Exception e) {

logger.error(e.getMessage(), e);

return new ReturnT<String>(ReturnT.FAIL_CODE, “request error:” + ThrowableUtil.toString(e));

}

}

我们主要看下run方法的执行过程

@Override

public ReturnT<String> run(TriggerParam triggerParam) {

// 根据jobid加载对应的job执行信息，第一次执行为null

JobThread jobThread = XxlJobExecutor.loadJobThread(triggerParam.getJobId());

IJobHandler jobHandler = jobThread!=null?jobThread.getHandler():null;//根绝jobThread获取job处理handler

String removeOldReason = null;

// valid：jobHandler + jobThread

GlueTypeEnum glueTypeEnum = GlueTypeEnum.match(triggerParam.getGlueType()); //获取任务类型

if (GlueTypeEnum.BEAN == glueTypeEnum) {

// new jobhandler

IJobHandler newJobHandler = XxlJobExecutor.loadJobHandler(triggerParam.getExecutorHandler());//获取任务的执行器

// 校验新老job是否一致，不一致将老的进行初始化。有可能任务更新。通过jobid获取的是老的

if (jobThread!=null && jobHandler != newJobHandler) {

// change handler, need kill old thread

removeOldReason = “change jobhandler or glue type, and terminate the old job thread.”;

jobThread = null;

jobHandler = null;

}

// valid handler

if (jobHandler == null) {

jobHandler = newJobHandler; //将新处理handler赋值给老的

if (jobHandler == null) {

return new ReturnT<String>(ReturnT.FAIL_CODE, “job handler [” + triggerParam.getExecutorHandler() + “] not found.”);

}

}

} else if (GlueTypeEnum.GLUE_GROOVY == glueTypeEnum) {

// valid old jobThread

if (jobThread != null &&

!(jobThread.getHandler() instanceof GlueJobHandler

&& ((GlueJobHandler) jobThread.getHandler()).getGlueUpdatetime()==triggerParam.getGlueUpdatetime() )) {

// change handler or gluesource updated, need kill old thread

removeOldReason = “change job source or glue type, and terminate the old job thread.”;

jobThread = null;

jobHandler = null;

}

if (jobHandler == null) {

try {

IJobHandler originJobHandler = GlueFactory.getInstance().loadNewInstance(triggerParam.getGlueSource());

jobHandler = new GlueJobHandler(originJobHandler, triggerParam.getGlueUpdatetime());

} catch (Exception e) {

logger.error(e.getMessage(), e);

return new ReturnT<String>(ReturnT.FAIL_CODE, e.getMessage());

}

}

} else if (glueTypeEnum!=null && glueTypeEnum.isScript()) {

// valid old jobThread

if (jobThread != null &&

!(jobThread.getHandler() instanceof ScriptJobHandler

&& ((ScriptJobHandler) jobThread.getHandler()).getGlueUpdatetime()==triggerParam.getGlueUpdatetime() )) {

// change script or gluesource updated, need kill old thread

removeOldReason = “change job source or glue type, and terminate the old job thread.”;

jobThread = null;

jobHandler = null;

}

// valid handler

if (jobHandler == null) {

jobHandler = new ScriptJobHandler(triggerParam.getJobId(), triggerParam.getGlueUpdatetime(), triggerParam.getGlueSource(), GlueTypeEnum.match(triggerParam.getGlueType()));

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

r(triggerParam.getJobId(), triggerParam.getGlueUpdatetime(), triggerParam.getGlueSource(), GlueTypeEnum.match(triggerParam.getGlueType()));

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-eHILBSN1-1712012705016)]
[外链图片转存中…(img-ITxSFOHw-1712012705016)]
[外链图片转存中…(img-7YqWSlAI-1712012705017)]
[外链图片转存中…(img-mXiQq4Tu-1712012705017)]
[外链图片转存中…(img-qqsnTdId-1712012705017)]
[外链图片转存中…(img-y4bkLay7-1712012705017)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-MXqgiueo-1712012705018)]

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

[外链图片转存中…(img-xZL0te3Y-1712012705018)]