Spring-AOP

Posted 2020-12-13 viewts

一、概念

Aspect-Oriented-Programming(面向切面编程)，一种编程思想。

切面：Aspect，由切入点和额外功能(增强)组成。

作用：解决项目业务中额外功能冗余的问题。

二、业务中存在的问题

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void insertUser() {
        System.out.println("调用新建用户服务..."); // 额外功能
        userDao.insertUser(); // 核心功能
    }
}

 

业务中的两大逻辑：核心业务+额外功能，其中额外功能存在大量的代码冗余，使得项目维护存在极大隐患。在OOP(面向对象编程)中，通常会将日志输出等功能再封装一个类来处理冗余问题，今天我们尝试使用spring-aop来解决这个问题。

三、代理

 

在用AOP解决上述提到的问题之前，首先来思考一个问题，什么是代理？业务开发中常见的有静态代理和动态代理，AOP就是使用的动态代理，这里我们将静态代理和动态代理都来分析一下。

1）静态代理

public class UserServiceProxy implements UserService {
    private UserService userService = new UserServiceImpl();

    public void insertUser() {
        System.out.println("调用新建用户服务..."); // 额外功能
        userService.insertUser(); // 核心功能
    }
}

新建一个代理类来处理额外功能，代理类原则上要和目标(核心)保持功能一致，这通常使用接口约束或者继承来实现。代理类虽然从一定程度上简化了目标的业务逻辑，但这仍然没有解决代码冗余的问题。

2）动态代理

public class TestApp {
    @Test
    public void myTest() {
        // 1.目标
        final UserService userService = new UserServiceImpl();
        // 2.额外功能
        InvocationHandler invocationHandler = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("调用新建用户服务..."); // 额外功能
                method.invoke(userService, args); // 核心功能
                return null;
            }
        };
        // 3.组装(编织)
        UserService proxy = (UserService) Proxy.newProxyInstance(TestApp.class.getClassLoader(), userService.getClass().getInterfaces(), invocationHandler);
        proxy.insertUser();
    }
}

新建一个测试类，采用jdk中的反射来重新组装一个代理对象，jdk代理通过和目标实现相同的接口来保证功能一致。

三、AOP

 

1.导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>

2.确认target

<bean id="service" class="service.UserServiceImpl"></bean>

3.实现advice

public class MyBeforeAdvice implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("调用新建用户服务..."); // 额外功能
    }
}

同时在applicationContext.xml中声明:

<bean id="before" class="advice.MyBeforeAdvice"></bean>

4.编织weave

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

    <!-- 目标target -->
    <bean id="service" class="service.UserServiceImpl"></bean>

    <!-- 额外功能advice -->
    <bean id="before" class="advice.MyBeforeAdvice"></bean>

    <!-- 编织weave -->
    <aop:config>
        <!-- 切入点：目标中的方法 execution(修饰符 返回值 包.类.方法名(参数表)) -->
        <aop:pointcut id="pc" expression="execution(* service.UserServiceImpl.*(..))"/>
        <!-- 将额外功能编织到切入点中，组装一个新的proxy类 -->
        <aop:advisor advice-ref="before" pointcut-ref="pc"></aop:advisor>
    </aop:config>
</beans>

5.测试

@Test
public void testDynamicProxy() {
    // 启动工厂
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 获取代理对象，通过目标id获取
    UserService userService = context.getBean("service", UserService.class);
    userService.insertUser();
    // 关闭工厂
    context.close();
}

 

 

四、补充

 

1）五种额外功能

public class MyAfterAdvice implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("后置额外功能");
    }
}

// 环绕额外功能
public class MyMethodInterceptor implements MethodInterceptor {
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("开始");
        Object ret = methodInvocation.proceed();
        System.out.println("结束");
        return ret;
    }
}

异常额外功能在目标抛出异常时执行，不过大多数的异常处理都是交给controller来做的，了解即可；最终额外功能相当于try,catch,finally中的finally，不管你有没有抛出异常，最终它都执行。

2）三种切入点表达式

execution(修饰符可省略 返回值 *任意 包.类.方法名 *任意(参数表 ..任意))

within描述包和类，类中的所有方法都加入

args描述参数表，符合的方法都加入

联用，不同的表达式之间，可以使用逻辑运算：and or not