Spring（十七）：Spring AOP（一）：简介

背景：

需求：

给一个计算器计算函数执行前后添加日志。

实现：

1）直接在函数中修改代码；

IArithmeticCalculator.java接口类

package com.dx.spring.beans.aop;

public interface IArithmeticCalculator {

    // Addition, subtraction, multiplication, and division

    int add(int i, int j);

    int sub(int i, int j);

    int multi(int i, int j);

    int div(int i, int j);

}

实现类中添加日志：

package com.dx.spring.beans.aop;

public class ArithmeticCalculatorImpl implements IArithmeticCalculator {

    @Override

    public int add(int i, int j) {

        System.out.println("method add before");

        int result = i + j;

        System.out.println("method add after");

        return result;

    }

    @Override

    public int sub(int i, int j) {

        System.out.println("method sub before");

        int result = i - j;

        System.out.println("method sub after");

        return result;

    }

    @Override

    public int multi(int i, int j) {

        System.out.println("method multi before");

        int result = i * j;

        System.out.println("method multi after");

        return result;

    }

    @Override

    public int div(int i, int j) {

        System.out.println("method div before");

        int result = i / j;

        System.out.println("method div after");

        return result;

    }

}

2）Java动态代理，实现参考《Java中动态代理方式：》；

ArithmeticCalculatorImpl.Java实现：

package com.dx.spring.beans.aop;

public class ArithmeticCalculatorImpl implements IArithmeticCalculator {

    @Override

    public int add(int i, int j) {

        int result = i + j;

        return result;

    }

    @Override

    public int sub(int i, int j) {

        int result = i - j;

        return result;

    }

    @Override

    public int multi(int i, int j) {

        int result = i * j;

        return result;

    }

    @Override

    public int div(int i, int j) {

        int result = i / j;

        return result;

    }

}

ProxyFactory.java动态代理工厂：

package com.dx.spring.beans.aop;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class ProxyFactory {

    private Object target=null;

    public ProxyFactory(Object target) {

        this.target = target;

    }

     /**

     * 给目标对象生成代理对象

     */

    public Object getProxyInstance() {

        ClassLoader classLoader = target.getClass().getClassLoader();

        Class<?>[] interfaces = target.getClass().getInterfaces();

        InvocationHandler invocationHandler = new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                before(method);

                // 执行目标对象方法

                Object returnValue = method.invoke(target, args);

                after(method);

                return returnValue;

            }

        };

        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

    }

    private void before(Method method) {

        System.out.println("before " + method);

    }

    private void after(Method method) {

        System.out.println("after " + method);

    }

}

调用测试Client.java:

package com.dx.spring.beans.aop;

public class Client {

    public static void main(String[] args) {

        IArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();

        // int result=arithmeticCalculator.add(1, 2);

        // System.out.println(result);

        IArithmeticCalculator arithmeticCalculatorProxyFactory = (IArithmeticCalculator) new ProxyFactory(arithmeticCalculator).getProxyInstance();

        int result = arithmeticCalculatorProxyFactory.add(1, 2);

        System.out.println(result);

    }

}

3）Spring AOP实现。

下边会举例，这里暂时不举例。

AOP：

AOP简介：

1）AOP（Aspect-Oriented Programming，面向切面编程）：是一种新的方法论，是对传统OOP(Object-Oriented Programming，面向对象编程)的补充。

2）AOP的主要编程对象是切面（aspect），而切面模块化横切关注点。

3）在应用AOP编程时，任然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。

4）AOP的好处：

---- 每个事物逻辑位于一个位置，代码不分散，便于维护和升级；

---- 业务模块更简洁，只包含核心业务代码。

AOP术语：

1）切面（aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象；

2）通知（advice）：切面必须要完成的工作；

3）目标（target）：被通知的对象；

4）连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。

连接点由两个信息确定：方法表示的程序执行点、相对点表示的方位。

例如：ArithmethicCalculator#add()方法执行前的连接点执行点为ArithmethicCalculator#add()；方位为该方法执行前的位置。

5）切点（pointcut）：每个类都拥有多个连接点：例如ArithmethicCalculator的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。

AOP通过切点位置到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。

Spring AOP

1）AspectJ：java社区里最完整最流行的AOP框架。在Spring2.0以上版本中，可以使用AspectJ注解或基于XML配置的AOP。

备注：先学习基于AspectJ注解的方式，接着再学习基于XML配置。

2）在Spring中启动AspectJ注解支持：

要在Spring应用中使用AspectJ注解，必须在ClassPath下包含AspectJ类库：aopalliance.jar、aspectj.wearver.jar和spring-aspects.jar；
将aop schema添加到<beans>根元素中；
要在Spring IOC容器中启用AspectJ注解支持，只要在Bean配置文件中定义一个空的xml元素<aop:aspectj-auotproxy>；
当Spring IOC容器侦测到Bean配置文件中的<aop:aspectj-autoproxy>元素是，会自动为与aspectj切面匹配的bean创建代理。

Spring AOP实现需求：

第一步：导入spring aop依赖包&额外依赖包（aopalliance.jar、asm.jar、aspectjrt.jar、aspectjweaver.jar）；

Aop额外依赖包：aopalliance.jar、asm.jar、aspectjrt.jar、aspectjweaver.jar下载：链接：https://pan.baidu.com/s/1SjYtrfrUwPIZXikr4guXkg 密码：lowr

第二步：添加spring-aop.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:aop="http://www.springframework.org/schema/aop"

    xmlns:context="http://www.springframework.org/schema/context"

    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-4.3.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 配置自动扫描的包 -->

    <context:component-scan base-package="com.dx.spring.beans.aop"></context:component-scan>

    <!-- 配置是AspectJ注解起作用 ：自动为匹配的类生成代理对象 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

第三步：添加Spring组件

IArithmeticCalculator.java组件接口

package com.dx.spring.beans.aop;

/**

 * Description：Addition, subtraction, multiplication, and division

 */

public interface IArithmeticCalculator {

    int add(int i, int j);

    int sub(int i, int j);

    int multi(int i, int j);

    int div(int i, int j);

}

ArithmeticCalculatorImpl.java组件

package com.dx.spring.beans.aop;

import org.springframework.stereotype.Component;

@Component("arithmeticCalculator")

public class ArithmeticCalculatorImpl implements IArithmeticCalculator {

    @Override

    public int add(int i, int j) {

        int result = i + j;

        return result;

    }

    @Override

    public int sub(int i, int j) {

        int result = i - j;

        return result;

    }

    @Override

    public int multi(int i, int j) {

        int result = i * j;

        return result;

    }

    @Override

    public int div(int i, int j) {

        int result = i / j;

        return result;

    }

}

第四步：给Spring组件添加LoggingAspect切面类：

LoggingAspect.java切面类

package com.dx.spring.beans.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

//把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。

@Aspect

@Component

public class LoggingAspect {

    // 声明该方法为一个前置通知：在目标方法开始之前执行

    @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.add(int, int))")

    public void beforeMethod() {

        System.out.println("before ");

    }

}

第五步：添加测试类Client.java&测试

package com.dx.spring.beans.aop;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {

    public static void main(String[] args) {

        // 1:创建Spring的IOC容器；

        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml");

        // 2.从IOC容器中获取Bean的实例

        IArithmeticCalculator arithmeticCalculator = (IArithmeticCalculator) ctx.getBean("arithmeticCalculator");

        // 3.使用Bean

        int result = arithmeticCalculator.add(1, 3);

        System.out.println(result);

    }

}

测试结果：

before
4

Spring AOP合并切入点表达式：

示例：

上边的LoggingAspect.java中的配置仅仅适用于接口IArithm*eticCalculator.java的add方法，如果想通过一个配置适用IArithmeticCalculator.java接口的四个方法，可以使用“*”占位符混匹方式。

第一步：修改LoggingAspect.java接口

package com.dx.spring.beans.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

//把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。

@Aspect

@Component

public class LoggingAspect {

    // 声明该方法为一个前置通知：在目标方法开始之前执行

    @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.*(int, int))")

    public void beforeMethod() {

        System.out.println("before ");

    }

}

第二步：修改Client.java&测试

        // 1:创建Spring的IOC容器；

        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aop.xml");

        // 2.从IOC容器中获取Bean的实例

        IArithmeticCalculator arithmeticCalculator = (IArithmeticCalculator) ctx.getBean("arithmeticCalculator");

        // 3.使用Bean

        int result = arithmeticCalculator.add(1, 3);

        System.out.println(result);

        result = arithmeticCalculator.add(4, 2);

        System.out.println(result);

测试结果：

before
4
before
6

利用方法签名编写AspectJ切入点表达式：

最经典的切入点表达式是根据方法的签名来匹配各种方法：

--- execution(* com.dx.spring.beans.aop.IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator中声明的所有方。第一个"*"代表任意修饰符及任意返回值；第二个"*"代表任意方法；其中".."匹配任意数量的参数。若目标类与接口与该切面在同一个包中，可以省略报名。
--- execution(public * IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator接口的所有公有方法。
--- execution(public double IArithmeticCalculator.*.(..))：匹配IArithmeticCalculator接口中返回double类型数据的方法。
--- execution(public double IArithmeticCalculator.*.(double,..))：匹配IArithmeticCalculator接口中返回double类型数据且第一个参数参数为double类型的（".."匹配任意数量任意类型的参数）方法。
--- execution(public double IArithmeticCalculator.*.(double,..))：匹配IArithmeticCalculator接口中返回double类型数据且有两个类型为double类型的参数的方法。

Spring AOP让通知访问当前连接点的细节：

通知方法支持接收参数，其中就允许接收JoinPoint，通过JointPoint参数对象，可以获取函数名称，和参数。

第一步：修改LoggingAspect.java类：

package com.dx.spring.beans.aop;

import java.util.List;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

//把这个类声明为一个切面：需要把该类放入到IOC容器中、再声明为一个切面。

@Aspect

@Component

public class LoggingAspect {

    // 声明该方法为一个前置通知：在目标方法开始之前执行

    @Before("execution(public int com.dx.spring.beans.aop.IArithmeticCalculator.*(int, int))")

    public void beforeMethod(JoinPoint joinpoint) {

        String methodName = joinpoint.getSignature().getName();

        List<Object> args = Arrays.asList(joinpoint.getArgs());

        System.out.println("before method " + methodName + " with " + args);

    }

}

第二步：测试打印结果

before method add with [1, 3]
4
before method add with [4, 2]
6