1. AOP基本概念

1.1 什么是AOP

（1）面向切面编程（方面）， 利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （3）使用登录例子说明 AOP 问题： 怎么配置新功能？？？

1.2 AOP底层原理

1.2.1 AOP底层使用动态代理方式来增加功能

有2种情况的动态代理：

1. 有接口情况： 使用jdk动态代理
2. 没有接口情况： 使用CGLIB动态代理

   

   2. 两种动态代理

   
   2.1 JDK的动态代理—-针对接口

   2.1.1 逻辑分析

   使用java.lang.proxy类里面的方法。

2.1.2 代码实现

step1. 创建interface, 创建方法

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

step2: 创建interface接口实现类，写实现方法

public class UserDaoImp implements UserDao {
  @Override
  public int add(int a, int b) {
    return a + b;
  }
  @Override
  public String update(String id) {
    return id;
  }
}

step3: 增强的逻辑—-现实InvocationHandler接口
method.invoke();

// 创建代理对象代码
class UserDaoImpProxy implements InvocationHandler {
  // step1: 需要增强谁的功能，就需要把谁传递过来--->此处是userDaoImp
  // 通过有参构造传递
  private Object obj;
  public UserDaoImpProxy(Object obj) {
    this.obj = obj;
  }
  // 增强的逻辑,eg： 增强add() 和update()
    /**
    *  proxy: 被代理的类
    */
  @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("方法之后执行。。。。。");
    return res;
  }
}

step4: 合并接口、原始的接口实现类、增强类
Proxy.newProxyInstance()
注：增强类的初始化依赖于原始的接口实现类

public class JDKProxy {
  public static void main(String[] args) {
    // 创建接口实现类的代理对象
    Class[] interfaces = {UserDao.class}; // 接口集合
    UserDaoImp userDaoImp = new UserDaoImp();
    UserDao userDao1 =
        (UserDao)
            Proxy.newProxyInstance(
                JDKProxy.class.getClassLoader(), interfaces, new UserDaoImpProxy(userDaoImp));
    int res = userDao1.add(1, 2);
    System.out.println("res:" + res);
    String update = userDao1.update("68672497");
    System.out.println(update);
  }
}

3. AOP术语

3.1 连接点 切入点 通知（增强）切面

4. AOP操作（Aspect Oriented Programming）

4.1 AOP操作（基于AspectJ注解）

4.1.1 准备

4.1.1.1 Spring框架一般都是基于AspectJ 实现AOP操作

1. 什么是AspectJ ?

| AspectJ 不是 Spring 组成部分，而是独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行AOP操作

| | —- |

4.1.1.2 基于AspectJ实现AOP操作的2种方式

4.1.2 实现

4.1.2.1 引入依赖

4.1.2.2 切入点表达式

让Spring知道要对哪个类中的哪个方法进行增强。
execution（【权限修饰符】【返回类型】【类的全路径】【方法名称】【参数列表】)

4.1.2.3 基于AspectJ注解的实现过程

1. 创建一个原始类

   public class User {
   public void add() {
    System.out.println("add.....");
   }
   }

2. 创建增强类：对上述类中方法进行增强

   // 增强类
   public class UserProxy {
    // 前置通知
   public void before() {
    System.out.println("before....");
   }
   }

3. 配置配置

step1: 在xml中开启注解扫描，需要使用context和aop名称空间

<!--开启注解扫描-->
    <context:component-scan base-package="com.atguigu.spring5.annotation"></context:component-scan>

step2: 使用注解创建User和UserProxy对象


step3: 在增强类上面加上注解@Aspect

step4: 在spring配置文件中开启生成对象的代理配置

<!--开启aspectJ,生成代理类的对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

step5: 配置不同类型的通知
@before

// 增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知----》先执行增强的代码，再执行被增强的部分
    @Before(value = "execution(* com.atguigu.spring5.annotation.User.add(..))")
    public void before() {
        System.out.println("before....");
    }
}

step6: 测试

public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }

4.1.3 其他通知

@before   // 在方法之前执行
@after    // 在方法之后执行，不管有没有异常都执行
@afterReturning   // 在方法返回值之后执行，方法有异常，则不通知（即不执行）
@afterThrowing   //方法有异常后才执行
@around   // 环绕通知， 在方法的之前、之后都通知

注意环绕通知写法：

@Around(value = "execution(* com.atguigu.spring5.annotation.User.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("在被增强的方法之前执行。。。");
    proceedingJoinPoint.proceed();  // 被增强的方法执行
    System.out.println("被增强的方法之后执行。。。。");
    }

4.1.4 对相同的切入点进行抽取

解析： 抽取公共点的表达式

// 抽取公共的切入点
    @Pointcut(value ="execution(* com.atguigu.spring5.annotation.User.add(..))" )
    public void pointDemo(){
    }

    // 前置通知
    @Before(value = "pointDemo()")
    public void before() {
        System.out.println("before....");
    }

4.1.5 相同切入点，多个增强方法的优先级设置

4.2 AOP操作（基于AspectJ配置文件）—-了解即可