Spring统一功能+SpringAOP
什么是拦截器
类似于门口的保安，用来做用户的验证，他是Spring提供的核心功能之一，用来拦截用户的请求
目标方法执行前，要做的事情。（要去实现这个接口)
public class LoginInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { log.info("登录拦截器校验");目标方法执行后，要做的事情
@Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { log.info("目标方法执行后"); }描写拦截的内容，拦截的规则
@Override public void addInterceptors(InterceptorRegistry registry) { //add路径，exclude排除什么我们不去拦截 registry.addInterceptor(loginInterceptor).addPathPatterns("/**").excludePathPatterns("/user/login") .excludePathPatterns(excludePath);//**表示会给所有方法添加拦截器 }
源码了解:DispatcherServlet
先初始化，有一个init(),再会去进行一些组件的初始化，然后会回调一个dodispatch,会检查有没有一些文件，
initHandlerMappings(会找到所有的HandlerBean，找到他想要的Bean,他会拿到一个处理器
（类似@RequestMapping拿到这个处理器就会获得一个映射),initHandlerAdapter(根据url,来找到处理器，然后再去找到适配器，适配器来使用处理器，再去执行一个拦截器，然后执行具体的方法，Controller,后续继续执行拦截器代码
slf4j:门面模式
Spring用了什么模式:适配器模式，代理模式，单例模式，门面模式（对其统一进行封装）。
SpringAOP
AOP面向切面编程:
切面使某一类特定问题，，也可以理解为面向特定方法编程
比如登录校验就是一类特定问题，登录校验拦截器，对登录校验这类问题统一处理，AOP是一种思想，对某一类事物的集中处理
比如计时这个操作
long start=System.currentTimeMillis(); long end=System.currentTimeMillis(); log.info(""+(end-start)+"ms")OOP面向对象编程
两个处理的维度不同
假如说对于所有方法的打印耗时时间
只是应用了@Aspectj的注解，但是是spring自己实现的，aspectj是一个第三方的
好处:代码无侵入，不修改原始的业务方法，就可以对原始的业务方法进行功能的增强或者功能的改变，减少了重复代码，提升了开发效率，维护方便
package com.example.demo.aspect;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.springframework.stereotype.Component;
import org.aspectj.lang.annotation.Aspect;
@Slf4j
@Aspect //表示一个切面类
@Component
public class TimeAspect {
//作用域，以及作用方式
@Around("execution(* com.example.demo.demos.book.controller.*.*(..))")
//这个方法的对象表示是作用目标
public Object timeCost(ProceedingJoinPoint joinPoint) throws Throwable {
long start=System.currentTimeMillis();
//让目标方法执行
Object result=joinPoint.proceed();
long end=System.currentTimeMillis();
log.info(joinPoint.getSignature()+"消耗时间"+(end-start)+"ms");
return result;
}
}
切点：其中表达式成为切点@Around("execution(* com.example.de
mo.demos.book.controller.*.*(..))")，用来告诉程序对哪些方法进行功能增强
连接点:目标方法ProceedingJoinPoint joinPoint，切面要去作用的方法。
AOP概念
切点：高二五班学生（那个Controller）
连接点：小张，小李，小王（在图书管理系统中是我们的方法，就是连接点）
通知:具体的逻辑，要去做什么处理
AOP： 对一类事情的几种处理
通知:具体的逻辑，要做什么处理（xxx具体要干什么，下面的一整串代码叫通知)
切面:切点+通知（全部代码叫切面（不包括导包啥的），一个类有多个切面。
测试五大方法
@Around:环绕通知，在目标方法的前后，都被执行
@Before:前置通知，通知方法，在目标方法前执行
@After:后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
@AfterReturning:返回后通知，此直接标注的通知方法在目标方法后被执行，有异常不会执行
@AfterThrowing:异常后通知，此注解标注的通知方法发生异常后执行
package com.example.aopdemo.demos.web; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; @Slf4j @Aspect //表示这是一个切面类 @Component public class AspectDemo { //方法的作用域，以及作用方式 @Before("execution(* com.example.aopdemo.demos.web.controller..*.*(..))") public void doBefore(){ log.info("执行AspectDemo before"); } @After("execution(* com.example.aopdemo.demos.web.controller..*.*(..))") public void doAfter(){ log.info("执行AspectDemo after"); } @AfterReturning("execution(* com.example.aopdemo.demos.web.controller..*.*(..))") public void doAfterReturning(){ log.info("执行AspectDemo afterReturning"); } @AfterThrowing("execution(* com.example.aopdemo.demos.web.controller..*.*(..))") public void doAfterThrowing(){ log.info("执行AspectDemo afterThrowing..."); } 方法的作用域，以及作用方式 @Around("execution(* com.example.aopdemo.demos.web.controller..*.*(..))") //Around表示的是方法前后，是必须要返回结果的 public Object doAround(ProceedingJoinPoint joinPoint 目标方法) throws Throwable { //方法执行前 log.info("执行AspectDemo Around前"); //执行目标方法。 Object result=joinPoint.proceed(); //方法执行后。 log.info("执行AspectDemo doAround 后"); return result; } }运行结果的顺序，先是Around,再是before,后面的是先执行after再是Around
当发生异常的时候，不执行AfterReturning,也不执行Around方法后的逻辑
切点的学习
切点表达式：
1.execution（根据方法的签名来匹配）
2.@annotation（根据注释匹配）
如何把切点提出来定义（代码更加优雅)
@Target({ElementType.METHOD})//表示我们的注解可以应用到哪里
@Target({ElementType.TYPE})//用于描述类，接口或者enum声明
@Target({ElementType.PARAMETER})//描述参数
@Target({ElementType.TYPE_USE})//可以标注任意类型@Retention(RetentionPolicy.RUNTIME) //注解的生命周期
@Retention(RetentionPolicy.SOURCE)//此注解存在源代码中，如同slf4j，编译成字节码会被丢弃
@Retention(RetentionPolicy.CLASS)//编译时注解，存在于源代码和字节码中，但是运行时候会被丢弃
AOP实现方式
1.基于注解@Aspect
2.基于自定义注解
3.基于Spring API(通过xml方式，少见)
4.基于代理来实现（更久远，更笨，不推荐）
AOP回顾：一种思想，对一类事物的集中处理
统一功能：就是AOP的一种实现
切点：其中表达式成为切点@Around("execution(* com.example.demo.demos.book.controller.*.*(..))")，用来告诉程序对哪些方法进行功能增强
通知：具体做什么事情
切面=切点+通知
AOP（常考，但是相对用的少，例如：多线程）的实现方式有几种：
代理模式：
AOP常见实现方式：
1.Spring AOP
2.aspectj
Spring使用了aspectj的注解，自己进行了实现
Spring AOP原理:基于动态代理来实现的:
(租客通过房屋中介->找到房东）
切点
代理模式:
静态：(给学生提供服务之前，先分配一个老师，进行答疑，别的同学问，我再给他分配一个老师。
动态:(不提前分配，学生问的问题类型，进行分配老师）
静态代理：在程序运行前，代理对象已经对目标对象进行空步骤对预执行代码
动态代理两种常见实现方式(基于反射)
JDK动态代理只能代理接口，不能代理类。
CGIB动态代理接口和类，都能被代理。
一般问题
SpringAOP如何实现的（基于动态代理实现的）->动态代理是怎么实现的（Spring动态代理基于JDK,CGlib）->Spring使用的是哪个呢（两个都用了）->什么时候用JDK,什么时候使用CGlib（Springboot2.x开始默认使用CGLIB代理，我们可以通过spring.aop.proxy-target-class=false 设置JDK代理）->JDK和CGlib的区别（
JDK动态代理只能代理接口，不能代理类。
CGIB动态代理接口和类，都能被代理。
）