SpringBoot+AOP+自定义注解，实现日志记录-蒲公英云

一.定义自定义注解

import java.lang.annotation.*;
/**
 * @author awen
 * 定义注解目的 想让他当作切点
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME) //.java .class 字节码
@Documented
public @interface Log {
    /**
     * 处理类型
     *
     * @return {@link String}
     */
    String handleType() default "";
    /**
     * 操作功能
     *
     * @return {@link String}
     */
    String cagn() default "";
}

1.@Target 这个注解可以往什么上面加这个就是可以往方法上面加

2.Retention 在哪个生命周期生效

生命周期: .java文件 .class文件 字节码文件(最常用 RUNTIME)

3.@Documented 的含义 @Document 是 java 在生成文档，显示注解

4.注意注解里面的定义

类型 +参数名字() 默认值 xx:

二.AOP切面类编写

1.导包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2.切面类

import com.alibaba.fastjson.JSONObject;
import com.example.demo2.service.CjzlMarkService;
import com.example.demo2.utils.JsonResult;
import com.example.demo2.utils.SpringFactoryUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
 * 操作记录切点
 *
 * @author awen
 * @date 2022/12/03
 */
@Aspect //让springboot 知道我是切点
@Component //让springboot 识别到
@DependsOn("springFactoryUtils")
public class CzjlMark {
    private static Map<String,CjzlMarkService> beanMap = SpringFactoryUtils.getBeanMap(CjzlMarkService.class);
    /**
     * 日志切点
     */
    //1.定义切点  往哪里切 通过注解来去切 
    @Pointcut("@annotation(com.example.demo2.annotation.Log)")
    //这个方法就和形参一样 他不会执行他就是代表着我们真实切入的那些方法
    public void logPointCut(){
        System.out.println(1);
    };
    //2.实现切点 ,切点前执行,和方法一起执行,方法执行完之后执行
    //在切点前执行
    @Before("logPointCut()&&@annotation(log)")  //参数是切点 和 切点对象
    public void beforePointCut(JoinPoint joinPoint,Log log){
        Object[] args = joinPoint.getArgs();
        CjzlMarkService cjzlMarkService = beanMap.get(log.handleType());
        cjzlMarkService.before(args,log);
    }
    //切点执行完之后执行
    @AfterReturning(returning = "result",value = "logPointCut()")    //返回值result拿到这个结果 看看返回成功了嘛
    public void afterPointCut(JoinPoint joinPoint,Object result){
        JSONObject jsonResult = (JSONObject) result;
        if(200==Integer.valueOf(jsonResult.get("code").toString())){
            Object[] args = joinPoint.getArgs();
            MethodSignature signature = (MethodSignature)joinPoint.getSignature();
            CjzlMarkService cjzlMarkService = beanMap.get(signature.getMethod().getAnnotation(Log.class).handleType());
            cjzlMarkService.after(args,signature);
        }
    }
    //和方法一起执行 很少用
    public void aroundPointCut(){}
}

3.工具类SpringUtils 用于获取Spring管理的bean

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class SpringFactoryUtils implements ApplicationContextAware {
    //Spring中的核心接口和容器，允许容器通过应用程序上下文环境创建、获取、管理bean
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringFactoryUtils.applicationContext = applicationContext;
    }
    /**
     * 获取applicationContext
     *
     * @return
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
    /**
     * 通过name获取 Bean.
     *
     * @param name
     * @return
     */
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }
    /**
     * 通过class获取Bean.
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }
    /**
     * 通过name,以及Clazz返回指定的Bean
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
    public static <T> Map<String, T> getBeanMap(Class<T> clazz) {
        return getApplicationContext().getBeansOfType(clazz);
    }
}

4.返回类 JsonResult

import com.alibaba.fastjson.JSONObject;
public class JsonResult {
    private JsonResult() {
        throw new IllegalStateException("Utility class");
    }
    public static JSONObject ok(String msg, Object data) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", msg);
        jsonObject.put("data", data);
        jsonObject.put("code", 200);
        return jsonObject;
    }
    public static JSONObject ok(String msg) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", msg);
        jsonObject.put("code", 200);
        return jsonObject;
    }
    public static JSONObject not0k(String msg) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", msg);
        jsonObject.put("code", 500);
        return jsonObject;
    }
}

5.Service 前后执行什么

import com.example.demo2.annotation.Log;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
@Component
@Slf4j
public abstract class CjzlMarkService {
    public  void before(Object[] args, Log loga){
        log.info("handle:{},入参:{}",loga.handleType(),args);
    };
    public abstract void after(Object[] args, MethodSignature signature);
}

6.实现类我们可以写多个实现类然后通过Componet里的value来区分这个value 和注解类 Log里面的handleType是一致的

import com.example.demo2.annotation.Log;
import com.example.demo2.service.CjzlMarkService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
@Component("bmcx")
@Slf4j
public class bmcxCjzlService extends CjzlMarkService {
    @Override
    public void after(Object[] args, MethodSignature signature) {
        log.info("handle:{},入参:{}",signature.getMethod().getAnnotation(Log.class).handleType(),args);
    }
}

7.测试

@Log(handleType = "bmcx",cagn="部门查询")
    @GetMapping("getAll")
    public JSONObject getAll(){
        List<UserPo> userPos = userMapper.selectList(null);
        return JsonResult.ok("成功",userPos);
    }