Spring|Spring5 之 AOP学习笔记 java|spring

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..."); } ... }

进行通知的配置 【Spring|Spring5 之 AOP学习笔记】1）在src目录下创建bean1.xml，并进行如下配置（注意这里要引入aop的名称空间），开启注解扫描：

2）使用注解在容器中创建User和UserProxy对象（即在类上添加@Component注解）：

//被增强的类 @Component public class User {public void add() {System.out.println("add......."); } }

@Component public class UserProxy {//前置通知 //@Before注解表示作为前置通知 @Before(value = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void before() {System.out.println("before........."); } }

3）在增强类上添加注解@Aspect：

@Component @Aspect public class UserProxy {//前置通知 //@Before注解表示作为前置通知 @Before(value = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void before() {System.out.println("before........."); } }

@Aspect表示生成代理对象

4）在Spring中开启AspectJ生成代理对象，即在配置文件（bean1.xml）中的加上aop:aspectj-autoproxy标签：

然后运行得到结果：

文章图片

可以看到，增强方法也执行了。
配置不同类型的通知除了之前所说的@Before通知之外，其他四种方式的通知分别如下：

//后置通知（返回通知） @AfterReturning(value = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void afterReturning() {System.out.println("afterReturning........."); }//最终通知 @After(value = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void after() {System.out.println("after........."); }//异常通知 @AfterThrowing(value = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void afterThrowing() {System.out.println("afterThrowing........."); }//环绕通知 @Around(value = "https://www.it610.com/article/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 = "https://www.it610.com/article/execution(* com.atguigu.spring5.aopanno.User.add(..))") public void pointdemo() {}

之后，改写通知注解里的参数：

@Before(value = "https://www.it610.com/article/pointdemo()") public void before() {System.out.println("before........."); }

文章图片

运行成功。
多个增强类的情况如果是多个增强类同时对一个基本类进行增强，此时我们可以设立他们之间的优先级。
可以通过注解@Order()来设立，参数内是数字，值越小优先级越高。
首先创建一个新的增强类PersonProxy，然后增加必要注解：

@Component @Aspect @Order(1) public class PersonProxy {//后置通知（返回通知） @Before(value = "https://www.it610.com/article/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

分别在配置文件中创建两个对象。
在Spring配置文件中配置切入点再继续在配置文件中加入下面的配置：

其中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(); }

测试，发现成功了：