Spring温故知新（六）AOP面向切面编程 <2>

上一章我们讲到了用代理模式来实现自动管理ISpeaker接口里的say()方法，自动的在say()方法前后加上我们get/give礼物的方法。

但是想法比较全面的同学可能也会想到，如果不仅仅只有ISpeaker里的say()方法需要自动送礼物，如果还有这个接口里的其他方法、甚至于是其他接口的方法也需要实现自动送礼物，那又该怎么办呢？
如果还是安装之前的代理模式来做的话那就得每个接口都写一个几乎相同的送礼物的代理类，区别仅在于代理类的接口不同。这样的话耦合性还是太高了，那么还有什么更好的办法吗？

一切皆有可能嘛~ JAVA标准库里面就有一种利用反射的可以实现不依赖接口的动态代理方法，那就是实现java.lang.reflect.InvocationHandler接口。下面我们来看一下怎么样用InvocationHandler接口来实现动态代理：

新的自动送礼物代理器：

package com.iteye.bolide74.action;

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

public class GiftDynamicProxy implements InvocationHandler {
	Object target;

	public Object bind(Object target) {
		//截取了被绑定的、需要被代理的实例对象,交给类成员target
		this.target = target;
		//返回一个新的"代理实例",也就是说外部调用了bind方法以后,获取到的就不是传进来的那个实例对象了，而是被"封装"过的代理实例
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
				target.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		//获取礼物
		getGift();
		//拦截了真正的目标实例对象的方法以后,利用反射来自动调用相同方法
		//this.target就是被代理的实例对象
		//这里的args数组就是方法调用时传递的实参数组
		result = method.invoke(this.target, args);
		//方法调用完毕以后再赠予礼物
		giveGift();
		return result;
	}

	public void getGift() {
		System.out.println("获取了一个礼物");
	}

	public void giveGift() {
		System.out.println("赠予一个礼物");
	}
}

为了体现区别，我们这里再另外新建一个跟ISpeaker无关的接口和实现类：

package com.iteye.bolide74.impl;

public interface IVisit {
	public void sayByVisit();
}

package com.iteye.bolide74.action;

import com.iteye.bolide74.impl.IVisit;

public class People implements IVisit {
	public String name;

	public People(String name) {
		this.name = name;
	}

	@Override
	public void sayByVisit() {
		System.out.println(this.name + "正在访问邻居家,在那坐了一会");
	}
}

下面就是应用代码了：

package com.iteye.bolide74.tester;

import com.iteye.bolide74.action.GiftDynamicProxy;
import com.iteye.bolide74.action.People;
import com.iteye.bolide74.action.Robot;
import com.iteye.bolide74.impl.ISpeaker;
import com.iteye.bolide74.impl.IVisit;

public class GiftDynamicProxyTester {
	public static void main(String[] args) {
		GiftDynamicProxy giftDP = new GiftDynamicProxy();
		ISpeaker wallE = (ISpeaker) giftDP.bind(new Robot("Wall-E"));
		wallE.say("你好");

		System.out.println();
		//调用同一个Gift动态代理实例,无需重写
		IVisit girlFriend = (IVisit) giftDP.bind(new People("GirlFriend"));
		girlFriend.sayByVisit();
	}
}

输出结果：
[quote]获取了一个礼物
到达邻居家,对邻居说:你好,我是Wall-E
赠予一个礼物

获取了一个礼物
GirlFriend正在访问邻居家,在那坐了一会
赠予一个礼物[/quote]

现在我们就能看到，虽然wallE和girlFriend两个实例对象分别属于不同的接口，使用的也是不同的方法，但是都实现了自动get/give礼物的功能。

并且我们还能扩展一下功能，就是根据调用方法名和实参值来筛选什么时候要自动送礼、什么时候不需要送礼，只需要稍微修改一下GiftDynamicProxy礼物动态代理类里的invoke方法：

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		//如果方法名为say、或者方法有形参就带礼物
		if ("say".equals(method.getName()) || null != args) {
			getGift();
			result = method.invoke(this.target, args);
			giveGift();
		} else {
			result = method.invoke(this.target, args);
		}
		return result;
	}

输出结果：
[quote]获取了一个礼物
到达邻居家,对邻居说:你好,我是Wall-E
赠予一个礼物

GirlFriend正在访问邻居家,在那坐了一会[/quote]


以上的InvocationHandler动态代理接口就实现了解耦，这也是Spring AOP的实现原理，也是建立在这个的基础上的。
这时候我们就要利用开始抛出AOP的几个名词概念：Pointcut切入点、Advice通知、Advisor配置器。


1)Pointcut切入点
Pointcut其实是一个集合，它是由一个一个叫做Join Point(连接点)的东西组合而成的。那么什么叫做Join Point呢？
其实前面我们的送礼物示例中的say()方法、sayByVisit()方法等等这些需要被代理的方法就是一个一个Join Point，它们代表了符合被代理条件的方法。(我个人认为Pointcut其实是代表了前面invoke方法里的那些约束条件，就是代表了什么情况下需要自动代理)

2)Advice通知
Advice其实就更好理解了，前面的getGift()和giveGift()方法就是Advice通知，它代表的意思就是需要自动嵌入进Join Point也就是被代理方法里的方法。它有5种类型，分别代表了5种嵌入Advice的约束，比如Join Point的前面、Join Point的后面、Join Point异常的时候等等...

3)Advisor配置器
Advisor就是Pointcut和Advice的配置器，它是将Advice注入Pointcut位置的代码，也就是前面的GiftDynamicProxy类。


AOP的强大优势就在于它能实现代码的低耦合，也就是说写项目的时候，可以让项目的各个功能模块都不用互相依赖，逻辑关系可以独立出来。
以经典的日志管理举例：我们可以先完全不用理会什么日志管理功能，就直接写我们需要的其他模块，比如说数据库操作。
当所有模块都完成以后，我们可以后期再额外的写一个不依赖与其他模块的日志管理模块，然后用AOP来把这个模块跟数据库操作模块挂上钩，这样在数据操作的时候同时也就通过AOP的自动代理功能自动的记录了数据库操作日志。
而当我们又突然不需要日志管理了，那么可以直接把日志管理模块移出，然后改一下AOP模块里的几行代码就可以了，数据库操作模块完全不用改写任何代码。

这也就是为什么AOP叫做面向切面编程而不是面向对象编程，因为用AOP观念来写程序的时候，是先考虑的要先那些切面（可以暂时理解为功能模块来帮助理解），而不是先考虑的这个工程有那些类和对象。


下一章我们就学习一下Spring是怎么通过IoC来实现功能更加强大的AOP的。

我的围脖：[url]http://t.qq.com/bolide74[/url]


下一章：Spring温故知新（六）AOP面向切面编程 <3>[url]http://bolide74.iteye.com/blog/1037396[/url]
上一章：Spring温故知新（六）AOP面向切面编程 <1> [url]http://bolide74.iteye.com/blog/1007086[/url]