目录
1.切点表达式
1.1execution表达式
1.2 @annotation
1.2.1自定义注解@MyAspect
1.2.3添加自定义注解
2.Sping AOP原理
2.1代理模式
2.1.1静态代理
2.1.2动态代理
2.1.3JDK动态代理
2.1.4CGLIB动态代理
3.总结
承接上文:详解Spring AOP(一)
1.切点表达式
之前的代码中,我们一直在使用切点表达式来描述切点.下面我们来介绍一下切点表达式的语法.切点表达式常见有两种表达方式:
execution(.....):根据方法的签名来匹配
@annotation(...):根据注解匹配
1.1execution表达式
execution() 是最常用的切点表达式, 用来匹配⽅法, 语法为:
execution(<访问修饰符> <返回类型> <包名 .类名 .方法(方法参数)> <异常>)
其中访问修饰符和异常可以省略
切点表达式支持通配符表达:
*:匹配任意字符,只匹配一个元素(返回类型,包,类名,方法或者方法参数)
包名使用*表示任意包(一层包使用一个*)
类名使用*表示任意类
返回值使用*表示任意返回值类型
方法名使用*表示任意方法
参数使用*表示一个任意类型的参数
.. :匹配多个连续的任意符号,可以通配任意层级的包,或任意类型,任意个数的参数
使用..配置包名,标识此包以及此包下的所有子包
可以使用..配置参数,任意个任意类型的参数
切点表达式示例:
TestController 下的 public修饰, 返回类型为String 方法名为t1, 无参方法
execution(public String com.example.demo.controller.TestController.t1())
省略访问修饰符
execution(String com.example.demo.controller.TestController.t1())
匹配所有返回类型
execution(* com.example.demo.controller.TestController.t1())
匹配TestController 下的所有无参方法
execution(* com.example.demo.controller.TestController.*())
匹配controller包下所有的类的所有方法
execution(* com.example.demo.controller.*.*(..))
匹配所有包下面的TestController
execution(* com..TestController.*(..))
匹配com.example.demo包下, 子孙包下的所有类的所有方法
execution(* com.example.demo..*(..))
1.2 @annotation
execution表达式更适用有规则的,如果我们要匹配多个无规则的方法,比如:TestController中的t1()和UserController中的u1()这两个方法.
这个时候我们使用execution这种切点表达式来描述就不是很方便了.
我们可以借助自定义注解的方式以及切点表达式@annotation来描述这一类的切点实现步骤:
1.编写自定义注解
2.使用@annotation表达式来描述切点
3.在连接点的方法上添加自定义注解
准备测试代码:
@RequestMapping("/test")
@RestController
public class TestController {
@RequestMapping("/t1")
public String t1() {
return "t1";
}
@RequestMapping("/t2")
public boolean t2() {
return true;
}
}
@RequestMapping("/user")
@RestController
public class UserController {
@RequestMapping("/u1")
public String u1(){
return "u1";
}
@RequestMapping("/u2")
public String u2(){
return "u2";
}
}
1.2.1自定义注解@MyAspect
创建⼀个注解类(和创建Class文件⼀样的流程, 选择Annotation就可以了)
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}
@Target标识了Annotation所修饰的对象范围,即该注解可以用在什么地方.
常用取值:
ElementType.TYPE:用于描述类、接口(包括注解类型)或enum声明
ElementType.METHOD:描述方法
ElementType.PARAMETER:描述参数
ElementType.TYPE_USE:可以标注任意类型
@Retention指Annotation被保留的时间长短,标明注解生命周期@Retention的取值有三种:
1.RetentionPolicy.SOURCE:表示注解仅存在于源代码中,编译成字节码后会被丢弃.这意味着在运行时无法获取到该注解的信息,只能在编译时使用.比如@SuppressWarnings,以及lombok提供的注解@Data,@slf4j
2.RetentionPolicy.CLASS:编译时注解.表示注解存在于源代码和字节码中,但在运行时会被丢弃.这意味着在编译时和字节码中可以通过反射获取到该注解的信息,但在实际运行时无法获取.通常用于一些框架和工具的注解.
3.RetentionPolicy.RUNTIME:运行时注解.表示注解存在于源代码,字节码和运行时中.这意味着在编译时,字节码中和实际运行时都可以通过反射获取到该注解的信息.通常用于一些需要在运行时处理的注解,如Spring的@Controller @ResponseBody
1.2.2切面类
使用@annotation切点表达式定义切点,只对@MyAspect生效
切面类代码如下:
@Slf4j
@Component
@Aspect
public class MyAspectDemo {
//前置通知
@Before("@annotation(com.example.demo.aspect.MyAspect)")
public void before(){
log.info("MyAspect -> before ...");
}
//后置通知
@After("@annotation(com.example.demo.aspect.MyAspect)")
public void after(){
log.info("MyAspect -> after ...");
}
}
1.2.3添加自定义注解
在TestController中的t1()和UserController中的u1()这两个方法上添加自定义注解@MyAspect,其他方法不添加
@MyAspect
@RequestMapping("/t1")
public String t1() {
return "t1";
}
@MyAspect
@RequestMapping("/u1")
public String u1(){
return "u1";
}
运行程序测试接口:
http://127.0.0.1:8080/test/t1
观察日志:
可以看到,切面通知被执行了
继续测试:
http://127.0.0.1:8080/test/t2, 切面通知未执行
http://127.0.0.1:8080/user/u1 , 切面通知执行
2.Sping AOP原理
上面我们主要学习了Spring AOP的应用,接下来我们来学习SpringAOP的原理,也就是Spring是如何实现AOP的.
Spring AOP是基于动态代理来实现AOP的,学习内容主要分以下两部分
1.代理模式
2.Spring AOP源码剖析
2.1代理模式
代理模式,也叫委托模式.
定义:为其他对象提供一种代理以控制对这个对象的访问.它的作用就是通过提供一个代理类,让我们在调用目标方法的时候,不再是直接对目标方法进行调用,而是通过代理类间接调用.
在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用.
使用代理前:
房屋中介:房屋进行租赁时,卖方会把房屋授权给中介,由中介来代理看房,房屋咨询等服务.
秘书/助理:合作伙伴找老板谈合作,需要先经过秘书/助理预约.
代理模式的主要角色:
1. Subject: 业务接口类. 可以是抽象类或者接口(不⼀定有)
2. RealSubject: 业务实现类. 具体的业务执行 , 也就是被代理对象.
3. Proxy: 代理类. RealSubject的代理.
比如房屋租赁
Subject 就是提前定义了房东做的事情, 交给中介代理, 也是中介要做的事情
RealSubject: 房东
Proxy: 中介
UML类图如下:
代理模式可以在不修改被代理对象的基础上,通过扩展代理类,进行一些功能的附加与增强.
根据代理的创建时期,代理模式分为静态代理和动态代理.
静态代理:由程序员创建代理类或特定工具自动生成源代码再对其编译,在程序运行前代理类的.class文件就已经存在了.
动态代理:在程序运行时,运用反射机制动态创建而成.
2.1.1静态代理
静态代理:在程序运行前,代理类的.class文件就已经存在了.(在出租房子之前,中介已经做好了相关的工作,就等租户来租房子了)
我们通过代码来加深理解.以房租租赁为例
1.定义接口(定义房东要做的事情,也是中介需要做的事情)
public interface HouseSubject {
void rentHouse();
}
2.实现接口(房东出租房子)
public class RealHouseSubject implements HouseSubject{
@Override
public void rentHouse() {
System.out.println("我是房东 , 我出租房⼦");
}
}
3.实现代理(中介,帮房东出租房子)
public class HouseProxy implements HouseSubject{
//将被代理对象声明为成员变量
private HouseSubject houseSubject;
public HouseProxy(HouseSubject houseSubject) {
this.houseSubject = houseSubject;
}
@Override
public void rentHouse() {
//开始代理
System.out.println("我是中介 , 开始代理");
//代理房东出租房⼦
houseSubject.rentHouse();
//代理结束
System.out.println("我是中介 , 代理结束");
}
}
4.编写测试用例:
public class StaticMain {
public static void main(String[] args) {
HouseSubject subject = new RealHouseSubject();
//创建代理类
HouseProxy proxy = new HouseProxy(subject);
//通过代理类访问⽬标⽅法
proxy.rentHouse();
}
}
运行结果:
上面这个代理实现方式就是静态代理
从上述程序可以看出,虽然静态代理也完成了对目标对象的代理,但是由于代码都写死了,对目标对象的每个方法的增强都是手动完成的,非常不灵活.所以日常开发几乎看不到静态代理的场景.
接下来新增需求:中介又新增了其他业务:代理房屋出售我们需要对上述代码进行修改
1.接口定义修改
public interface HouseSubject {
void rentHouse();
void saleHouse();
}
2.接口实现修改
public class RealHouseSubject implements HouseSubject{
@Override
public void rentHouse() {
System.out.println("我是房东 , 我出租房⼦");
}
@Override
public void saleHouse() {
System.out.println("我是房东 , 我出售房⼦");
}
}
3.代理类修改
public class HouseProxy implements HouseSubject{
//将被代理对象声明为成员变量
private HouseSubject houseSubject;
public HouseProxy(HouseSubject houseSubject) {
this.houseSubject = houseSubject;
}
@Override
public void rentHouse() {
//开始代理
System.out.println("我是中介 , 开始代理");
//代理房东出租房⼦
houseSubject.rentHouse();
//代理结束
System.out.println("我是中介 , 代理结束");
}
@Override
public void saleHouse() {
//开始代理
System.out.println("我是中介 , 开始代理");
//代理房东出租房⼦
houseSubject.saleHouse();
//代理结束
System.out.println("我是中介 , 代理结束");
}
}
从上述代码可以看出,我们修改接口(Subject)和业务实现类(RealSubject)时,还需要修改代理类(Proxy).
同样的,如果有新增接口(Subject)和业务实现类(RealSubject),也需要对每一个业务实现类新增代理类(Proxy).
既然代理的流程是一样的,有没有一种办法,让他们通过一个代理类来实现呢?这就需要用到动态代理技术了
2.1.2动态代理
相比于静态代理来说,动态代理更加灵活.
我们不需要针对每个目标对象都单独创建一个代理对象,而是把这个创建代理对象的工作推迟到程序运行时由JVM来实现.也就是说动态代理在程序运行时,根据需要动态创建生成.比如房屋中介,我不需要提前预测都有哪些业务,而是业务来了我再根据情况创建.我们先看代码再来理解.
Java也对动态代理进行了实现,并给我们提供了一些API,常见的实现方式有两种:
2.1.3JDK动态代理
JDK动态代理类实现步骤
1.定义一个接口及其实现类(静态代理中的HouseSubject和RealHouseSubject)
2.自定义InvocationHandler并重写invoke方法,在invoke方法中我们会调用目标方法(被代理类的方法)并自定义一些处理逻辑
3.通过Proxy.newProxyInstance(ClassLoader loader,Class<?>[ ] interfaces,InvocationHandlerh)方法创建代理对象
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class JDKInvocationHandler implements InvocationHandler {
//⽬标对象即就是被代理对象
private Object target;
public JDKInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 代理增强内容
System.out.println("我是中介 , 开始代理");
//通过反射调⽤被代理类的⽅法
Object retVal = method.invoke(target, args);
//代理增强内容
System.out.println("我是中介 , 代理结束");
return retVal;
}
}
创建⼀个代理对象并使用
public class DynamicMain {
public static void main(String[] args) {
HouseSubject target= new RealHouseSubject();
//创建⼀个代理类:通过被代理类、被代理实现的接口、⽅法调用处理器来创建
HouseSubject proxy = (HouseSubject) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
new Class[]{HouseSubject.class},
new JDKInvocationHandler(target)
);
proxy.rentHouse();
}
}
1.InvocationHandler
InvocationHandler接口是Java动态代理的关键接口之一,它定义了一个单一方法invoke(),用于处理被代理对象的方法调用.
public interface InvocationHandler {
/**
* 参数说明
* proxy:代理对象
* method:代理对象需要实现的⽅法,即其中需要重写的⽅法
* args:method所对应⽅法的参数
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
通过实现InvocationHandler接口,可以对被代理对象的方法进行功能增强.
2.Proxy
Proxy类中使用频率最高的方法是:newProxyInstance(),主要用来生成一个代理对象
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//...代码省略
}
这个方法一共有3个参数:
Loader:类加载器,用于加载代理对象.
interfaces:被代理类实现的一些接口(这个参数的定义,也决定了JDK动态代理只能代理实现了接口的一些类)
h:实现了InvocationHandler接口的对象
2.1.4CGLIB动态代理
JDK动态代理有一个最致命的问题是其只能代理实现了接口的类.
有些场景下,我们的业务代码是直接实现的,并没有接口定义.为了解决这个问题,我们可以用CGLIB动态代理机制来解决.
CGLIB(Code Generation Library)是一个基于ASM的字节码生成库,它允许我们在运行时对字节码进行修改和动态生成.CGLIB通过继承方式实现代理,很多知名的开源框架都使用到了CGLIB.例如Spring中的AOP模块中:如果目标对象实现了接口,则默认采用JDK动态代理,否则采用CGLIB动态代理
CGLIB动态代理类实现步骤
1.定义一个类(被代理类)
2.自定义MethodInterceptor并重写intercept方法,intercept用于增强目标方法,和JDK动态代理中的invoke方法类似
3.通过Enhancer类的create()创建代理类
添加依赖
和JDK 动态代理不同, CGLIB(Code Generation Library) 实际是属于⼀个开源项⽬ ,如果你要使用它的话 ,需要手动添加相关依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
⾃定义 MethodInterceptor(方法拦截器) 实现MethodInterceptor接口
public class CGLIBInterceptor implements MethodInterceptor {
//⽬标对象, 即被代理对象
private Object target;
public CGLIBInterceptor(Object target){
this.target = target;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodPro
// 代理增强内容
System.out.println("我是中介 , 开始代理");
//通过反射调⽤被代理类的⽅法
Object retVal = methodProxy.invoke(target, objects);
//代理增强内容
System.out.println("我是中介 , 代理结束");
return retVal;
}
}
创建代理类, 并使用
public class DynamicMain {
public static void main(String[] args) {
HouseSubject target= new RealHouseSubject();
HouseSubject proxy= (HouseSubject) Enhancer.create(target.getClass(),new
proxy.rentHouse();
}
}
1.MethodInterceptor
MethodInterceptor和JDK动态代理中的InvocationHandler类似,它只定义了一个方法intercept(),用于增强目标方法.
public interface MethodInterceptor extends Callback {
/**
* 参数说明:
* o: 被代理的对象
* method: ⽬标⽅法(被拦截的⽅法, 也就是需要增强的⽅法)
* objects: ⽅法⼊参
* methodProxy: ⽤于调⽤原始⽅法
*/
Object intercept(Object o, Method method, Object[] objects,
MethodProxy methodProxy) throws Throwable;
}
2. Enhancer.create()
Enhancer.create()用来生成一个代理对象
public static Object create(Class type, Callback callback) {
//...代码省略
}
参数说明:
type: 被代理类的类型(类或接口)
callback: ⾃定义⽅法拦截器 MethodInterceptor
3.总结
1.AOP是一种思想,是对某一类事情的集中处理.Spring框架实现了AOP,称之为SpringAOP
2.SpringAOP常见实现方式有两种:1.基于注解@Aspect来实现2.基于自定义注解来实现,还有一些更原始的方式,比如基于代理,基于xml配置的方式,但目标比较少见
3.SpringAOP是基于动态代理实现的,有两种方式:1.基本JDK动态代理实现2.基于CGLIB动态代理实现.运行时使用哪种方式与项目配置和代理的对象有关.