常见Spring内置AOP接口

Before通知

• 在目标方法被调用前调用，
• 切面需要实现的接口：org.springframework.aop.MethodBeforeAdvice

After通知

• 在目标方法被调用后调用
• 切面需要实现的接口：org.springframework.aop.AfterReturningAdvice

Throws通知

• 在目标方法抛出异常时调用
• 切面需要实现的接口：org.springframework.aop.ThrowsAdvice

Around通知

• 环绕通知：拦截对目标对象方法的调用，在被调用方法前后执行切面功能，例如：事务切面就是环绕通知
• 切面需要实现的接口：org.aopalliance.intercept.MethodInterceptor

原生Before通知示例

• 其他通知类型同理，不再重复演示

业务接口

package com.example.service;

/**
 * 定义业务接口
 */
public interface Service {
    //购买功能
    default void buy(){}
    //预定功能
    default String order(int orderNums){return null;}
}

业务实现类

package com.example.service.impl;

import com.example.service.Service;

/**
 * 图书业务实现类
 */
public class BookServiceImpl implements Service {
    @Override
    public void buy() {
        System.out.println("图书购买业务....");
    }

    @Override
    public String order(int orderNums) {
        System.out.println("预定图书: " + orderNums + " 册");
        return "预定成功";
    }
}

切面实现类

• 相当于使用了Spring内置的AOP前置通知接口：org.springframework.aop.MethodBeforeAdvice

package com.example.advice;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class LogAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        //3个参数：目标方法，目标方法返回值，目标对象
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println("[业务功能名称] :" + method.getName());
        System.out.println("[业务参数信息] :" + Arrays.toString(args));
        System.out.println("[业务办理时间] :" + sf.format(new Date()));
        System.out.println("--------- 具体业务如下 ---------");
    }
}

业务功能和切面功能整合

• 使用applicationContext.xml，看起来更加直观

    <!--创建业务对象-->
    <bean id="bookServiceTarget" class="com.example.service.impl.BookServiceImpl"/>
    <!--创建切面的对象-->
    <bean id="logAdvice" class="com.example.advice.LogAdvice"/>


    <!-- 相当于创建动态代理对象，用来在底层绑定业务和切面-->
    <bean id="bookService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置业务接口，底层的jdk动态代理需要用-->
        <property name="interfaces" value="com.example.service.Service"/>

        <!--配置切面，可以有多个-->
        <property name="interceptorNames">
            <list>
                <value>logAdvice</value>
            </list>
        </property>

        <!--待织入切面的业务功能对象，底层的jdk动态代理需要用-->
        <property name="target" ref="bookServiceTarget"/>
    </bean>

对比手写的AOP版本5

将上述applicationContext.xml的内容和AOP版本5中的ProxyFactory对比，上述xml作用就相当于我们手写的ProxyFactory作用：
获取到业务功能对象和切面功能对象，并将他们传给底层来获取动态代理对象，在底层完成切面功能的织入
不管是xml或者通过注解来整合业务和切面，Spring底层都是像手写的AOP版本5一样，通过jdk动态代理来实现的，只不过现在封装起来了

• AOP版本5中的ProxyFactory代理工厂

package com.example.proxy05;

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

/**
 * 代理工厂，获取动态代理对象
 */
public class ProxyFactory {
    //获取jdk动态代理对象
    //Service target 接口类型的业务功能对象
    //Aop aop 接口功能的切面功能对象
    public static Object getProxy(Service target, Aop aop){
        //使用内置类，返回jdk动态代理对象
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                //获取实现的所有接口
                target.getClass().getInterfaces(),
                //调用目标对象的目标方法
                new InvocationHandler() {
                    @Override
                    public Object invoke(
                            Object obj,
                            Method method,
                            Object[] args) throws Throwable {
                        //存放目标对象的目标方法的返回值
                        Object res = null;
                        try{
                            //切面功能
                            aop.before();
                            //业务功能，根据外部调用的功能，动态代理目标对象被调用的方法
                            res = method.invoke(target, args);
                            //切面功能
                            aop.after();
                        }catch (Exception e){
                            //切面功能
                            aop.exception();
                        }
                        return res;
                    }
                }
        );
    }
}

测试

package test;

import com.example.service.Service;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpringAOP {
    @Test
    public void testSpringAop(){
        //创建Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取动态代理对象
        Service agent = (Service) ac.getBean("bookService");
        //调用业务功能
        String res = agent.order(10);
        System.out.println("结果: " + res);
    }
}

测试输出

• Spring原生AOP前置通知在业务功能前顺利执行。底层的jdk动态代理也正确的反射调用了外部调用的目标方法，正确接收了参数并给出了返回值

[业务功能名称] :order
[业务参数信息] :[10]
[业务办理时间] :2022-08-23
--------- 具体业务如下 ---------
预定图书: 10 册
结果: 预定成功

Process finished with exit code 0

注意

• 在开发中一般不常用Spring原生的AOP支持，在需要时，常使用其他专门的AOP框架
• 手写AOP框架和简单演示Spring内置AOP通知接口是为了更好的理解AOP面向接口编程的思想