Spring AOP

本篇笔记简单的介绍了Spring中AOP的底层设计模式，在介绍主流的注解实现AOP，由于作者水平有限出现一些bug再多难免！

目录

简介

静态代理

动态代理

JDK动态代理实例

CGlib代理类实例

AOP在Spring中的作用

AOP的七大术语

Spring的通知类型

切点表达式

使用Spring实现AOP

方式一：基于注解方式完成AOP

方式二：使用配置文件完成aop（了解即可）

总结

---

简介

Spring AOP是Spring框架体系结构中非常重要的功能模块之一，该模块提供了面向切面编程实现。一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。这些系统服务称为：交叉业务。那么AOP的底层原理就是代理模式的具体实现。说到AOP就不得不先了解一下设计模式的代理模式。首先代理模式分为静态代理和动态代理。

静态代理

通过一张关于租房的生活事件来进行引入：

Java代码具体实现

//定义一个租房类型接口
public interface Procy {
    void  send();//提供租房服务
}
//房东的实现类
public class Host implements Procy{
    @Override
    public void send() {
        System.out.println("进行租房");
    }
}
//中介进行代理
public class Proces implements Procy{
    private  Host host=new Host();
​
    public Proces() {
    }
​
    public Proces(Host host) {
        this.host = host;
    }
​
    public  void  send(){
        host.send();
        show();
    }
​
    public  void  show(){//在原来的租房方法上还可以进行添加不同方法
        System.out.println("进行看房");
    }
}
//测试类
public class Demo {
    public static void main(String[] args) {
        Host host = new Host();
        Proces proces = new Proces(host);
        proces.send();
    }
}

测试效果

静态代理模式的好处：

可以使真实角色的操作更加纯粹！不用去关注一些公共的业务 公共也就交给代理角色！实现代码的分工！ 公共业务发生扩展的时候，方便集中管理！

缺点：

一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低~

动态代理

动态代理和静态代理角色都是一样！ 动态代理的代理类是动态生成的，不是我们写好的！ 动态代理分为两大类：基于接口的动态代理，基于类的动态代理 基于接口——JDK动态代理 基于类——cglib

JDK动态代理实例

//模拟用户的CRUD部分
public interface UserDao {
    void  addUser();
    void  updateUser();
    void  deleteUser();
    void  queryUser();
}
//实现类
public class UserDaoImpl implements UserDao{
    @Override
    public void addUser() {
        System.out.println("增加一个用户");
    }
​
    @Override
    public void updateUser() {
        System.out.println("修改一个用户");
    }
​
    @Override
    public void deleteUser() {
        System.out.println("删除一个用户");
    }
​
    @Override
    public void queryUser() {
        System.out.println("查询一个用户");
    }
}

动态代理类：

/*invoke()方法参数介绍
* 所有的动态代理的方法调用，将会交给invoke()方法去处理
* proxy:被代理的对象
* method:将要被执行的方法信息（反射）
* args:执行方法时需要的参数
*/

调用动态代理类进行测试

输出效果

CGlib代理类实例

public class UserDaos {
    public void addUser(){
        System.out.println("添加用户");
    }
​
    public void deleteUser(){
        System.out.println("删除用户");
    }
}

切面类

public class MyAspect {
​
    public void check_Permissions(){
        System.out.println("模拟检查权限...");
    }
​
    public void log(){
        System.out.println("模拟日志记录...");
    }
}

动态代理类

调用动态代理类进行测试

输出效果

好处：

一个动态代理类代理的是一个接口，一般就是一类业务。 一个动态代理类可以代理多个类，只要是实现了同一个接口即可

通过以上对于JDK动态代理与CGLib代理的简单介绍，使我们大致了解到代理模式的具体使用。那么在Spring的AOP使用的动态代理是JDK动态代理+CGlib动态代理技术。在Spring在这两种动态代理中灵活切换！

AOP在Spring中的作用

提供声明式事务：

允许用户自定义切面 横切关注点：跨越应用程序多个模块的方法或功能，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点，如：日志、缓存、事务等等...

AOP的七大术语

切面(Aspect)：切点+通知。即，它是一个类。 ​

通知(Advice)：通知又叫做增强。就是具体增强那个代码。 ​

目标对象(Target)：被织入通知的对象。 ​

代理对象(Proxy)：向目标应用通知之后创建的对象。 ​

切点(PointCut)：本质上就是方法（真正织入切面的那个方法叫做切点）。切面通知执行的“地点”的定义。 ​

连接点(JointPoint)：描述的是位置。与切入点匹配的执行点。 ​

织入(Weaving):把通知应用到目标对象的过程。

通过下图，我们可以很好的理解AOP的相关术语：

Spring的通知类型

环绕通知：在目标方法执行前和执行后实施增强，可用于日志记录、事务处理等。 ​

前置通知：在目标方法执行前实施增强，可用于权限管理等。 ​

后置返回通知：在目标方法成功执行后实施增强，可用于关闭流、删除临时文件等。 ​

后置（最终）通知：在目标方法成功执行后实施增强，与后置返回通知不同的是，不管发生是否发生异常都要执行该通知，可用于释 放资源。 ​

异常通知：在方法抛出异常后实施增强，可应用于异常处理、日志记录等。 ​

引入通知：在目标类中添加一些新的方法和属性，可用于修改目标类（增强类）

切点表达式

切点表达式用来定义通知(Advice)往那些方法上切入。 切点表达式语法格式：

execution([访问权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表)[异常]);

访问权限修饰符：可选项、没写就是4个权限都包括、写public就表示只包括公开的方法 返回值类型：必填项、*表示返回值类型任意 全限定类名：可选项、两个点".."代表当前包及子包下的所有类、省略时表示所有的类 方法名：必填项、 * 表示所有方法、 set* 表示所有的set方法 形式参数列表：必填项、(..)参数类型和个数随意的方法、(*)只有一个参数的方法 异常：可选项、省略时表示任意异常类型

日常使用的切点表达式：

execution(* 包名.*(..))

使用Spring实现AOP

Spring对AOP的实现包括两种方式： Spring框架结合AspectJ框架实现AOP，基于注解方式。 Spring框架结合AspectJ框架实现AOP，基于XML方式。

准备工作：使用AOP，需要导入依赖包

<!-- aspectjrt包的依赖 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.1</version>  
    </dependency>
<!-- aspectjweaver包的依赖 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.6</version>  
    </dependency>

Spring配置文件中添加context命名空间和aop命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">
</beans>

方式一：基于注解方式完成AOP

目标对象

public interface UserDao {
    void  insert();
​
    void update();
​
    void delete();
​
    void select();
}
//实现类
public class PersonDaoImpl implements PersonDao {
    @Override
    public void insert() {
        System.out.println("添加用户");
    }
​
    @Override
    public void delete() {
        System.out.println("删除用户");
    }
​
    @Override
    public void select() {
        System.out.println("查询用户");
    }
​
    @Override
    public void update() {
        System.out.println("更新用户");
    }
}

切面类

配置文件applicationContext.xml

测试类

执行结果

AspectJ注解表

方式二：使用配置文件完成aop（了解即可）

目标对象

public interface PersonDao {
    void insert();
​
    void delete();
​
    void select();
​
    void update();
}
//实现类
public class PersonDaoImpl implements PersonDao {
    @Override
    public void insert() {
        System.out.println("添加用户");
    }
​
    @Override
    public void delete() {
        System.out.println("删除用户");
    }
​
    @Override
    public void select() {
        System.out.println("查询用户");
    }
​
    @Override
    public void update() {
        System.out.println("更新用户");
    }
}

切面类

配置applicationContext.xml

测试类

执行结果

总结

这种横向抽取机制采用传统的OOP是无法办到的，因为OOP实现的是父子关系的纵向重用。但是AOP不是OOP的替代品，而是OOP的补充，它们是相辅相成的！