背景
在开发中有时会遇到长耗时的任务，我们又不想傻傻的等待任务的执行完成后才可能进行其他的操作。这时我们首先想到的是使用多线程进行异步处理，那么如何才能知道任务的执行状态呢，如执行了多长时间，执行的结果是成功了还是失败了。
此处提到的长耗时任务是指本身已经经过优化了不能在拆分的情况，如果任务还可以在拆分请先拆分，不要为难你自己。
如果项目中只是一次性或者很少量是这种情况，怎么着也能忍了；此处面对的是大量的，并且是需要经常处理的情况。
如果是定时任务或者在控制台执行的，就忍着吧，我们总是对自己很残忍，对他人很友善的。
总之此处要面对的就是项目中有大量的长耗时任务，需要在页面上点击某个按钮后立即返回，还要知道任务执行的情况。
解决方法
办法总比问题多，总是有解决的方法的。我用到的技术主要是自定义注解、AOP、@Async。不太了解的请自行扫盲，此处不做展开。
具体代码
自定义注解
import java.lang.annotation.*;
/**
* 后续操作
* @author 李庆海
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aftermath {
/**
* 运行结果保存的路径
* 相对路径是指相对prefix返回值而言
* @return
*/
String path() default "";
/**
* 运行结果保存的根路径
* @return
*/
String prefix() default "/devops/ydhxg/";
}
善后处理拦截器
import cn.com.yd.cygp4.webinterface.YuandayunHelper;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
import java.lang.reflect.Method;
/**
* 后续操作拦截器
*
* @author 李庆海
*/
@Aspect
@Component
@Slf4j
public class AftermathInterceptor {
@Pointcut("@annotation(cn.com.yd.cygp4.webinterface.annotations.Aftermath)")
public void aspect() {
}
@Around(value = "aspect()")
public Object around(ProceedingJoinPoint point) throws Throwable {
log.debug("进入事后处理");
Object reO = null;
// 返回目标对象
Object target = point.getTarget();
String targetName = target.getClass().getName();
// 返回当前连接点签名
String methodName = point.getSignature().getName();
// 获得参数列表
Object[] arguments = point.getArgs();
Class<?> targetClass = Class.forName(targetName);
// 获取参数类型数组
Class<?>[] argTypes = ReflectUtils.getClasses(arguments);
// 获取目标method,考虑方法的重载等问题
Method method = targetClass.getDeclaredMethod(methodName, argTypes);
// 获取目标method上的注解
Aftermath annotation = method.getAnnotation(Aftermath.class);
if (null != annotation) {
String status = null;
StopWatch clock = new StopWatch();
//计时开始
clock.start();
try {
reO = point.proceed();
status = "成功";
}catch(Exception e){
status = "失败";
}finally {
clock.stop();
JSONObject json = new JSONObject();
//执行状态
json.put("status",status);
// 花费的时间
json.put("take",clock.getTotalTimeSeconds());
String path = annotation.path();
if(null == path || "".equals(path)){
path = targetName+"/"+methodName;
}
path = annotation.prefix()+path;
System.out.println("path:"+path);
System.out.println(json);
YuandayunHelper.delete(path);
YuandayunHelper.add(path,json);
}
} else {
reO = point.proceed();
}
log.debug("退出事后处理");
return reO;
}
}
异步执行
开启异步执行
/**
* Springboot 程序入口
*
* @author 李庆海
*/
@SpringBootApplication
@EnableAsync
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Bean(name = "threadPoolTaskExecutor")
public Executor threadPoolTaskExecutor() {
return new ThreadPoolTaskExecutor();
}
}
在目标方法上添加@Async
@Async
public Object chushihuagupiaogainian() {
//do something;
return something;
}
长耗时异步执行示例
import cn.com.yd.cygp4.webinterface.annotations.Aftermath;
import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 龙虎榜手动管理Controller
*
* @author 李庆海
*/
@RestController
@RequestMapping("${admin-url}")
@Api(tags = "后台管理")
public class AdminController {
/**
* 初始化
*
* @return
*/
@GetMapping("/init")
@ApiOperation("后台管理 > 数据初始化")
@Aftermath
@Async
public Object init() {
//此处耗时5m;
return something;
}
最后
这些代码都是从实际开发中提炼出来的，与业务具有一定的绑定。为了跳出局限使其具有通用性，可以进行一些优化，比如将写入操作抽象一个接口如IWrite，定义一个方法write（String path，String content），然后根据场景进行实现即可达到通用的目的。关于执行结果的获取就更好办了，可以是监听、可以是轮询。
