java自定义注解及使用场景（并学习：拦截器+AOP）

Java自定义注解一般使用场景为：自定义注解+拦截器或者AOP，使用自定义注解来自己设计框架，使得代码看起来非常优雅。
本文将先从自定义注解的基础概念说起，然后开始实战，写小段代码实现自定义注解+拦截器，自定义注解+AOP。

一、什么是注解(Annotation)

Java注解是什么，以下是引用自维基百科的内容

Java注解又称Java标注，是JDK5.0版本开始支持加入源代码的特殊语法元数据。
Java语言中的类、方法、变量、参数和包等都可以被标注。和Javadoc不同，Java标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java虚拟机可以保留标注内容，在运行时可以获取到标注内容。 当然它也支持自定义Java标注。

二、注解体系图

元注解：java.lang.annotation中提供了元注解，可以使用这些注解来定义自己的注解。主要使用的是Target和Retention注解

注解处理类： 既然上面定义了注解，那得有办法拿到我们定义的注解啊。java.lang.reflect.AnnotationElement接口则提供了该功能。注解的处理是通过java反射来处理的。如下，反射相关的类Class, Method, Field都实现了AnnotationElement接口。


因此，只要我们通过反射拿到Class, Method, Field类，就能够通过getAnnotation(Class)拿到我们想要的注解并取值。

三、常用元注解

Target： 描述了注解修饰的对象范围，取值在java.lang.annotation.ElementType定义，常用的包括：

• METHOD：用于描述方法
• PACKAGE：用于描述包
• PARAMETER：用于描述方法变量
• TYPE：用于描述类、接口或enum类型

Retention: 表示注解保留时间长短。取值在java.lang.annotation.RetentionPolicy中，取值为：

• SOURCE：在源文件中有效，编译过程中会被忽略
• CLASS：随源文件一起编译在class文件中，运行时忽略
• RUNTIME：在运行时有效

只有定义为RetentionPolicy.RUNTIME时，我们才能通过注解反射获取到注解。

@Target(ElementType.FIELD)  //  注解用于字段上
@Retention(RetentionPolicy.RUNTIME)  // 保留到运行时，可通过注解获取
public @interface MyField {
    String description();
    int length();
}

四、示例

先定义一个注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 *
 * @author zhangys
 * @date 2020/4/15
 */
@Target(value = ElementType.FIELD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface MyFirstField {
    String description();
    int length();
}

再通过反射获取注解

import org.junit.Test;

import java.lang.reflect.Field;

/**
 * @author zhangys
 * @description
 * @date 2020/4/15
 */
public class MyFirstFieldTest {

    @MyFirstField(length = 10,description = "用户名")
    String username;

    @Test
    public void testMyField() throws NoSuchFieldException {
        MyFirstFieldTest myFirstFieldTest = new MyFirstFieldTest();
        Class<MyFirstFieldTest> c = MyFirstFieldTest.class;
        Field f = c.getDeclaredField("username");
        MyFirstField myFirstField = f.getAnnotation(MyFirstField.class);
        System.out.println(myFirstField.description());
        System.out.println(myFirstField.length());
    }

}

运行结果

五、应用场景一：自定义注解+拦截器 实现登录校验

接下来，我们使用springboot拦截器实现这样一个功能，如果方法上加了@LoginRequired，则提示用户该接口需要登录才能访问，否则不需要登录。

设计：拦截每个请求（拦截路径为"/**"），在拦截方法中通过反射获取方法的@LoginRequired注解，根据获取到的注解是否为空，来判断该方法是否需要登录校验。

首先定义一个LoginRequired注解

package com.zys.aoptest.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.METHOD)
public @interface LoginRequired {
}

然后写两个简单的接口和一个service，访问sourceA，sourceB资源，并学习springmvc拦截器

controller

package com.zys.aoptest.controller;

import com.zys.aoptest.service.MyFirstAopService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zhangys
 * @description
 * @date 2020/4/16
 */
@RestController
public class MyFirstAopController {

    @Autowired
    MyFirstAopService myFirstAopService;

    @GetMapping(value = "/sourceA")
    public String sourceA(){
        System.out.println("你正在访问资源A,service.test()前");
        System.out.println(myFirstAopService.test());
        System.out.println("你正在访问资源A,service.test()后");
        return "你正在访问资源A";
    }

    @GetMapping(value = "/sourceB")
    public String sourceB(){
        System.out.println("你正在访问资源B,service.test()前");
        System.out.println(myFirstAopService.test());
        System.out.println("你正在访问资源B,service.test()后");
        return "你正在访问资源B";
    }


}

service

package com.zys.aoptest.service;

import org.springframework.stereotype.Service;

/**
 * @author zhangys
 * @description
 * @date 2020/4/16
 */
@Service
public class MyFirstAopService {

    public String test(){
        System.out.println("这里是service.test()");
        return "test()";
    }


}

实现spring的HandlerInterceptor 类先实现拦截器，但不拦截，只是简单打印日志，如下：

package com.zys.aoptest.aop;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author zhangys
 * @description
 * @date 2020/4/16
 */
public class SourceAccessInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle方法在业务处理器处理请求之前被调用");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle方法在业务处理器处理请求执行完成后，生成视图之前执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion方法在DispatcherServlet完全处理完请求后被调用，可用于清理资源等");
    }
}

实现spring类WebMvcConfigurer，创建配置类把拦截器添加到拦截器链中

package com.zys.aoptest.aop;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author zhangys
 * @description
 * @date 2020/4/16
 */
@Configuration
public class WebAppConfigurer implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //可添加多个
        registry.addInterceptor(new SourceAccessInterceptor()).addPathPatterns("/**");
    }
}

页面

控制台

在sourceB方法上添加登录注解@LoginRequired

@GetMapping(value = "/sourceA")
    @LoginRequired
    public String sourceA(){
        System.out.println("你正在访问资源A,service.test()前");
        System.out.println(myFirstAopService.test());
        System.out.println("你正在访问资源A,service.test()后");
        return "你正在访问资源A";
    }

简单实现登录拦截逻辑

@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle方法在业务处理器处理请求之前被调用");

        // 反射获取方法上的LoginRequred注解
        HandlerMethod handlerMethod = (HandlerMethod )handler;
        LoginRequired loginRequired = handlerMethod.getMethodAnnotation(LoginRequired.class);
        if (loginRequired == null){
            return true;
        }

        // 有LoginRequired注解说明需要登录，提示用户登录
        response.setContentType("application/json; charset=utf-8");
        response.getWriter().print("你访问的资源需要登录");
        return false;
    }

运行成功，现在访问A资源会被拦截，B资源则不会

六、应用场景二：自定义注解+AOP 实现日志打印

设计：通过AOP设置所有带有@MyLog注解的方法为切点，然后通过AOP中的@Around的功能完成该方法的日志输出。

先导入切面需要的依赖包

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

定义一个注解@MyLog

package com.zys.aoptest.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {
}

定义一个切面类，见如下代码注释理解：

package com.zys.aoptest.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author zhangys
 * @description
 * @date 2020/4/16
 */
@Aspect // 1.表明这是一个切面类
@Component
public class MyLogAspect {


    /**
     * 2. PointCut表示这是一个切点，@annotation表示这个切点切到一个注解上，后面带该注解的全类名
     * 切面最主要的就是切点，所有的故事都围绕切点发生
     * logPointCut()代表切点名称
     */
    @Pointcut("@annotation(MyLog)")
    public void logPointCut() {
    }

    // 3. 环绕通知
    @Around("logPointCut()")
    public Object logAround(ProceedingJoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println("joinPoint.getThis():" + joinPoint.getThis());
        System.out.println("joinPoint.getTarget():" + joinPoint.getTarget());
        // 获取入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for (Object o : param) {
            sb.append(o).append("; ");
        }

        System.out.println("进入[" + methodName + "]方法,参数为:" + sb.toString());

        Object object = null;
        // 继续执行方法
        try {
            //接受方法的返回值
            object = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println(methodName + "方法执行结束");
        return object;
    }
}

在MyFirstAopController写一个sourceC进行测试，加上我们的自定义注解：

@MyLog
    @GetMapping(value = "/sourceC/{source_name}")
    public String sourceC(@PathVariable("source_name") String sourceName){
        System.out.println("你正在访问资源C,sourceName:"+sourceName);
        System.out.println("你正在访问资源C,service.test()前");
        System.out.println(myFirstAopService.test());
        System.out.println("你正在访问资源C,service.test()后");
        return "你正在访问资源C";
    }

启动springboot web项目，测试