一、Spring AOP 注解使用

该文章为使用AOP来做日志统计
转自：https://blog.csdn.net/liaomingwu/article/details/125198728

@Around注解可以用来在调用一个具体方法前和调用后来完成一些具体的任务。

比如我们想在执行controller中方法前打印出请求参数，并在方法执行结束后来打印出响应值，这个时候，我们就可以借助于@Around注解来实现；

再比如我们想在执行方法时动态修改参数值等

类似功能的注解还有@Before等等，用到了Spring AOP切面思想，Spring AOP常用于拦截器、事务、日志、权限验证等方面。

完整演示代码如下：

需要说明的是，在以下例子中，我们即可以只用@Around注解，并设置条件，见方法run1()；也可以用@Pointcut和@Around联合注解，见方法pointCut2()和run2()，这2种用法是等价的。如果我们还想利用其进行参数的修改，则调用时必须用joinPoint.proceed(Object[] args)方法，将修改后的参数进行回传。如果用joinPoint.proceed()方法，则修改后的参数并不会真正被使用。

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.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import javax.persistence.EntityManager;
 
/**
 * 控制器切面
 *
 * @author lichuang
 */
 
@Component
@Aspect
public class ControllerAspect {
 
    private static final Logger logger = LoggerFactory.getLogger(ControllerAspect.class);
 
    @Autowired
    private EntityManager entityManager;
 
    /**
     * 调用controller包下的任意类的任意方法时均会调用此方法
     */
    @Around("execution(* com.company.controller.*.*(..))")
    public Object run1(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取方法参数值数组
        Object[] args = joinPoint.getArgs();
        //得到其方法签名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取方法参数类型数组
        Class[] paramTypeArray = methodSignature.getParameterTypes();
        if (EntityManager.class.isAssignableFrom(paramTypeArray[paramTypeArray.length - 1])) {
            //如果方法的参数列表最后一个参数是entityManager类型，则给其赋值
            args[args.length - 1] = entityManager;
        }
        logger.info("请求参数为{}",args);
        //动态修改其参数
        //注意，如果调用joinPoint.proceed()方法，则修改的参数值不会生效，必须调用joinPoint.proceed(Object[] args)
        Object result = joinPoint.proceed(args);
        logger.info("响应结果为{}",result);
        //如果这里不返回result，则目标对象实际返回值会被置为null
        return result;
    }
 
    @Pointcut("execution(* com.company.controller.*.*(..))")
    public void pointCut2() {}
 
    @Around("pointCut2()")
    public Object run2(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取方法参数值数组
        Object[] args = joinPoint.getArgs();
        //得到其方法签名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        //获取方法参数类型数组
        Class[] paramTypeArray = methodSignature.getParameterTypes();
        if (EntityManager.class.isAssignableFrom(paramTypeArray[paramTypeArray.length - 1])) {
            //如果方法的参数列表最后一个参数是entityManager类型，则给其赋值
            args[args.length - 1] = entityManager;
        }
        logger.info("请求参数为{}",args);
        //动态修改其参数
        //注意，如果调用joinPoint.proceed()方法，则修改的参数值不会生效，必须调用joinPoint.proceed(Object[] args)
        Object result = joinPoint.proceed(args);
        logger.info("响应结果为{}",result);
        //如果这里不返回result，则目标对象实际返回值会被置为null
        return result;
    }
}

以上内容为转载 https://blog.csdn.net/lichuangcsdn/article/details/87741811

下面为自己的使用的两个案例
结构图

package com.gaia.web.aop;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.gaia.common.model.enums.CacheKeyEnum;
import com.gaia.common.service.RedisCacheService;
import com.gaia.common.util.SchoolYearUtils;
import com.gaia.user.model.GrowthCreditDO;
import com.gaia.user.model.GrowthTaskConfigDO;
import com.gaia.user.model.UserDO;
import com.gaia.user.model.enums.GrowthTaskJumpEnum;
import com.gaia.user.service.GrowthService;
import com.gaia.user.service.GrowthTaskConfigService;
import com.gaia.web.auth.shiro.ShiroUtil;
import org.apache.log4j.Logger;
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.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 成长体系 任务行为的aop 需要设置成b一台机器运行任务的监听轮训
 */
@Aspect
@Component("creditTaskAspect")
public class  CreditTaskAspect {

    @Resource
    HttpServletRequest request;

    @Resource
    RedisCacheService  redisCacheService;

    @Resource
    GrowthService growthService;

    @Resource
    GrowthTaskConfigService growthTaskConfigService;

    private static final Logger logger = Logger.getLogger("GROWTH_TASK");

    @Pointcut("@annotation(com.gaia.web.aop.CreditTaskAOP)")
    public void CreditPointCut(){

    }

    /**
     * task处理  任务处理数据库的操作要事务 redis可以异步 后面改
     */
    @Around("CreditPointCut()")
    public Object isRightTask(ProceedingJoinPoint point){
        //请求成功判断
        Object proceed = null;
        //commit任务类型区分
        String type = "";
        try {
            proceed = point.proceed();
            UserDO user = ShiroUtil.getUser();
            if (user == null || !user.getRole().equals("student")){
                return proceed;
            }
            String proceedJson = JSONObject.toJSONString(proceed);
            Map jsonMap = JSON.parseObject(proceedJson);
            //错误码
            //针对success为存在的且为false的情况
            Object success = jsonMap.get("success");
            if (success != null){
                if (!((Boolean) success).booleanValue()){
                    return proceed;
                }else {
                    //判断data中错误情况
                    Object obj = jsonMap.get("data");
                    if (obj instanceof  JSONObject){
                        if (((JSONObject) obj).size()>1){
                            //判断是否是错误码
                            Object obj2 = ((JSONObject) obj).get("result");
                            if (obj2 != null){
                                Boolean isSuccess = (boolean) ((JSONObject) obj).get("result");
                                if (isSuccess != null && !isSuccess){
                                    return proceed;
                                }
                            }
                        }
                    }
                }
            }
            type = (String) jsonMap.get("remark");
        }catch (Throwable e){
            return proceed;
        }
        //获取请求的URI,然后获取到方法的/isvLogin  根据这个地址来匹配，并不是taskType
        String uri =request.getRequestURI();
        String taskUri = uri.substring(uri.lastIndexOf("/")+1);
        String taskType = "";
        switch (taskUri){
            case "likePC": taskType= GrowthTaskJumpEnum.LIKE.getCode();
                break;
            case "like": taskType= GrowthTaskJumpEnum.LIKE.getCode();
                break;
            case "uploadBookRequired": taskType= GrowthTaskJumpEnum.READING_WISH.getCode();
                break;
            case "addMedal": taskType= GrowthTaskJumpEnum.ANTI_DRUG_MEDAL.getCode();
                break;
            case "login": taskType= GrowthTaskJumpEnum.LOGIN_IN.getCode();
                break;
                //钉钉登录 组织架构登录
            case "isvLogin": taskType= GrowthTaskJumpEnum.LOGIN_IN.getCode();
                break;
            case "afterLogin": taskType= GrowthTaskJumpEnum.LOGIN_IN.getCode();
                break;
                //支付宝免登 钉钉登录
            case "ssoLogin": taskType= GrowthTaskJumpEnum.LOGIN_IN.getCode();
                break;
            case "commit": taskType= "exam_commit";
                break;
            case "getAttention" : taskType= GrowthTaskJumpEnum.ATTENTION.getCode();
                break;
                //马云推荐
            case "addTMTask": taskType= GrowthTaskJumpEnum.TEACHER_MA.getCode();
                break;
        }
        if (StringUtils.isEmpty(taskType)){
            return proceed;
        }else if (taskType.equals("exam_commit")){
            //四个考试判断
            if (!StringUtils.isEmpty(type)){
                switch (type){
                    case "final": taskType= GrowthTaskJumpEnum.FINAL_EXAM.getCode();
                        break;
                    case "self": taskType= GrowthTaskJumpEnum.SELF_STUDY_FINAL_EXAM.getCode();
                        break;
                    case "course": taskType= GrowthTaskJumpEnum.COURSE_CENTER_FINAL_EXAM.getCode();
                        break;
                    case "quiz": taskType= GrowthTaskJumpEnum.QUIZ.getCode();
                        break;
                    default: taskType ="";
                        break;
                }
            }else {
                return proceed;
            }
            if (StringUtils.isEmpty(taskType)){
                return proceed;
            }
        }
        UserDO user = ShiroUtil.getUser();
        try {
            //日志1
            logger.info(user.getId()+":"+taskType);
            judgeTask(taskType,user);
        }catch (Exception e){
            logger.info(new Date()+","+"schoolId,"+user.getId()+","+taskType+","+e.getMessage().toString());
            throw e;
        }
        finally {
            return proceed;
        }
    }

    /**
     * 任务处理
     * @param taskType
     */
    private void judgeTask(String taskType, UserDO user) {
        //判断是否是符合条件的积分任务
        if (StringUtils.isEmpty(taskType)){
            return;
        }
        // 获取任务配置表
        List<GrowthTaskConfigDO> growthTaskConfigDOList = (List<GrowthTaskConfigDO>) redisCacheService.redisGet(CacheKeyEnum.CREDIT_TASK.getCode());
        if (CollectionUtils.isEmpty(growthTaskConfigDOList)){
            growthTaskConfigDOList =  growthTaskConfigService.getAllTaskList(0);
            redisCacheService.redisPut(CacheKeyEnum.CREDIT_TASK.getCode(),growthTaskConfigDOList);
        }
        GrowthTaskConfigDO growthTaskConfigDO = growthTaskConfigDOList.stream().filter(item-> item.getRemark() != null && taskType.equals(item.getRemark())).findAny().orElseGet(()->null);
        if (growthTaskConfigDO == null){
            logger.info(user.getId()+"做的任务 "+taskType+" 不存在");
            return;
        }
        //任务时间是否开始 是否结束
        Date date = new Date();
        if (growthTaskConfigDO.getStartTime().after(date) || growthTaskConfigDO.getEndTime().before(date)){
            return;
        }
        //course转must
        boolean isMust = false;
        if (taskType.equals(GrowthTaskJumpEnum.COURSE_CENTER_FINAL_EXAM.getCode())){
            String mustTaskType = GrowthTaskJumpEnum.LEARN_TWO_CLASS.getCode();
            GrowthTaskConfigDO mustGrowthTaskConfigDO = growthTaskConfigDOList.stream().filter(item-> item.getRemark() != null && mustTaskType.equals(item.getRemark())
                    && item.getStartTime().before(date) && item.getEndTime().after(date)).findAny().orElseGet(()->null);
            if (mustGrowthTaskConfigDO != null){
                //判断must完成度
                String key = CacheKeyEnum.TASK_FINISH_NUM.getCode().concat(mustGrowthTaskConfigDO.getId().toString()).concat(user.getId().toString());
                String num = (String) redisCacheService.get(key);
                if (!StringUtils.isEmpty(num)){
                    Long num2 = Long.parseLong(num);
                    if (num2 < mustGrowthTaskConfigDO.getTaskNum()){
                        growthTaskConfigDO = mustGrowthTaskConfigDO;
                        isMust = true;
                    }
                }else {
                    growthTaskConfigDO = mustGrowthTaskConfigDO;
                    isMust = true;
                }
            }
        }

        // 检查redis完成度次数
        if (!isMust){
            String key = CacheKeyEnum.TASK_FINISH_NUM.getCode().concat(growthTaskConfigDO.getId().toString()).concat(user.getId().toString());
            logger.info(user.getId()+"key"+key);
            String num1 = (String) redisCacheService.get(key);
            if (!StringUtils.isEmpty(num1)){
                Long num = Long.parseLong(num1);
                logger.info(user.getId()+"num"+num);
                if (num >= growthTaskConfigDO.getTaskNum()){
                    return;
                }
            }
        }
        //执行任务操作
        doTask(growthTaskConfigDO, user);
    }

    /**
     * 执行任务逻辑
     * @param growthTaskConfigDO
     * @param user
     */
    @Transactional("distributedTransactionManager")
    private void doTask(GrowthTaskConfigDO growthTaskConfigDO, UserDO user) {
        growthService.creditTask(growthTaskConfigDO,user);
        doRedisTask(growthTaskConfigDO,user);
    }

    /**
     * redis任务操作部分
     * @param growthTaskConfigDO
     * @param user
     */
    public void doRedisTask(GrowthTaskConfigDO growthTaskConfigDO, UserDO user){
        try {
            //redis 任务完成度+1
            String key = CacheKeyEnum.TASK_FINISH_NUM.getCode().concat(growthTaskConfigDO.getId().toString()).concat(user.getId().toString());
            // 自增
            Boolean isExist = true;
            if (!redisCacheService.hasKey(key)){
                isExist = false;
            }
            redisCacheService.counterUpdate(key,1L);
            if (!isExist){
                //新增需要设置过期时间
                Long expireTime = getExpireTime(growthTaskConfigDO);
                redisCacheService.expireTime(key, expireTime, TimeUnit.SECONDS);
            }
            //学分增加逻辑
            //获取数据库学分总分
            GrowthCreditDO growthCreditDO = growthService.getCreditByUserId(user.getId(), SchoolYearUtils.getSchoolYear());
            Long totalCredit =0L;
            if (growthCreditDO != null){
                totalCredit = growthCreditDO.getCredit();
            }
            redisCacheService.addCredit(user.getSchoolId(), user.getClassId(), user.getId(), growthTaskConfigDO.getCredit(), totalCredit);
        }catch (Exception e){
            logger.info(new Date()+",schoolId,"+user.getId()+","+growthTaskConfigDO.getId()+","+e.getMessage());
            throw e;
        }
    }


    /**
     * 获取传入时间和现在时间的间隔 second
     * @param growthTaskConfigDO
     * @return
     */
    private long getExpireTime(GrowthTaskConfigDO growthTaskConfigDO) {
        LocalDateTime date = null;
        if (growthTaskConfigDO.getType()==1){
            //每日任务 获取下一天0点时间
            date = getZeroTime();
        }else {
            //自定义任务的结束时间 和当前时间间隔作为过期时间
            Date endTime =  growthTaskConfigDO.getEndTime();
            Instant instant = endTime.toInstant();
            ZoneId zoneId = ZoneId.systemDefault();
            date = instant.atZone(zoneId).toLocalDateTime();
        }
        LocalDateTime now = LocalDateTime.now();
        long time = ChronoUnit.SECONDS.between(now, date);
        return time;
    }

    private LocalDateTime getZeroTime(){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        Date zero = calendar.getTime();
        Instant instant = zero.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime endTime = instant.atZone(zoneId).toLocalDateTime();
        return endTime;
    }
}

package com.gaia.web.aop;

import java.lang.annotation.*;

/**
 * 成长体系 学分任务aop
 * 
 * 常用注解说明：
     * 1. RetentionPolicy(保留策略)是一个enum类型，有三个值
         * SOURCE        --  这个Annotation类型的信息只会保留在程序源码里，源码如果经过了编译后，Annotation的数据就会消失，并不会保留在编译好的.class文件里
         * CLASS         --  这个Annotation类型的信息保留在程序源码中，同时也会保留在编译好的.class文件里面,在执行的时候，并不会把这一些信息加载到虚拟 机(JVM)中去.注意一下，当你没有设定一个Annotation类型的Retention值时，系统默认值是CLASS。
         * RUNTIME       --  在源码、编译好的.class文件中保留信息，在执行的时候会把这一些信息加载到JVM中去的。
         *
     * 2.ElementType @Target中的ElementType用来指定Annotation类型可以用在哪些元素上
         * TYPE(类型)    -- 在Class，Interface，Enum和Annotation类型上
         * FIELD        -- 属性上
         * METHOD       -- 方法上
         * PARAMETER    -- 参数上
         * CONSTRUCTOR  -- 构造函数上
         * LOCAL_VARIABLE -- 局部变量
         * ANNOTATION_TYPE   -- Annotation类型上
         * PACKAGE           -- 包上
         *
      * 3.Documented    -- 让这个Annotation类型的信息能够显示在API说明文档上；没有添加的话，使用javadoc生成的API文件找不到这个类型生成的信息
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CreditTaskAOP {
    /**
     * 任务类型
     * @return
     */
    public String taskType() default "";
}

package com.gaia.user.model.enums;

public enum GrowthTaskJumpEnum {
    LIKE("LIKE","点赞"),
    READING_WISH("READING_WISH","益起读书-心愿榜"),
    ANTI_DRUG_MEDAL("ANTI_DRUG_MEDAL","勋章领取"),
    FINAL_EXAM("FINAL_EXAM","期末考试"),
    SELF_STUDY_FINAL_EXAM("SELF_STUDY_FINAL_EXAM","自学课堂学习"),
    COURSE_CENTER_FINAL_EXAM("COURSE_CENTER_FINAL_EXAM","课程中心学习"),
    LEARN_TWO_CLASS("LEARN_TWO_CLASS","学习2课时并通过考试"),
    LOGIN_IN("LOGIN_IN","登录"),
    COMMON("COMMON","一般任务"),
    ATTENTION("ATTENTION","关注任务"),
    QUIZ("QUIZ","知识竞赛"),
    TEACHER_MA("TEACHER_MA","马云推荐"),
    DONATION_STEP("DONATION_STEP","加入青骄战队并完成捐步"),
    ;

    private String code;
    private String desc;

    public static String getCode(String code) {
        for (GrowthTaskJumpEnum item : GrowthTaskJumpEnum.values()) {
            if (item.getCode().equalsIgnoreCase(code)) {
                return item.getCode();
            }
        }
        return null;
    }

    GrowthTaskJumpEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

}

通过Controller中的接口调用

 /**
     * 加入青骄战队并完成捐步
     * @return
     */
    @RequestMapping(value = "addYoungPrideAndDonationStep",method = RequestMethod.GET)
    @ResponseBody
    @CreditTaskAOP(taskType = "加入青骄战队并完成捐步")
    public Result addYoungPrideAndDonationStep(){
        UserDO user = ShiroUtil.getUser();
        if (user == null){
            return SystemResultUtil.fail(ErrorConst.NOT_LOGIN);
        }
        Result result = new Result();
        result.setSuccess(true);
        result.setRemark("DONATION_STEP");
        return result;
    }

/**
     * 登录并授权成功以后回调接口
     *
     * @param ticket
     * @return
     */
    @CreditTaskAOP(taskType = "登陆任务")
    @RequestMapping(value = "/afterLogin", method = RequestMethod.GET)
    @ResponseBody
    @AroundLog(type = "Login")
    public ModelAndView loginCallBack(@RequestParam(name = "ticket", required = false) String ticket) {
        logger.info("回调afterLogin成功,ticket = :" + ticket);
        int year = SchoolYearUtils.getSchoolYear();
        ModelAndView mav = new ModelAndView("redirect:/index");
        if (StringUtils.isBlank(ticket)) {
            mav.addObject("errCode", "err1");
            mav.addObject("errMsg", "非法访问,请联系管理员");
            logger.error("ticket为null", ticket);
            return mav;
        }

/**
     * 点赞
     *
     * @param coupletId
     * @return
     */
    @CreditTaskAOP(taskType = "点赞任务")
    @RequestMapping(value = "/like", method = RequestMethod.GET)
    @ResponseBody
    @AroundLog(type = "couplet")
    public Result thumbsUp(@RequestParam(value = "coupletId", required = true) Long coupletId,
                           HttpServletRequest request) {
        if (InputCheckUtil.isInValidLong(coupletId)) {
            return BusinessResultUtil.fail(ErrorConst.EMPTY_PARAM);
        }
        if (!isRightDate()){
            return BusinessResultUtil.fail(ErrorConst.TIME_IS_OVER);
        }
        //用户
        UserDO user = ShiroUtil.getUser();
        //第三方用户
        String userId = UserCookieUtils.getUserId(request);

        CommonUserInfo thirdUserInfo = null;
        if (!StringUtils.isEmpty(userId)) {
            logger.info("like,CookieUserId:" + userId);
            thirdUserInfo = userBindThirdAccountService.getThirdUserInfo(userId);
        }
        if (user == null && thirdUserInfo == null) {
            return SystemResultUtil.fail(ErrorConst.NOT_LOGIN);
        }
        UserWorksRelationDO userWorksRelationDO = new UserWorksRelationDO();
        userWorksRelationDO.setWorksId(coupletId);
        if (user != null) {
            userWorksRelationDO.setUserId(user.getId().toString());
        } else {
            userWorksRelationDO.setUserId(thirdUserInfo.getUserId());
        }
        //ip
        String ip = HttpUtils.getIpAddress(request);
        userWorksRelationDO.setUserIp(ip);
        ServiceResult result = userWorksRelationService.insert(userWorksRelationDO);
        if (!result.isSuccess()) {
            return BusinessResultUtil.fail(Constant.ERROR_WORKS_USER_LIKE_EXIST);
        }
        //点赞数目增加
        worksService.addLikeCount(coupletId);
        return BusinessResultUtil.success();
    }

日志统计AOP

创建一个注解

/**
 * @Auther: jia
 * @Date: 2018/11/22 16:09
 * @Description:
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AroundLog {


    String type() default "";

}

AOP类

package com.gaia.web.aop;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.gaia.user.model.UserDO;
import com.gaia.web.auth.shiro.ShiroUtil;
import com.gaia.web.util.HttpUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * @Auther: jia
 * @Date: 2018/11/22 15:51
 * @Description:
 */
@Aspect
@Component("logAspect")
public class LogAspect {

    @Resource
    HttpServletRequest request;

    private static final Logger logger = Logger.getLogger("EXECUTED");

    @Around(value = "@annotation(aroundLog)")
    public Object aroundMethod(ProceedingJoinPoint jp, AroundLog aroundLog) {
        // 创建一个计时器
        StopWatch watch = new StopWatch();
        // 计时器开始
        watch.start();
        String SUCCESS = "Y";
        String ERRORS = "";
        Object proceed = null;
        Long userId = null;
        String result = "";

        try {
            proceed = jp.proceed();
            String proceedJson = JSONObject.toJSONString(proceed);
            Map jsonMap = JSON.parseObject(proceedJson);
            Object successObj = jsonMap.get("success");
            if (successObj == null) {
                Object model = jsonMap.get("model");
                String errMsg = JSON.parseObject(model.toString()).getString("errMsg");
                if (StringUtils.isNotEmpty(errMsg)) {
                    SUCCESS = "N";
                    ERRORS = errMsg;
                }
            } else {
                result = successObj.toString();
                if (!Boolean.valueOf(result)) {
                    String errorMsg = jsonMap.get("errorMsg").toString();
                    if (!StringUtils.equals(errorMsg, "未登录或登录已失效，请重新登录") && !StringUtils.equals(errorMsg, "请求已失效，请刷新页面后重试")
                    && !StringUtils.equals(errorMsg, " 你不在钉钉企业里，请联系管理员") && !StringUtils.equals(errorMsg, "用户名或密码错误，请联系管理员")
                    && !StringUtils.equals(errorMsg, "登录失败，请联系管理员")) {
                        SUCCESS = "N";
                        ERRORS = jsonMap.get("errorMsg").toString();
                    }
                }
            }
            UserDO user = ShiroUtil.getUser();
            if (user != null) {
                userId = user.getId();
            }

        } catch (Throwable throwable) {
            SUCCESS = "N";
            ERRORS = throwable.toString();
            logger.error("aroundLog fail", throwable);
        } finally {
            watch.stop();
            logger.info(aroundLog.type() + "," + jp.getSignature().getDeclaringTypeName() + "," + request.getRequestURI() + ","
                    + SUCCESS + "," + watch.getLastTaskTimeMillis() + "," + ERRORS + "," + userId + "," + HttpUtils.getIpAddress(request));

        }
        return proceed;
    }

}

使用

@CreditTaskAOP(taskType = "登录任务")
    @RequestMapping(value = "/isvLogin", method = RequestMethod.POST)
    @ResponseBody
    @AroundLog(type = "Login")
    public Result<String> isvLogin(@RequestBody LoginReqData req, HttpServletRequest request) {

        logger.info("UserController isvLogin isvUserId={}, corpId={}", req.getIsvUserId(), req.getCorpId());
        // 确保参数有值
        if (InputCheckUtil.isEmptyString(req.getCorpId()) ||
                InputCheckUtil.isEmptyString(req.getIsvUserId())) {
            return BusinessResultUtil.fail(ErrorConst.EMPTY_PARAM);
        }
        IsvUserDO isvUserDO = ddEduIsvUserService.findByUserIdAndCorpId(req.getIsvUserId(), req.getCorpId());
        if (Objects.isNull(isvUserDO)) {
            return BusinessResultUtil.fail(ErrorConst.USER_IS_NULL);
        }
        UserDO userDO = userService.selectNoDelById(isvUserDO.getAccUserId());
        if (Objects.isNull(userDO)) {
            return BusinessResultUtil.fail(ErrorConst.USER_IS_NULL);
        }
        String ip = HttpUtils.getIpAddress(request);
        log.info(ip + "," + req.getAccount() + ",logging");
        Result result = userService.loginAccount(userDO.getAccount(), null);

        UserDO user = ShiroUtil.getUser();
        if (user != null) {
            log.info(ip + "," + user.getAccount() + ",success");
        } else {
            log.info(ip + "," + req.getAccount() + ",fail");
        }
        return result;
    }