【Spring】AOP

Spring的AOP学习笔记

一、AOP概述

AOP：
- （1）面向切面（方面）编程
- （2）通俗描述：不通过修改源码的方式，在主干功能里面添加新功能
举例：
- 拿登录作为例子

二、AOP底层原理

2.1 动态代理

AOP底层使用到了动态代理
- 有两种情况的动态代理
  - 有接口：使用JDK动态代理
  - 无接口：使用CGLIB动态代理

有接口：

无接口

2.2 JDK动态代理实例

（1）使用JDK动态代理，使用Proxy类里面的方法创建代理对象
- public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
- 参数1：ClassLoader(类加载器)
- 参数2：interfaces(接口)
- 参数3：InvocationHandler(一个接口，其实现类填写增强的方法)

（2）JDK动态代理代码

public class JDK {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        //创建代理类，等同于创建userDao类
        UserDao proxyInstance = (UserDao)Proxy.newProxyInstance(JDK.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        proxyInstance.add(1, 2);
    }
}

//（1）创建接口，定义方法
interface UserDao{
     public abstract int add(int a, int b);

     public abstract String update(String id);
}

//（2）创建借口实现类，实现方法
class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        return a + b;
    }

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

//(3)创建代理对象的代码
class UserDaoProxy implements InvocationHandler {
     //把要代理的对象，传递进代理类
    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());
        System.out.println("传递的参数" + Arrays.toString(args));

        //执行方法：
        Object res = method.invoke(obj, args);

        //方法之后的处理：
        System.out.println("方法之后执行：" + res);

        return res;
    }
}

三、AOP框架

3.1 aop术语

（1）连接点：类中可以被增强的方法，被称为连接点
（2）切入点：实际被真正增强的方法，被称为切入点
（3）通知（增强）：实际增强的逻辑部分
- 通知的种类：
  - 前置通知（Before）
  - 后置通知（AfterReturning）
  - 环绕通知（Around）
  - 异常通知（AfterThrowing）
  - 最终通知（After）

3.2 aop使用了解

（1）Spring框架一般都是基于AspectJ实现AOP操作
- AspectJ：AspectJ不是Spring的组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

（2）基于AspectJ实现AOP操作
- 基于xml配置文件实现
- 基于注解方式实现（推荐使用）

（3）在项目工程中引入相关依赖
- 首先是IOC的相关Jar包：beans、context、core、expression、logging、aop外
- 还需要Spring自带的：aspects
- 以及额外的：cglib、aopalliance、weaver

（4）切入点表达式
- 切入点表达式作用：知道哪个类是对哪个类进行增强
- 语法结构：
  - execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
- 举例一：对com.letere.dao.BookDao类里面的add进行增强
  - `execution(* com.letere.dao.BookDao.add(..))
- 举例二：对com.letere.dao.BookDao类里面的所有方法进行增强
  - execution(* com.letere.dao.BookDao.*(..))
- 举例三：对com.letere.dao包内所有类里面的所有方法进行增强
  - execution(* com.letere.dao.*.*(..))

四、基于注解实现AOP操作

4.1 操作步骤

（1）创建一个类（被增强类），在类里面定义方法

（2）创建一个增强类（里面填写增强的逻辑）

（3）进行通知配置
- 在Spring配置文件中，开启组件扫描
- 使用注解创建User和UserProxy对象
- 在增强类中添加注解@Aspect
- 在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名称空间、生成aop名称空间-->
    
	<!--开启注解扫描-->
    <context:component-scan base-package="annotationAspectJ"></context:component-scan>

    <!--开启AspectJ生成代理对象-->
        <!--一旦搜到@AspectJ注解，就将此类生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	
</beans>

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

@Component
@Aspect
class UserProxy{
    public void before(){
        System.out.println("before...");
    }
}

（4）配置不同类型的通知
- 在增强类里面，在作为通知方法上面添加通知类型
  - @Before(value = "execution()")
  - @After(value = "execution()")
  - @AfterReturning(value = "execution()")
  - @AfterThrowing(value = "execution()")
  - @Around(value = "execution()")

@Component
@Aspect
class UserProxy{
    //前置通知
    @Before(value =  "execution(* annotationAspectJ.User.add(..))")
    public void before(){
        System.out.println("before...");
    }

    //最终通知，在方法执行后执行，出现异常也一样执行
    @After(value = "execution(* annotationAspectJ.User.add(..))")
    public void after(){
        System.out.println("after...");
    }

    //后置（返回）通知，在返回值之前执行
    @AfterReturning(value = "execution(* annotationAspectJ.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    //异常通知，出现异常时执行
    @AfterThrowing(value = "execution(* annotationAspectJ.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }

    //环绕通知，可在方法之前/之后执行
    @Around(value = "execution(* annotationAspectJ.User.add(..))")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("beforeAround...");

        try {
            pjp.proceed();//执行方法，类似代理模式下的代理对象
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        System.out.println("afterAround...");
    }
}

（5）公共切入点抽取
- 重用切入点:@pointCut(value = “execution()”)

@Component
@Aspect
class UserProxy{
	//切入点
    @Pointcut(value = "execution(* annotationAspectJ.User.add(..))")
    public void pointCut(){}

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

（6）一个方法有多个增强类，可以设置优先级
- 在增强类上面添加注解@Order(数字类型值)，数字类型值越小，优先级越高

4.2 纯注解开发形式

配置类

@Configuration
@ComponentScan(basePackages = {"annotationAspectJ"})//注解扫描位置
@EnableAspectJAutoProxy(proxyTargetClass = true)//识别@Aspect，生成代理类
public class classConfig {
}

五、基于xml配置文件实现AOP操作

5.1 操作步骤

（1）创建两个类，增强类和被增强类，创建方法
（2）在Spring配置文件中创建两个类的对象
（3）在Spring配置文件中配置切入点

class Book{
    public void buy(){
        System.out.println("buy...");
    }
}

class BookProxy{
    public void before(){
        System.out.println("before buy...");
    }
}

<?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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--创建aop名称空间-->
    
    <!--创建对象-->
    <bean id="book" class="xmlAspectJ.Book"></bean>
    <bean id="bookProxy" class="xmlAspectJ.BookProxy"></bean>

    <!--配置aop增强-->
    <aop:config>
        <!--切入点pointCut-->
        <aop:pointcut id="p" expression="execution(* xmlAspectJ.Book.buy(..))"/>

        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体的哪个方法上-->
            <!--将before方法配置到p的bug方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
    
</beans>