前言
🌟🌟本期讲解关于spring aop的切面表达式和自身实现原理介绍~~~
🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客
🔥 你的点赞就是小编不断更新的最大动力
🎆那么废话不多说直接开整吧~~
目录
📚️1.切点表达式
🚀1.1execution表达式
🚀1.2@annotation
1.自定义注解
2.切面类
3.添加注解
📚️2.Spring AOP原理
🚀2.1代理模式
1.静态代理（了解）
2.动态代理（八股）
🚀2.2Spring AOP原理总结
📚️3.总结
📚️1.切点表达式
我们在上一期了解到了关于通知中切点表达式execution表达式，但是没有做很详细的介绍，不仅如此在切点表达式中，有两种方式，下面来一一介绍
🚀1.1execution表达式
切点表达式的结构如下所示：
execution(<访问修饰符> <返回类型> <包名.类名.⽅法(⽅法参数)> <异常>)
而在我们上期写的表达式中格式如下：
@Around("execution(* com.example.springaop.controller.*.*(..))")解释：
* ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数）
.. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数
上述的controller后的两个 * 代表就是每一层，括号里的 .. 就是表示任意的方法参数；这里也可以代表无参数；
举例：
execution(public String com.example.demo.controller.TestController.t1())
解释：testcontroller类下的名为t1的方法，并且这里的方法是无参的，访问修饰符可以省去；
execution(* com.example.demo.controller.TestController.t1())
解释：这里可以访问的就是没有任何限制的访问权限，匹配所有返回类型；
execution(* com.example.demo.controller.TestController.*())
解释：这里匹配所有的方法，这些方法是无参的；
execution(* com.example.demo.controller.*.*(..))
解释：这里匹配controller包下所有类的所有方法
execution(* com..TestController.*(..))
解释：这里匹配com包下的所有testcontroller类的所有方法
🚀1.2@annotation
我们在上述的简述中了解到，关于execution表达式如何作用于匹配某个方法和类，但是当存在两个类，都要进行匹配，并且里面的方法也是无规则的，那如何呢，此时就要@annotation进行操作了；
假如有以下的两个控制类：
@RestController
@RequestMapping("/test")
public class TestController {
@RequestMapping("/t1")
public String test1(){
log.info("这是t1执行");
return "t1";
}
@RequestMapping("/t2")
public String test2(){
log.info("这是t2在执行");
return "t2";
}
}@RestController
@RequestMapping("/user")
public class UserController {
@RequestMapping("/u1")
public String user1(){
return "u1";
}
@RequestMapping("/u2")
public String user2(){
return "u2";
}
}
那么此时我们要将第一个控制器类的第一个方法进行匹配，以及第二个控制器类的方法进行匹配，那么此时的操作就是如下所示：
1.自定义注解
代码如下所示：
//定义自己的注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}
@Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅.
@Retention 指Annotation被保留的时间⻓短, 标明注解的⽣命周期
2.切面类
使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效
代码如下所示：
@Aspect
@Component
@Slf4j
public class MyAnnotationAspect {
@Before("@annotation(com.example.springaop.config.MyAspect)")
public void doBefore(){
log.info("before start...");
}
@After("@annotation(com.example.springaop.config.MyAspect)")
public void doAfter(){
log.info("after start...");
}
}
这里小编设置了两种通知类，第一种是在目标方法执行前进行执行，第二种通知是在方法执行后进行执行，当然表达式里的的是我们自己注解的全限定路径，加上我们的定义注解名称；
3.添加注解
代码如下所示：
@MyAspect
@RequestMapping("/t1")
public String test1(){
log.info("这是t1执行");
return "t1";
}这是第一个类的第一个方法；
@MyAspect
@RequestMapping("/u2")
public String user2(){
return "u2";
}这是第二个类的第二个方法；
此时就与这两个方法进行了匹配，那么就可执行切面通知了；
📚️2.Spring AOP原理
🚀2.1代理模式
代理模式也叫委托模式定义：为其他对象提供⼀种代理以控制对这个对象的访问. 它的作⽤就是通过提供⼀个代理类, 让我们在调⽤⽬标⽅法的时候, 不再是直接对⽬标⽅法进⾏调⽤, ⽽是通过代理类间接调⽤（其实就是中介的作用）
1. Subject: 业务接⼝类. 可以是抽象类或者接⼝(不⼀定有)
2. RealSubject: 业务实现类. 具体的业务执⾏, 也就是被代理对象.（真正的房东）
3. Proxy: 代理类. RealSubject的代理 （中介）
这里的代理模式分为两种
• 静态代理: 由程序员创建代理类或特定⼯具⾃动⽣成源代码再对其编译, 在程序运⾏前代理类的
.class ⽂件就已经存在了.
• 动态代理: 在程序运⾏时, 运⽤反射机制动态创建⽽成
1.静态代理（了解）
代码如下：
定义一个subject业务接口；
public interface SubjectHouse {
void rentHouse();
}让代理对象继承这个接口，并写出要代理什么
public class RealSubjectHouse implements SubjectHouse{
//真正的房东
@Override
public void rentHouse(){
System.out.println("我是房东，我要出租房子");
}
}
最后中介，进行代理
public class HouseProxy implements SubjectHouse{
private SubjectHouse subjectHouse;
public HouseProxy(SubjectHouse subjectHouse) {
this.subjectHouse = subjectHouse;
}
@Override
public void rentHouse() {
System.out.println("我是中介开始代理");
subjectHouse.rentHouse();
System.out.println("我是中介结束代理");
}
}
解释这里使用了一个向上转型的思想，这里实际指定就是代理的对象就是realsubjecthouse（即真正的房东）；
从上述代码可以看出, 我们修改接⼝(Subject)和业务实现类(RealSubject)时, 还需要修改代理类
(Proxy).
同样的, 如果有新增接⼝(Subject)和业务实现类(RealSubject), 也需要对每⼀个业务实现类新增代理类(Proxy).
2.动态代理（八股）
相⽐于静态代理来说，动态代理更加灵活.
我们不需要针对每个⽬标对象都单独创建⼀个代理对象, ⽽是把这个创建代理对象的⼯作推迟到程序运
⾏时由JVM来实现. 也就是说动态代理在程序运⾏时, 根据需要动态创建⽣成
这里的动态代理分为两种
JDK动态代理；
CGLIB动态代理；
JDK动态代理代码（了解）
public class JDKInvocationHandler implements InvocationHandler {
private Object target;//目标对象
public JDKInvocationHandler(Object target) {
this.target = target;
}
/**
* 代理对象 通过 invoke调用 目标对象的方法
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是代理, 开始代理");
//通过反射, 调用目标对象的方法
Object result = method.invoke(target, args);
System.out.println("我是代理, 结束代理");
return result;
}
}
进行main方法调用：
SubjectHouse proxy= (SubjectHouse) Proxy.newProxyInstance(
SubjectHouse .class.getClassLoader(),
new Class[]{SubjectHouse .class},
new JDKInvocationHandler(target));
proxy.rentHouse();newProxyInstance() , 这个⽅法主要⽤来⽣成⼀个代理对象
Loader: 类加载器, ⽤于加载代理对象.
interfaces : 被代理类实现的⼀些接⼝(这个参数的定义, 也决定了JDK动态代理只能代理实现了接⼝的⼀些类)
h : 实现了 InvocationHandler 接⼝的对象，target被代理对象
CGLIB动态代理代码
添加依赖：
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>public class CGLibMethodInterceptor implements MethodInterceptor {
private Object target;
public CGLibMethodInterceptor(Object target) {
this.target = target;
}
/**
* 调用代理对象的方法
*/
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("我是中介, 开始代理");
Object result = method.invoke(target, args);
System.out.println("我是中介, 结束代理");
return result;
}
}最后进行调用：
SubjectHouse houseSubject = (SubjectHouse) Enhancer.create(
target.getClass(), new CGLibMethodInterceptor(target));
houseSubject.rentHouse();上述存在一个比较重要的知识点：
JDK动态代理存在一个致命的问题，即只能代理接口，不能代理类，而CGLIB既可以代理接口，又可以代理类；
🚀2.2Spring AOP原理总结
spring AOP原理，是要从源码进行解读的，但是源码过于复杂，最终的情况就是如下所示：
在源码中的代理⼯⼚有⼀个重要的属性: proxyTargetClass, 默认值为false. 也可以通过程序设置（这里的默认值是根据不同情况来进行定义的）
大致意思就是在 proxyTargetClass为false时，在实现接口时使用JDK代理，只实现类的情况下，使用CGLIB代理，若proxyTargetClass,为true，那么所有实现方式都使用CGLIB代理；
Spring默认使用的的proxyTargetClass为false，但是在spring boot2.x之后proxyTargetClass默认为true，使用CGLIB进行代理；
当然我们可以使用配置项进行配置
spring.aop.proxy-target-class=false这里设置proxyTargetClass默认为false；
📚️3.总结
本期主要讲解了关于切点表达式的两种表达方式，以及Spring AOP实现原理的两种代理模式，即JDK代理，以及CGLIB代理，最后进行Spring AOP原理的总结；
🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！
💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。
😊😊 期待你的关注~~~
