SpringBoot系列之使用自定义注解校验用户是否登陆

时间 2019-11-13

标签 springboot 系列使用自定义注解校验用户是否登陆栏目 Spring 繁體版

原文原文链接

记得今年年初刚开始面试的时候，被问的最多的就是你知道Spring的两大核心嘛？那你说说什么是AOP，什么是IOC？我相信你可能也被问了不少次了。java

一、究竟是什么是AOP？git

所谓AOP也就是面向切面编程，可以让咱们在不影响原有业务功能的前提下，横切扩展新的功能。这里面有一个比较显眼的词咱们须要注意一下，横切，它是基于横切面对程序进行扩展的。github

二、AOP相关术语web

在Spring的AOP中有不少的术语，并且容易混淆，你们必定要先搞清楚这几个概念：面试

链接点（Joinpoint）：在程序执行过程当中某个特定的点，好比类初始化前、类初始化后，方法调用前，方法调用后；spring
切点（Pointcut）：所谓切点就是你所切取的类中的方法，好比你横切的这个类中有两个方法，那么这两个方法都是链接点，对这两个方法的定位就称之为切点；apache
加强（Advice）：加强是织入到链接点上的一段程序，另外它还拥有链接点的相关信息；编程
目标对象（Target）：加强逻辑的织入目标类，就是个人加强逻辑植入到什么位置；tomcat
引介（Introduction）：一种特殊的加强，它能够为类添加一些属性喝方法；springboot
织入（Weaving）：织入就是讲加强逻辑添加到目标对象的过程；
代理（Proxy）：一个类被AOP织入加强后，就会产生一个结果类，他是融合了原类和加强逻辑的代理类；
切面（Aspect）：切面由切点和加强组成，他是横切逻辑定义和链接点定义的组成；

三、AOP功能实践

咱们这里主要是学习SpringBoot中的一些功能，因此咱们这里用的是SpringBoot工程，版本也是最新的2.0.5版本。

建立SpringBoot工程就不说了，咱们直接引入Maven的依赖：

<parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.0.5.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <java.version>1.8</java.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
           <exclusions>
               <exclusion>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-starter-tomcat</artifactId>
               </exclusion>
           </exclusions>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-jetty</artifactId>
       </dependency>

       <!-- 引入AOP -->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-aop</artifactId>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-compiler-plugin</artifactId>
               <version>3.6.1</version>
               <configuration>
                   <source>1.8</source>
                   <target>1.8</target>
               </configuration>
           </plugin>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-surefire-plugin</artifactId>
               <version>2.20</version>
               <configuration>
                   <skip>true</skip>
               </configuration>
           </plugin>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <executions>
               </executions>
           </plugin>
       </plugins>
   </build>

首先咱们来建立一个Controller类：

@RestController
public class LoginController {

   @GetMapping(value = "/username")
   public String getLoginUserName(String userName, Integer age) {
       
       return userName + " --- " + age;
   }
}

建立切面：

@Aspect
@Component
public class LogAspect {

   /**
    * 功能描述: 拦截对这个包下全部方法的访问
    *
    * @param:[]
    * @return:void
    **/
   @Pointcut("execution(* com.example.springbootaop.controller.*.*(..))")
   public void loginLog() {
   }

   // 前置通知
   @Before("loginLog()")
   public void loginBefore(JoinPoint joinPoint) {

       // 咱们从请求的上下文中获取request，记录请求的内容
       ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

       HttpServletRequest request = attributes.getRequest();

       System.out.println("请求路径 : " + request.getRequestURL());
       System.out.println("请求方式 : " + request.getMethod());
       System.out.println("方法名 : " + joinPoint.getSignature().getName());
       System.out.println("类路径 : " + joinPoint.getSignature().getDeclaringTypeName());
       System.out.println("参数 : " + Arrays.toString(joinPoint.getArgs()));
   }

   @AfterReturning(returning = "object", pointcut = "loginLog()")
   public void doAfterReturning(Object object) {

       System.out.println("方法的返回值 : " + object);
   }

   // 方法发生异常时执行该方法
   @AfterThrowing(throwing = "e",pointcut = "loginLog()")
   public void throwsExecute(JoinPoint joinPoint, Exception e) {

       System.err.println("方法执行异常 : " + e.getMessage());
   }

   // 后置通知
   @After("loginLog()")
   public void afterInform() {

       System.out.println("后置通知结束");
   }

   // 环绕通知
   @Around("loginLog()")
   public Object surroundInform(ProceedingJoinPoint proceedingJoinPoint) {

       System.out.println("环绕通知开始...");

       try {
           Object o =  proceedingJoinPoint.proceed();
           System.out.println("方法环绕proceed，结果是 :" + o);
           return o;
       } catch (Throwable e) {
           e.printStackTrace();
           return null;
       }
   }
}

注解概述：

@Apsect：将当前类标识为一个切面；
@Pointcut：定义切点，这里使用的是条件表达式；
@Before：前置加强，就是在目标方法执行以前执行；
@AfterReturning：后置加强，方法退出时执行；
@AfterThrowing：有异常时该方法执行；
@After：最终加强，不管什么状况都会执行；
@Afround：环绕加强；

测试：

异常测试：

四、定义自定义注解

应用场景：在我以前上个项目的时候，有这样一个注解，就是在访问其余接口的时候必需要登陆，那么这个时候咱们就定义一个注解，让它去对用户是否登陆进行校验，那么基于这样的一个场景，咱们来定义一个校验登陆的注解。

建立一个注解：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Auth {

   String desc() default "验证是否登陆";
}

建立一个AOP切面：

@Aspect
@Component
public class LoginAspect {

   @Pointcut(value = "@annotation(com.example.springbootaop.annotation.Auth)")
   public void access() {
   }

   @Before("access()")
   public void before() {

       System.out.println("开始验证用户是否登陆...");
   }

   @Around("@annotation(auth)")
   public Object around(ProceedingJoinPoint pj, Auth auth) {

       // 获取注解中的值
       System.out.println("注解中的值 : " + auth.desc());
       try {

           // 检验是否登陆 true 已经登陆  false 未登陆
           Boolean flag = false;

           if (flag == true) {
               return "登陆成功";
           } else {
               return "未登陆";
           }
       } catch (Throwable throwable) {
           return null;
       }
   }
}

测试未登陆：

测试登陆：

这样咱们就能够简单的实现了一个登陆校验的注解。

经过今天的分享你会使用AOP和自定义注解了吗？我把源码的地址放在下面，有兴趣的朋友能够看看。

GitHub地址：https://github.com/liangbintao/SpringBootIntegration.git

原创不易，若是感受不错，给个顺便扩散一下吧！