Spring5 之 AOP学习笔记
AOP
Spring有两个核心部分，除了一个是IOC，另外一个就是AOP
基本概念
-
面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
-
通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。
-
使用登录例子说明 AOP：
底层原理
Spring底层主要使用动态代理实现AOP
关于动态代理
这里推荐一篇博客，我感觉讲的还可以：Java动态代理
静态代理是我们手动为具有接口的类一个类创建另外一个继承该接口的类（代理类），在代理类实现我们需要增加的功能，并且在此基础上调用原有类的方法，最终实现：不改变原有类的代码的基础上增强原有类的功能。
当然，这个时候我们的最终使用对象是代理类，而不是原有类。
我们可以发现的是，静态代理要求的是实现创建好代理类的字节码文件，如果代理类过多，那么实现起来将特别麻烦。
动态代理就是摒弃静态代理的缺点，在原有对象运行的过程中动态的创建代理类的字节码文件。
使用动态代理的情况
主要有两种情况会使用到动态代理，分有接口和没接口
有接口的情况
有接口的情况使用JDK动态代理
创建原有接口实现类的代理对象，并实现增强的方法。
没接口的情况
没有接口的情况使用CGLIB动态代理
创建子类，继承原有类，并实现增强的方法。
JDK 动态代理
这里用JDK动态代理来做一个实例
使用Proxy类创建代理对象
JDK动态代理主要涉及java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler类。
Proxy里面有一个newProxyInstance方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
这个方法主要返回指定接口的代理类的实例。
该方法里有三个参数：
- 第一个参数是类加载器
- 第二个参数表示增强类所实现的接口，可以有多个
- 第三个参数是一个接口，需要被代理对象所实现（写增强的部分）
示例
创建接口
public interface UserDao {
int add(int a, int b);
String update(String id);
}
创建实现类
public class UserDaoImpl implements UserDao{
@Override
public int add(int a, int b){
return a + b;
}
public String update(String id){
return id;
}
}
现在需要通过动态代理，对Impl类的add方法和update方法做到加强。
使用Proxy类创建接口代理对象
创建JDKProxy类。因为newProxyInstance方法的第三个参数需要实现InvocationHandler接口，所以我们除了在传参处直接new一个匿名类，也可以通过传递实现该接口的内部类：
在该类里面创建内部类UserDaoProxy，UserDaoProxy类继承InvocationHandler接口，该接口有一个invoke方法，该方法用于写增强逻辑，UserDaoProxy
class UserDaoProxy implements InvocationHandler {
/**
* 谁被代理，就把谁传递进来
*/
private final Object obj;
public UserDaoProxy(Object obj){
this.obj = obj;
}
/**
* 增强的逻辑
* @param proxy
* @param method
* @param args
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前
System.out.println("方法之前被执行..." + method.getName() + " :传递的参数" + Arrays.toString(args));
Arrays.toString(args);
//被增强的方法执行
Object res = method.invoke(obj, args);
//方法之后
System.out.println("方法之后执行..." + obj);
return res;
}
}
主类如下：
public class JDKProxy {
public static void main(String[] args) {
Class[] interfaces = {
UserDao.class};
// 创建接口实现类的代理对象
UserDaoImpl userDao = new UserDaoImpl();
UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
int re = dao.add(1, 2);
System.out.println("result: " + re);
}
}
运行结果：
其实就是在原有基础上加上新的逻辑。
相关术语
这里只列出部分AOP术语
假如有一个User类，里面有四个基本方法：
class User{
public void add(){
};
public void delete(){
};
public void select(){
};
public void update(){
};
}
连接点
一个类里面哪些方法可以被增强，这些方法就称为连接点。
比如User类里面的四个方法理论上都可以被增强，所以四个方法都是连接点。
切入点
一个类中实际被增强的方法，被称为切入点。
比如只有add方法被增强了，那add方法就称为切入点，其余则不是。
通知/增强
实际增强的逻辑部分，称为通知或增强。
比如加强add方法时加入权限，那么权限部分代码就称为通知或者增强。
通知的类型
通知主要有五种，下面拿add方法举例
-
前置通知
通知部分代码中，在add方法执行之前执行的代码。
-
后置通知
通知部分代码中，在add方法执行之后执行的代码。
-
环绕通知
通知部分代码中，在add方法执行前后都执行的代码。
-
异常通知
通知部分代码中，add方法出现异常时执行的代码。
-
最终通知
通知部分代码中，无论add方法是否出现异常，最终都会执行的代码。
切面
切面表示一种动作，表示把通知应用到切入点的过程。
AOP操作
准备工作
在Sprin中主要基于AspectJ来实现AOP操作
关于AspectJ
AspectJ不是Spring的组成部分之一，而是一个独立的AOP框架，为了操作方便，一般会把Spring与之结合来进行AOP操作。
基于AspectJ实现AOP的两种方式
- 基于xml配置文件实现
- 基于注解方式实现（使用）
在项目中引入AOP相关依赖
主要引入如下依赖
切入点表达式
切入点表达式的作用主要是知道对哪个类里面的哪个方法进行增强
语法结构
execution(权限修饰符, 返回类型,类的全路径,方法名称(参数列表))，其中，权限修饰符可以省略。
省略的话要添加上空格，并默认为public
示例：
-
对某个包里的某个类的某个方法进行增强
excution(* com.example.qks.dao.BookDao.add(..)) -
对某个包里的某个类的所有方法进行增强
excution(* com.example.qks.dao.BookDao.*(..)) -
对某个包里的所有类的所有方法进行增强
excution(* com.example.qks.dao.*.*(..))
*表示所有返回类型，…表示可变长参数
基于注解
创建增强类与被增强类
基本类：
public class User {
public void add(){
System.out.println("add...");
}
}
增强类（代理）：
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
...
}
进行通知的配置
1）在src目录下创建bean1.xml，并进行如下配置（注意这里要引入aop的名称空间），开启注解扫描：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.atguigu.spring5.aopanno"/>
beans>
2）使用注解在容器中创建User和UserProxy对象（即在类上添加@Component注解）：
//被增强的类
@Component
public class User {
public void add() {
System.out.println("add.......");
}
}
@Component
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before() {
System.out.println("before.........");
}
}
3）在增强类上添加注解@Aspect：
@Component
@Aspect
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before() {
System.out.println("before.........");
}
}
@Aspect表示生成代理对象
4）在Spring中开启AspectJ生成代理对象，即在配置文件（bean1.xml）中的加上aop:aspectj-autoproxy标签：
<aop:aspectj-autoproxy/>
然后运行得到结果：
可以看到，增强方法也执行了。
配置不同类型的通知
除了之前所说的@Before通知之外，其他四种方式的通知分别如下：
//后置通知（返回通知）
@AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
System.out.println("afterReturning.........");
}
//最终通知
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after() {
System.out.println("after.........");
}
//异常通知
@AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterThrowing() {
System.out.println("afterThrowing.........");
}
//环绕通知
@Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前.........");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后.........");
}
运行项目，可以看到最终结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J5aIIcaf-1630931396282)(C:\Users\15998\AppData\Roaming\Typora\typora-user-images\image-20210906193802538.png)]
可以发现的是，除了@AfterThrowing，其他的通知都出现提示了。这只是因为add方法并没有报错。
现在我们手动给add方法制造错误：
@Component
public class User {
public void add() {
int a = 10 / 0;
System.out.println("add.......");
}
}
再次运行项目，可以发现@AfterThrowing报错了：
结合这次的结果，可以发现报错之后@AfterReturning并没有通知，由此我们可以总结出他们的执行情况。
相同切入点的提取
仔细观察上面注解的参数，发现只要是针对同一个方法，那参数的写法就都是一样的。现在我们可以将其提取，避免重复编写。
首先在UserProxy类添加pointdemo空方法，方法上使用@Pointcut注解，注解参数写上之前通知注解里面的参数：
//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
之后，改写通知注解里的参数：
@Before(value = "pointdemo()")
public void before() {
System.out.println("before.........");
}
运行成功。
多个增强类的情况
如果是多个增强类同时对一个基本类进行增强，此时我们可以设立他们之间的优先级。
可以通过注解@Order()来设立，参数内是数字，值越小优先级越高。
首先创建一个新的增强类PersonProxy，然后增加必要注解：
@Component
@Aspect
@Order(1)
public class PersonProxy {
//后置通知（返回通知）
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
System.out.println("Person Before.........");
}
}
然后在UserProxy上增加@Order(2)注解：
@Component
@Aspect //生成代理对象
@Order(2)
public class UserProxy {
...
}
运行之后可以看到结果：
注意，优先级不影响执行与否，所有增强方法还是会全部执行
基于配置文件
创建增强类与被增强类
创建一个新包，里面创建两个类Book和BookProxy：
public class Book {
public void buy() {
System.out.println("buy.............");
}
}
public class BookProxy {
public void before() {
System.out.println("before.........");
}
}
上面的before方法要求在buy方法之前实现。
在Spring配置文件中创建两个类对象
创建一个新的配置文件bean2.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="book" class="com.atguigu.spring5.aopxml.Book"/>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"/>
beans>
分别在配置文件中创建两个对象。
在Spring配置文件中配置切入点
再继续在配置文件中加入下面的配置：
<aop:config>
<aop:pointcut id="point" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
<aop:aspect ref="bookProxy">
<aop:before method="before" pointcut-ref="point"/>
aop:aspect>
aop:config>
其中aop:pointcut的id随缘起，下面的切面的子注解中，aop:before表示增强在方法之前，跟之前的@Before作用一样，method参数的值就是BookProxy类中的方法，pointcut-ref的值就是上面aop:pointcut的id。
编写测试方法：
@Test
public void testAopXml() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.buy();
}
测试，发现成功了：
完全注解开发
对于一开始的基于注解的AOP，在运用过程中我们可以发现还是需要编写xml配置文件。
Spring允许我们使用完全基于注解的开发，此时需要写一个配置类，使用@ComponentScan和@EnableAspectJAutoProxy：
@Configuration
@ComponentScan(basePackages = {
"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
@Configuration：在Spring开发中，被其注释的类将在解析过程中作为类似于一个xml配置文件的存在
@ComponentScan：作用跟
@EnableAspectJAutoProxy：作用跟