阅读数:2972 评论数:0

一、自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明一个配置参数。方法的名称就是参数的名称，返回值类型就是参数类型（返回值类型只能是基本类型、Class、String、enum或相关数组），可以通过default来声明参数的默认值。

1、格式

public @interface 注解名 {定义体}

2、定义体里的参数该怎么设定

（1）只能用public或默认（default）这两个访问权修饰。例如String value(); 这里把方法设为default默认类型。

（2）如果只有一个参数成员，最好把参数名称设为“value”，后加小括号。

自定义注解如果没有增加解析代码是没有任何效果的，可以借助Spring AOP帮忙拦截使用了这个注解的所有方法 ，在执行注解所在方法之前或者之后可以增加自己的处理逻辑。

二、示例：

1、创建自定义注解LogAnnotation

import java.lang.annotation.*;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited()
public @interface LogAnnotation {
    String desc();
}

2、使用aop解析注解

通过@Aspect注解使类成为切面类，通过@Pointcut指定切入点，这里指的切入点是LogAnnotation注解类型，也就是被@LogAnnotation注解修改的方法，进入该切入点。

package com.blue.module.annotation;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
 
@Aspect //AOP 切面
@Component
public class CommonLogAspect {
 
    /*通过@Pointcut指定切入点 ，这里指定的切入点为LogAnnotation注解类型，也就是
      被@LogAnnotation注解修饰的方法，进入该切入点*/
    @Pointcut(value = "@annotation(com.blue.module.annotation.LogAnnotation)")
    private void pointcut() {
 
    }
 
    /**
     * 在方法执行前后
     *
     * @param point
     * @param logA
     * @return
     */
    @Around(value = "pointcut() && @annotation(logA)")
    public Object around(ProceedingJoinPoint point, LogAnnotation logA) {
 
        System.out.println("执行了around方法");
 
        String msg = logA.desc();
        //拦截的类名
        Class clazz = point.getTarget().getClass();
        //拦截的方法
        Method method = ((MethodSignature) point.getSignature()).getMethod();
 
        System.out.println("执行了类:" + clazz + " 方法:" + method + " 自定义消息:" + msg);
 
        try {
            return point.proceed(); //执行程序
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return throwable.getMessage();
        }
    }
 
    /**
     * 方法执行后
     *
     * @param joinPoint
     * @param logA
     * @param result
     * @return
     */
    @AfterReturning(value = "pointcut() && @annotation(logA)", returning = "result")
    public Object afterReturning(JoinPoint joinPoint, LogAnnotation logA, Object result) {
        System.out.println("执行了afterReturning方法: result=" + result);
        return result;
    }
 
    /**
     * 方法执行后 并抛出异常
     *
     * @param joinPoint
     * @param logAnnotation
     * @param ex
     */
    @AfterThrowing(value = "pointcut() && @annotation(logAnnotation)", throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, LogAnnotation logAnnotation, Exception ex) {
        System.out.println("执行了afterThrowing方法");
        System.out.println("请求：" + logAnnotation.desc() + " 出现异常");
    }
 
}

3、注解的使用

@RestController
public class TestController{
 
    @LogAnnotation(desc="My annotation")
    @RequestMapping("/hello")
    public String hello() {
        return "hello";
    }
}