AOP概念，底层原理，AspectJ

• • • • AOP（概念）:
      • • AOP底层原理：
        • AOP（JDK动态代理）：
        • AOP（术语）
        • AOP操作（准备）：
        • AOP操作（AspectJ注解）
        • AOP操作（AspectJ配置文件）

1. 什么是AOP？

   （1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑个部分之间的耦合度降低，提高程序的重用性，同时提高了开发的效率。

   （2）通俗描述：不通过修改源代码的方式，在主干功能里添加新功能

   （3）使用登录的功能来说明

   （4）应用场景：日志、权限检查、
   

1. AOP底层使用动态代理

   （1）有两种情况动态代理

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

   *创建接口实现类，使用JDK代理实现类增强方法

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

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

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

（1）调用newProxyInstance方法

方法有三参数：

第一个参数，类加载器

第二个参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三个参数，实现接口IncocationHandler，创建代理对象，写增强方法

2. 编写JDK动态代理代码

（1）创建接口

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

（2）创建接口里的实现类

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

（3）使用Proxy类创建接口代理对象
https://blog.csdn.net/zhangzhen02/article/details/106121718?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_baidulandingword~default-4.pc_relevant_without_ctrlist&spm=1001.2101.3001.4242.3&utm_relevant_index=7

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces={UserDao.class};
        UserDaoImpi userDaoImpi=new UserDaoImpi();
        UserDao dao=(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoPRoxy(userDaoImpi));
        int add=dao.add(1,2);
        System.out.println(add);
    }
    //创建代理对象代码
    static class  UserDaoPRoxy implements InvocationHandler{
        //1. 把创建的是谁的代理对象，把谁传递过来
        //有参构造传递
        private Object obj;
        public UserDaoPRoxy(Object obj){
            this.obj=obj;
        }

        // 增强的逻辑
        @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;
        }
    }
}

1. 连接点

   类里面哪些方法可以被增强，这些方法称为连接点

2. 切入点

   实际被增强的点，称为切入点

3. 通知（增强）

   （1）实际增强的逻辑部分称为通知（增强）

   （2）通知有多种类型

   ​ *前置通知

   ​ *后置通知

   ​ *环绕通知

   ​ *异常通知

   ​ *最终通知

4. 切面

   把通知应用到切入点的过程

1. Spring框架一般基于AspectJ实现AOP操作

   （1）什么是AspectJ

   • 面向切面的框架
   • AspectJ不是spring组成部分，独立AOP框架，一般把AspectJ和spring框架一起使用，进行AOP操作

2. 基于AspectJ实现AOP操作

   （1）基于xml配置文件实现

   （2）基于注解方式实现

3. 在项目工程引入AOP相关依赖

4. 切入点表达式

   （1）切入点表达式作用：

   （2）语法结构：

   execution([权限修饰符] [返回类型] [类全路劲] [方法名称] ([参数列表])

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

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

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

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

3. 在spring配置文件中开启生成代理对象

4. 配置不同类型的通知

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

package com.atguigu.spring5.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect  //生成代理对象
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }
    //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo() {

    }
    
    //后置通知（返回通知）
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知，相当于try-catch中的 finally
    @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("环绕之后.........");
    }
}

@Test
public void testAopAnno() {
    ApplicationContext context =
        new ClassPathXmlApplicationContext("bean1.xml");
    User user = context.getBean("user", User.class);
    user.add();
}
运行结果：
before.........
add.......

5. 相同切入点抽取

//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {

}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
    System.out.println("before.........");
}

6. 有多个增强类，可以设置优先级

   在增强类的上面添加注解，@Order（值），这个值数字越小优先级越高

@Component
@Aspect
@Order(1)    //通过@Order（1）来设置优先级
public class PersonProxy {
    //后置通知（返回通知）
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning() {
        System.out.println("Person Before.........");
    }
}

7. 完全使用注解开发

   @Configuration
   @ComponentScan(basePackages = {"com.atguigu"})
   @EnableAspectJAutoProxy(proxyTargetClass = true)
   public class ConfigAop {
   }
   

1. 创建两个类，增强类和被增强类，创建方法

2. 在spring配置文件中创建两个对象

4. 在spirng配置文件中配置切入点