AOP概念，底层原理，AspectJ

AOP的详细讲解

- - - AOP（概念）:

AOP（概念）:

什么是AOP？

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

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

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

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

AOP底层原理：

AOP底层使用动态代理

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

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

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

在这里插入图片描述

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

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

在这里插入图片描述

AOP（JDK动态代理）：

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

在这里插入图片描述

（1）调用newProxyInstance方法
在这里插入图片描述

方法有三参数：

第一个参数，类加载器

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

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

编写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;
        }
    }
}

AOP（术语）

连接点

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

实际被增强的点，称为切入点
通知（增强）

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

（2）通知有多种类型

*前置通知

*后置通知

*环绕通知

*异常通知

*最终通知
切面

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

AOP操作（准备）：

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

（1）什么是AspectJ
- 面向切面的框架
- AspectJ不是spring组成部分，独立AOP框架，一般把AspectJ和spring框架一起使用，进行AOP操作
基于AspectJ实现AOP操作

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

（2）基于注解方式实现
在项目工程引入AOP相关依赖

在这里插入图片描述

切入点表达式

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

（2）语法结构：

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

AOP操作（AspectJ注解）

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

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

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

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

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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">
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan>

    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

配置不同类型的通知

（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.......

相同切入点抽取

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

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

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

在增强类的上面添加注解，@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.........");
    }
}

在这里插入图片描述

完全使用注解开发

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

AOP操作（AspectJ配置文件）

创建两个类，增强类和被增强类，创建方法
在spring配置文件中创建两个对象

<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

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

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>