Spring AOP

AOP简介

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

AOP的做法是将通用、与业务无关的功能抽象封装为切面类

切面可配置在目标方法的执行前、后运行，真正做到即插即用，在不修改源码的情况下，对程序进行扩展

AOP底层原理

AOP底层使用动态代理

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

JDK动态代理

需要使用 Proxy类的newProInstance方法

static Object  newProxyInstance(ClassLoader loader,类<?>[]interfaces,InvocationHandler h)
//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序

参数解读：

参数一：类加载器

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

参数三：实现这个接口InvacationHandler，创建代理对象，写增强的部分

1.创建接口

public interface UserDao {
    public int add(int a,int b);

    public String update(String id);
}

2.创建被增强的类

public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        System.out.println("方法obj被执行了...");
        return a+b;
    }

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

3.创建增强类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
        UserDaoImpl obj=new UserDaoImpl();
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(obj));
        int sum = userDao.add(1, 2);
        System.out.println(sum);
    }
}
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()+":传递的参数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object res=method.invoke(obj,args);
        //方法执行后
        System.out.println("方法之后执行..."+obj);
        return res;
    }
}

AOP

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

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

基于Aspectj实现AOP操作

1. 基于xml配置文件实现
2. 基于注解方式实现

引入AOP相关的依赖

maven

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
</dependency>
<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.10</version>
</dependency>
<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.5.4</version>
</dependency>

切入点表达式

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

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

配置文件（xml）

<?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">

<!--创建对象-->
<bean id="book" class="com.spring.aop.Book"></bean>
<bean id="bookProxy" class="com.spring.aop.BookProxy"></bean>
<!--配置aop增强-->
<aop:config>
	<!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.spring.aop.Book.buy(..))"/>
    <!--配置切入面-->
    <aop:aspect ref="bookProxy">
    	<!--增强作用在具体的方法上-->
        <aop:before method="before" pointcut-ref="p"/>
        <aop:after method="afert" pointcut-ref="p"/>
        <!--...-->
    </aop:aspect>
</aop:config>
</beans>

操作（基于注解）

配置文件

<?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.spring.aop"></context:component-scan>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

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

import org.springframework.stereotype.Component;

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

创建增强类

package com.spring.aop.aopanno;

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

@Component
@Aspect//生成代理对象
public class UserProxy {

    /**
     * 前置通知
     * @Before(value="execution()") 注解表示作为前置通知
     */
    @Before(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void before(){
        System.out.println("before.....");
    }

    /**
     *方法之后通知
     */
    @After(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void after(){
        System.out.println("after.....");
    }

    /**
     *方法返回值之后执行
     */
    @AfterReturning(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.....");
    }

    /**
     *异常通知
     */
    @AfterThrowing(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.....");
    }

    /**
     *环绕通知
     */
    @Around(value="execution(* com.spring.aop.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.....");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后.....");
    }
}