JAVA项目AOP应用-任务流程执行续跑处理

通过如下aop任务配置，可以实现任务执行结果记录，如有任务失败可以进行任务续跑（已经执行成功的任务跳过执行）

任务执行参数

用于记录任务执行是否当前步骤执行状态，
taskRunStatuses是记录下本次执行任务状态
lastTaskRunStatuses记录是上次任务执行任务状态

/**
 * 任务流程通用参数
 *
 * @author yufeng
 * @version V1.0
 * @date 2018-07-03 10:04
 */
public class TaskParam {
    private StringBuffer runLog;
    private InterruptMsg interruptMsg;
    private boolean reRun;
    private Queue<TaskStatus> taskRunStatuses;
    private Queue<TaskStatus> lastTaskRunStatuses;

    public TaskParam() {

    }

    public TaskParam(StringBuffer runLog, InterruptMsg interruptMsg, boolean reRun, Queue<TaskStatus> taskRunStatuses, Queue<TaskStatus> lastTaskRunStatuses) {
        this.runLog = runLog;
        this.interruptMsg = interruptMsg;
        this.reRun = reRun;
        this.taskRunStatuses = taskRunStatuses;
        this.lastTaskRunStatuses = lastTaskRunStatuses;
    }

    public StringBuffer getRunLog() {
        return runLog;
    }

    public void setRunLog(StringBuffer runLog) {
        this.runLog = runLog;
    }

    public InterruptMsg getInterruptMsg() {
        return interruptMsg;
    }

    public void setInterruptMsg(InterruptMsg interruptMsg) {
        this.interruptMsg = interruptMsg;
    }

    public boolean isReRun() {
        return reRun;
    }

    public void setReRun(boolean reRun) {
        this.reRun = reRun;
    }

    public Queue<TaskStatus> getTaskRunStatuses() {
        return taskRunStatuses;
    }

    public void setTaskRunStatuses(Queue<TaskStatus> taskRunStatuses) {
        this.taskRunStatuses = taskRunStatuses;
    }

    public Queue<TaskStatus> getLastTaskRunStatuses() {
        return lastTaskRunStatuses;
    }

    public void setLastTaskRunStatuses(Queue<TaskStatus> lastTaskRunStatuses) {
        this.lastTaskRunStatuses = lastTaskRunStatuses;
    }
}

任务执行步骤状态类

用于记录任务执行是否成功和执行结果记录。

**
 * @author yunfeng
 * @version V.1.0
 * @title
 * @Desc
 * @create 2018-06-30 16:23
 **/
public class TaskStatus {

    private boolean success;
    private String runType;
    private String runDesc;
    private Object runRet;


    public TaskStatus(boolean success, String runType, String runDesc) {
        this.runType = runType;
        this.runDesc = runDesc;
        this.success = success;
    }

    public TaskStatus(boolean success, String runType, String runDesc, Object runRet) {
        this.success = success;
        this.runType = runType;
        this.runDesc = runDesc;
        this.runRet = runRet;
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public String getRunType() {
        return runType;
    }

    public void setRunType(String runType) {
        this.runType = runType;
    }

    public String getRunDesc() {
        return runDesc;
    }

    public void setRunDesc(String runDesc) {
        this.runDesc = runDesc;
    }

    public Object getRunRet() {
        return runRet;
    }

    public void setRunRet(Object runRet) {
        this.runRet = runRet;
    }
}

import cn.process.common.TaskParam;
import cn.common.TaskStatus;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.util.Queue;

/**
 *
 * 任务流程执行AOP处理
 * @author yunfeng
 * @version V1.0
 * @date 2018/7/3 20:24
 */
@Aspect
@Component
public class TaskHandleAspect {
    private final static Logger logger = LoggerFactory.getLogger(TaskHandleAspect.class);

    private boolean isNotNext(boolean reRun, Queue<TaskStatus> lastTask) {
        TaskStatus taskStatus = lastTask == null ? null : lastTask.isEmpty() ? null : lastTask.remove();
        boolean isNotNext = reRun && taskStatus != null && taskStatus.isSuccess();
        return isNotNext;
    }

    /**
     * 配置的是任务流程包下的所有方法，方法参数需要规范
     */
    @Pointcut("execution(public * cn.webank.ci.citask.process.handle.*.*Handle(..))")
    public void taskHandle() {
    }


    /**
     * 环绕通知,环绕增强，相当于MethodInterceptor
     *
     * @param pjp
     * @return
     */
    @Around("taskHandle()")
    public Object arround(ProceedingJoinPoint pjp) {
        logger.info("方法环绕start.....");
        Object[] args = pjp.getArgs();
        TaskParam taskParam = (TaskParam) args[0];
        Integer taskLogId = (Integer) args[1];
        String process = (String) args[2];
        Queue<TaskStatus> runTask = taskParam.getTaskRunStatuses();
        Queue<TaskStatus> lastTask = taskParam.getLastTaskRunStatuses();
        boolean reRun = taskParam.isReRun();
        TaskStatus runStatus = null;
        Object object = null;
        TaskStatus lastStatus = (lastTask == null || lastTask.isEmpty()) ? null : lastTask.remove();
        if (isNotNext(reRun, lastTask)) {
            runStatus = lastStatus;
        } else {
            try {
                //执行流程
                object = pjp.proceed();
                runStatus = (TaskStatus) object;
            } catch (Throwable e) {
                runStatus = new TaskStatus(false, process, "程序因异常中断,详情：" + e.toString(), null);
                logger.error(e.toString(), e);
            }
        }
        runTask.offer(runStatus);
        runStatus = (TaskStatus) object;
        return runStatus;
    }
}