自定义注解

说实话，因为一些知识点的欠缺，对自定义注解和拦截，一直有种仰望不敢触及的心态。工作一段时间慢慢看代码，内心os：这样可不行。那么，从简单的记录起，然后慢慢实现登录校验把。

计划：先是一些基本的动手实践部分，然后再来一些项目中可以用到的登录或别的功能。

感叹一句：那些经过时间考验，看起来复杂的代码、框架，实际都是为了简化操作而生，这样一想，很多事就简单了起来。

使用场景

自定义注解+拦截器
自定义注解+AOP

注解体系

元注解

java.lang.annotation中提供元注解，用来定义自己的注解。主要使用Target和Retention注解。

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();
}

注解处理类

java.lang.reflect.AnnotationElement接口提供了该功能——拿到我们定义的注解。

注解的处理是通过java反射来处理的，反射相关的类Class，Method，Field都实现了AnnotationElement接口。

方法有：
isAnnotationPresent(Class<? extends Annotation>)         boolean
getAnnotation(Class<T>)                                  T
getAnnotations()                                         Annotation[]
getAnnotationsByType(Class<T>)                           T[]
getDeclaredAnnotation(Class<T>)                          T
getDeclaredAnnotationsByType(Class<T>)                   T[]
getDeclaredAnnotations()                                 Annotation[]

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

Demo1：通过反射获取注解

定义一个注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyField {
    String description();
    int length();
}

通过反射获取注解

public class MyFieldTest {

    @MyField(description = "用户名", length = 12)
    private String username;

    @Test
    public void testMyField() {
        // 获取类模板
        Class c = MyFieldTest.class;

        // 获取所有字段
        for (Field f : c.getDeclaredFields()) {
            if (f.isAnnotationPresent(MyField.class)) {
                MyField annotation = f.getAnnotation(MyField.class);
                System.out.println("字段：[" + f.getName() + "]，描述：["
                        + annotation.description() + "]，长度：["
                        + annotation.length() + "]");
            }
        }
    }
}

运行结果：

字段：[username]，描述：[用户名]，长度：[12]

Demo2：自定义注解+拦截器，实现登录校验

(web)

方法上加了@LoginRequired，则提示用户该接口需要登录才能访问，否则不需要登录。

LoginRequired注解：

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

}

Controller，写两个简单的接口

@RestController
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
public class IndexController {

    @GetMapping("/sourceA")
    public String sourceA() {
        return "你正在访问sourceA资源";
    }

    @GetMapping("/sourceB")
    public String sourceB() {
        return "你正在访问sourceB资源";
    }
}

没添加拦截器之前，成功访问

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

拦截器的方法说明

// 表示被拦截的URL对应的方法执行前的自定义处理
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o)

// 表示此时还未将modelAndView进行渲染，被拦截的URL对应的方法执行后的自定义处理
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView)

// 表示此时modelAndView已被渲染，执行拦截器的自定义处理。
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e)

public class SourceAccessInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("进入拦截器了");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

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

@Configuration
public class InterceptorTrainConfigurer implements WebMvcConfigurer {

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

拦截成功

进入拦截器了

在IndexController sourceB方法上添加我们的登录注解@LoginRequire

在SourceAccessInterceptor，简单实现登录拦截逻辑

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
	System.out.println("进入拦截器了");

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

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

运行成功，访问sourceB时提示需要登录，访问sourceA则不用登录

Demo3：自定义注解+AOP，实现日志打印

面向切面拦截的是类的元数据（包、类、方法名、参数等）

相对于拦截器更加细致，而且非常灵活，拦截器只能针对URL做拦截，而AOP针对具体的代码，能够实现更加复杂的业务逻辑。

先导入切面需要的依赖包

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

定义一个注解@MyLog

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

定义一个切面类

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;

@Aspect // 表明这是一个切面类
@Component
public class MyLogAspect {

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

    // 环绕通知
    @Around("logPointCut()")
    public void logAround(ProceedingJoinPoint joinPoint) {
        // 获取方法名称
        String methodName = joinPoint.getSignature().getName();
        // 获取入参
        Object[] param = joinPoint.getArgs();

        StringBuilder sb = new StringBuilder();
        for (Object o : param) {
            sb.append(o + "; ");
        }
        System.out.println("进入[" + methodName + "]方法，参数为：" + sb.toString());

        // 继续执行方法
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println(methodName + "方法执行结束");
    }
}

Controller，写一个简单的接口进行测试，加上自定义注解

@RestController
@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})
public class IndexController {
    @MyLog
    @GetMapping("/sourceC/{source_name}")
    public String sourceC(@PathVariable("source_name") String sourceName) {
        return "你正在访问sourceC资源";
    }
}

启动springboot web项目，输入访问地址

localhost:8080/sourceC/ahaha

进入拦截器了
进入[sourceC]方法，参数为：ahaha
sourceC方法执行结束

过滤器、拦截器、AOP的区别

过滤器

过滤器可以拦截到方法的请求和响应（ServletRequest request, SetvletResponse response），并对请求响应做出响应的过滤操作，比如设置字符编码、鉴权操作。

拦截器

拦截器可以在方法之前（preHandle）和方法执行之后（afterCompletion）进行操作，回调操作（postHandle），可以获取执行的方法的名称，请求（HttpServletRequest）。

AOP切片

AOP操作可以对操作进行横向的拦截，最大的优势在于可以获取执行方法的参数，对方法进行统一的处理，常见使用日志，事务，请求参数安全验证等。

顺序

请求->>过滤器->>拦截器-->Aspect->>拦截器->>过滤器->>响应

posted @ 2020-07-02 10:53 shinl00 阅读(191) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

林仔的园子

尽管做些让自己开心的事情叭o(￣▽￣)ブ但是既然是令自己开心的事情就努力做好叭

自定义注解

自定义注解

使用场景

注解体系

元注解

Target

Retention

注解处理类

Demo1：通过反射获取注解

Demo2：自定义注解+拦截器，实现登录校验

Demo3：自定义注解+AOP，实现日志打印

过滤器、拦截器、AOP的区别

过滤器

拦截器

AOP切片

顺序

公告

林仔的园子

尽管做些让自己开心的事情叭o(*￣▽￣*)ブ 但是既然是令自己开心的事情 就努力做好叭

自定义注解

自定义注解

使用场景

注解体系

元注解

Target

Retention

注解处理类

Demo1：通过反射获取注解

Demo2：自定义注解+拦截器，实现登录校验

Demo3：自定义注解+AOP，实现日志打印

过滤器、拦截器、AOP的区别

过滤器

拦截器

AOP切片

顺序

公告

尽管做些让自己开心的事情叭o(￣▽￣)ブ但是既然是令自己开心的事情就努力做好叭