Spring—AOP

1. 前奏：

现在我们有一个UML图如下：

还有两个需求：

• 在程序执行期间追踪正在发生的活动
• 希望计算器只能处理正数的运算

1.1 普通java方法

那么用普通java的实现方法如下：

新建一个Calculator接口：

public interface Calculator {
	
	int add(int i, int j);
	int sub(int i, int j);
	
	int mul(int i, int j);
	int div(int i, int j);
}

再新建一个CalculatorImpl类来调用接口：

public class CalculatorImpl implements Calculator {

	@Override
	public int add(int i, int j) {
		System.out.println("The method add begins with [" + i + "," + j + "]");
		int result = i + j;
		System.out.println("The method add begins with " + result);
		return result;
	}

	@Override
	public int sub(int i, int j) {
		System.out.println("The method sub begins with[" + i + "," + j + "]");
		int result = i - j;
		System.out.println("The method add begins with " + result);
		return result;
	}

	@Override
	public int mul(int i, int j) {
		System.out.println("The method mul begins with[" + i + "," + j + "]");
		int result = i * j;
		System.out.println("The method add begins with " + result);
		return result;
	}

	@Override
	public int div(int i, int j) {
		System.out.println("The method div begins with[" + i + "," + j + "]");
		int result = i / j;
		System.out.println("The method add begins with " + result);
		return result;
	}

}

再在Main中实现：

public class Main {
	
	public static void main(String[] args) {
		Calculator calculator = null;
		calculator = new CalculatorImpl();
		
		int result = calculator.add(1, 2);
		System.out.println("-->" + result);
		
		result = calculator.div(4, 2);
		System.out.println("-->" + result);
	}
}

我们从中可以看到有以下几点问题：

• 代码混乱，越来越多的非业务需求（日志和验证等）加入后，原来的业务方法急剧膨胀，每个方法在处理核心逻辑的同事还必须兼顾其他多个关注点
• 代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求方式变化，必须修改所有模块。

那么为了解决上述问题，就出现了面向切面编程（AOP）。

1.1 使用动态代理解决上述问题

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

我们来看看代码和里面的注释：

首先，Calculator接口还是用上面的那个，CalculatorImpl类修改如下：

public class CalculatorImpl implements Calculator {

	@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 mul(int i, int j) {
		int result = i * j;
		return result;
	}

	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}

}

再新建一个CalculatorLoggingProxy来实现动态代理：

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

public class CalculatorLoggingProxy {
	
	//要代理的对象
	private Calculator target;
	public CalculatorLoggingProxy(Calculator target) {
		this.target = target;
	}
	public Calculator getLoggingProxy() {
		Calculator proxy = null;
		
		//代理对象由哪一个类加载器负责加载
		ClassLoader loader = target.getClass().getClassLoader();
		//代理对象的类型，即其中有哪些方法
		Class [] interfaces = new Class[]{Calculator.class};
		//当调用代理对象其中的方法时，该执行的代码
		InvocationHandler h = new InvocationHandler() {
			/**
			 * proxy:正在返回的那个代理对象，一般情况下，在invoke方法内都不使用该对象
			 * method：正在被调用的方法
			 * args：调用方法时，传入的参数
			 */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				// TODO Auto-generated method stub
				//日志
				System.out.println("The method " + method.getName() + " begins with " + Arrays.asList(args));
				//执行方法
				Object result = method.invoke(target, args);
				System.out.println("The method " + method.getName() + " ends with " + result);
				return result;
			}
		};
		proxy = (Calculator) Proxy.newProxyInstance(loader, interfaces, h);
		return proxy;
	}
}

再在Main中调用方法：

public class Main {
	
	public static void main(String[] args) {
//		Calculator calculator = null;
//		calculator = new CalculatorLoggingImpl();
		
		Calculator target = new CalculatorImpl();
		Calculator proxy = new CalculatorLoggingProxy(target).getLoggingProxy();
		int result = proxy.add(1, 2);
		System.out.println("-->" + result);
		
		result = proxy.div(4, 2);
		System.out.println("-->" + result);
	}
}

我们从上面代码可以看出，使用动态代理之后，修改日志内容只需修改CalculatorLoggingProxy中的invoke中的日志内容，而之前需要逐一修改，这看起来就简洁多了。

2. AOP简介

AOP（面向切面编程）是一种新的方法论，是对传统OOP（面向对象编程）的补充。

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

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

AOP的好处：

• 每个事物逻辑位于一个位置，代码不分散，便于维护和升级
• 业务模块更简洁，只包含核心业务代码

以一个图来说说:

我们正常去写的时候，实际的业务逻辑就是图中上面的内容，我们可以看到业务全部写完会很复杂，量很大且非常冗余，于是我们把验证和日志这些给单独提出来，这里面一个个具体的需求（验证参数，日志）就是我们所说的横切关注点。我们把这些横切关注点一个个拿出来，比如验证参数这个需求单独拿出来就是一个切面，前置日志和后置日志拿出来就是另外一个切面。从上往下看，把关注点拿出来就叫抽取横切关注点。然后我们从切面和业务逻辑（纯净的，只实现具体的单一的方法）往回走的过程就叫做AOP。

3. AOP术语

• 切面（Aspect）：横切关注点被模块化的特殊对象
• 通知（Advise）：切面必须要完成的工作
• 目标（Target）：被通知的对象
• 代理（Proxy）：向目标对象应用通知之后创建的对象
• 连接点（Jointpoint）：程序执行的某个特殊位置，如类某个方法调用前，调用后等。
• 切点（pointcut）每个类都有多个连接点，比如Calculator中的所有方法实际上都是连接点，即连接点是程序类中客观存在的事物。AOP通过切点定位到特定的连接点。类比起来就是：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系。