AOP

2021/9/18 6:05:35

编程Tag： 方法代理 class aop 增强 public

本文主要是介绍AOP，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

AOP（概念）

AOP(Aspect Oriented Programming) 面向切面编程
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
在不修改源代码的情况下，在主干功能里面添加新功能

AOP（底层原理）

AOP 底层使用动态代理

有两种情况动态代理

第一种：有接口情况，使用 JDK 动态代理

创建接口实现类代理对象，增强类的方法

第二种：没有接口情况，使用 CGLIB 动态代理

创建子类的代理对象，增强类的方法

AOP （JDK 动态代理）

1. 使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象

调用 newProxyInstance 方法，这个方法返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
newProxyInstance方法有三个参数：
- 参数一：类加载器
- 参数二：增强方法所在的类，这个类的实现接口，支持多个接口
- 参数三：实现这个接口InvocationHandler，创建代理对象写增强的方法

2. 编写 JDK 动态代理代码

创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

使用 Proxy 类创建接口代理对象（不太清楚，看动态代理）

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 result = dao.add(1, 2);
        System.out.println("result:" + result);
    }
}

// 创建代理对象代码
public class UserDaoProxy implements InvocationHandler {

    // 创建的是谁的代理对象，就把谁传递过来
    // 有参构造传递
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    // 增强的部分写 invoke 方法里面
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 方法之前执行
        System.out.println("方法之前执行..." + method.getName() + "————传递的参数" + Arrays.toString(args));

        // 被增强的方法执行
        Object res = method.invoke(obj, args);

        // 方法之后执行
        System.out.println("方法之后执行。。。" + obj);

        return res;
    }
}

AOP（术语）

连接点：类里面可以被增强的方法，称为连接点
切入点：实际真正被增强的方法，称为切入点
通知（增强）：实际增强的逻辑部分，称为通知(增强)
- 通知有五个类型：
  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常通知
  5. 最终通知
切面：把通知应用到切入点的过程，称为切面

AOP操作（准备）

Spring要实现AOP操作，一般基于AspectJ实现AOP操作
1. 什么是AspectJ
  - AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spring 框架一起使用进行 AOP 操作
基于AspectJ实现 AOP 操作
1. 基于 XML 配置文件实现
2. 基于注解方式实现（常用）
在项目工程中引入 AOP 相关依赖

切入点表达式

切入点表达式作用：知道对哪个类里面的那个方法进行增强

语法结构：

execution(权限 返回值类型 类的全路径 方法名(参数列表)

例1：对 com.wnaoii.spring5.UserDaoImpl 类里的 add 方法进行增强

// * 号代表任意类型
// 返回类型可以不写
execution(* com.wnaoii.spring5.UserDaoImpl.add(需要的参数))

例2：对 com.wnaoii.spring5.UserDaoImpl 类里的所有方法进行增强

// 把方法名换成通配符*
execution(* com.wnaoii.spring5.UserDaoImpl.*(需要的参数))

例3：对 com.wnaoii.spring5包里所有的类，类里的所有方法进行增强

execution(* com.wnaoii.spring5.*.*(需要的参数))

AOP 操作（AspectJ注解）

创建类，在类里面定义方法

// 被增强的类
public class User {
    public void add() {
        System.out.println("add方法已执行---");
    }
}

创建增强类（编写增强逻辑）

在增强类里创建方法，让不同的方法代表不同的通知类型

// 增强的类
public class UserProxy {
    // 前置通知
    public void before() {
        System.out.println("before方法执行---");
    }
}

进行通知的配置

在 Spring 配置文件中，开启注解扫描(也可以用注解创建配置类)

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.wnaoii"></context:component-scan>
</beans>

使用注解创建 User 和 UserProxy 对象

// 加上@Component注解
@Component
public class User {...}

// 加上@Component注解
@Component
public class UserProxy {...}

在增强类上面添加注解 @Aspect

// 增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {...}

@Aspect注解报错就是jar包没导

在 Spring 配置文件中开启生成代理对象

<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置不同类型的通知

在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

// 增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.wnaoii.spring5.aopanno.User.add(..))")
    public void before() {
        System.out.println("before方法执行---");
    }
}

(待续)

这篇关于AOP的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

AOP