一文详解Java如何实现自定义注解

public @interface MyAnnotation { }

@Retention(RetentionPolicy.SOURCE)

@Target(ElementType.Field)

//注解用于字段上
@Target(ElementType.FIELD)
//运行时使用
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String message() default  "aaa";
}

@Data
public class Student {
    @JSONField(ordinal =0)
    @MyAnnotation(message = "AAAAAAAAA")
    public String name;
    @MyAnnotation(message = "AAAAAAAAA")
    public Integer score;
}

    public static void main(String[] args) {
        Class<?> studentClass = Student.class;
        Field[] fields = studentClass.getDeclaredFields();//获取所有的类成员变量字段
        for (Field field : fields) {
            String fieldName = field.getName(); //获取该类成员变量的名字
            System.out.println("成员变量名是：" + fieldName);
            Annotation[] annotations = field.getAnnotations(); //获取该类成员变量上所有声明周期是运行时的注解
            for (Annotation annotation : annotations) {
                Class<? extends Annotation> annotationType = annotation.annotationType();
                String annotationName = annotationType.getSimpleName();//注解的简短名称
                System.out.println(" 使用的注解是：" + annotationName);
                //判断该注解是不是 MyAnnotation 注解，是的话打印其 id 和 describe 属性
                if (annotationType.equals(MyAnnotation.class)) {
                    MyAnnotation myAnnotation = field.getAnnotation(MyAnnotation.class);
                    String message = myAnnotation.message();
                    System.out.println("    MyAnnotation注解中的message是：" + message);

                }
            }
            System.out.println();
        }
    }

//注解用于方法
@Target(ElementType.METHOD)
//运行时使用
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String message() default  "aaa";

}

@Component
@Aspect
@Slf4j
public class MyAnnotationAspect {
    /*
     * 这是一个切入点
     * */
    @Pointcut("@annotation(com.demo.aaa.annotation.MyAnnotation)")
    public void cutMethod(){
    }
    /**
     * 切点之前
     */
    @Before("cutMethod()")
    public void before(JoinPoint joinPoint) throws Throwable {
        log.info("============ before ==========");
    }
    /**
     * 切点之后
     */
    @After("cutMethod()")
    public void after() throws Throwable {
        log.info("============ after ==========");
    }
    /**
     * 切点返回内容后
     */
    @AfterReturning("cutMethod()")
    public void afterReturning() throws Throwable {
        log.info("============ afterReturning ==========");
    }
    /**
     * 切点抛出异常后
     */
    @AfterThrowing("cutMethod()")
    public void afterThrowing() throws Throwable {
        log.info("============ afterThrowing ==========");
    }
    @Around("cutMethod() && @annotation(myAnnotation)")
    public Object around(ProceedingJoinPoint point, MyAnnotation myAnnotation) throws Throwable {
        log.info("============ around1 ==========");
        Object  obj= point.proceed(point.getArgs());
        log.info("============ around2 ==========");
        return obj;
    }
}

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

    @GetMapping("/aaa")
    @MyAnnotation(message = "成功拉！！！！！！！！！！！！")
    public void test() {
        System.out.println("执行代码逻辑");
    }

@Pointcut("args(java.lang.String)")  //这样就是错的，不能单独使用要匹配到某些类

@Pointcut("within(com.example.demo.service.impl.UserServiceImpl) && args(java.lang.String,java.lang.String)") //要像这样使用 within 先匹配到某个具体的类，在使用args匹配到某个类型参数的方法

@Pointcut("within(com.demo.RedisTest) && @args(com.demo.aaa.annotation.MyAnnotation)")

//within表达式的粒度为类，其参数为全路径的类名（可使用通配符），表示匹配当前表达式的所有类都将被当前方法环绕。如下是within表达式的语法：
@Pointcut(within(declaring-type-pattern))

//within表达式只能指定到类级别，如下示例表示匹配com.spring.service.BusinessObject中的所有方法：
@Pointcut(within(com.spring.service.BusinessObject))
      
//within表达式路径和类名都可以使用通配符进行匹配，比如如下表达式将匹配com.spring.service包下的所有类，不包括子包中的类：
@Pointcut(within(com.spring.service.*))

//如下表达式表示匹配com.spring.service包及子包下的所有类：
@Pointcut(within(com.spring.service..*))

//如下所示示例表示匹配使用com.spring.annotation.BusinessAspect注解标注的类：
@within(com.spring.annotation.BusinessAspect)

@Pointcut("@annotation(com.test.annotations.LogAuto)")

modifiers-pattern：方法的可见性修饰符，如 public，protected，private；
ret-type-pattern：方法的返回值类型，如 int，void 等；
declaring-type-pattern：方法所在类的全路径名，如 com.spring.Aspect；
name-pattern：方法名，如 getOrderDetail()；
param-pattern：方法的参数类型，如 java.lang.String；
throws-pattern：方法抛出的异常类型，如 java.lang.Exception；
示例：

// 匹配目标类的所有 public 方法，第一个 * 代表返回类型，第二个 * 代表方法名，..代表方法的参数
execution(public * *(..))

// 匹配目标类所有以 User 为后缀的方法。第一个 * 代表返回类型，*User 代表以 User 为后缀的方法
execution(* *User(..))

// 匹配 User 类里的所有方法
execution(* com.test.demo.User.*(..))

// 匹配 User 类及其子类的所有方法
execution(* com.test.demo.User+.*(..)) :

// 匹配 com.test 包下的所有类的所有方法
execution(* com.test.*.*(..))

// 匹配 com.test 包下及其子孙包下所有类的所有方法
execution(* com.test..*.*(..)) :

// 匹配 getOrderDetail 方法，且第一个参数类型是 Long，第二个参数类型是 String
execution(* getOrderDetail(Long, String))

   @Around(value = "@annotation(basisLogAnnotation)")
    public Object demoAop(ProceedingJoinPoint proceedingJoinPoint, final BasisLogAnnotation basisLogAnnotation) throws Throwable {
 
        logger.debug("执行前：");
 
        Object object = proceedingJoinPoint.proceed();  //执行连接点方法，object：方法返回值
 
        logger.debug("执行后：");
 
 
        // 类名
        String className = proceedingJoinPoint.getTarget().getClass().getName();
        //方法名
        String methodName = proceedingJoinPoint.getSignature().getName();
        //参数（我这里是对象，具体根据个人的参数类型来强转）
        BasisUser basisUser = (BasisUser)proceedingJoinPoint.getArgs()[0];
        return object;
    }