先来说说代理模式（静态代理）：
其为23种设计模式之一，属于结构型模式，其主要思想是通过一个代理对象来代替真实对象来响应client的调用或请求。静态代理要求代理类与真实类实现一个共同的接口，这样代理对象才能在“型”上代替真实对象。类图如下：
一个通过代理模式来代理并增强真实对象的简单示例：
//定义代理类与真实类的公共接口
public interface Subject {
public void operation();
}
//真实主题，即被代理对象的类
public class RealSubject implements Subject {
public void operation() {
System.out.println("执行业务处理... ...");
}
}
//使用代理对象来代替真实对象，并对真实对象中的处理方法进行增强
public class ProxySubject implements Subject {
private Subject real; //持有真实对象
public ProxySubject(Subject subject){ //constructor，注入真实的被代理的对象
this.real = subject;
}
public void operation() { //对被代理的对象方法进行增强
beforeOperation();
real.operation(); //真实主题中的方法
afterOperation();
}
private void beforeOperation(){ //增强处理
System.out.println("业务预先处理...");
}
private void afterOperation(){ //增强处理
System.out.println("业务善后处理...");
}
}
//测试main函数
public class Main {
public static void main(String[] args) {
Subject real = new RealSubject();
Subject proxy = new ProxySubject(real);
proxy.operation(); //在实际使用时，操作代理对象来代替真实对象
}
}
代理模式应用非常广泛，在各种框架中也能找到其应用。例如在DAO（data access object）模式中：
DAO接口：声明要对DB进行哪些操作
DAOImpl类：实现DAO接口，定义对DB的具体操作
DAOProxy类：代理DAOImpl，并额外进行DB的打开、关闭操作
DAOFactory：创建代理对象的工厂
然而静态代理并不是很灵活，如上例，就只能代理和增强实现了Subject接口的真实类，不能代理任意类型的真实类。
下面来看动态代理：
动态代理即可以在运行时生成代理，其更加灵活，Java提供了Proxy类和InvocationHandler接口两个工具来实现动态代理功能。动态代理的流程如下图：
使用java api中静态方法：Proxy.newProxyInstance()来生成对象：
Proxy.newProxyInstance(classloader, interface, handler) => proxy对象
classloader：类加载器，用于将动态生成的代理类的字节码加载到JVM中，一般就使用被代理类的加载器
interface：被代理类实现的接口，故此，当被代理中存在非接口的方法时，应该就无法被动态增强
handler：InvocationHandler接口的实现类，在handler.invoke()中实现对被代理类接口方法进行增强
动态代理示例：
//真实类的接口型
public interface Subject {
public void operation(); //定义了真实类的操作
}
//真实类：
public class RealSubject implements Subject { //实现接口，完成业务处理
public void operation() {
System.out.println("执行业务处理... ...");
}
}
//增强工具：注意此工具没有实现Subject接口，完全是一个独立的工具方法单元，一般被称为拦截器
public class EnhanceTool {
public void beforeOperation(){ //增强处理
System.out.println("业务预先处理...");
}
public void afterOperation(){ //增强处理
System.out.println("业务善后处理...");
}
}
//***动态代理的核心之处***
public class MyInvocationHandler implements InvocationHandler {
private Object real;
public void setReal(Object real){ //持有被代理的对象
this.real = real;
}
//InvocationHandler接口中的方法，在此方法中对被代理类接口方法增强
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
EnhanceTool tool = new EnhanceTool();
tool.beforeOperation(); //增强工具方法
Object result = method.invoke(real, args); //通过反射调用真实对象中的方法
tool.afterOperation(); //增强工具方法
return result;
}
}
//生成代理对象的工厂：
public class MyProxyFactory {
public static Object getProxy(Object real) throws Exception{
MyInvocationHandler handler = new MyInvocationHandler();
handler.setReal(real);
//Proxy中的静态方法：输入参数(类加载器，被代理类的接口，InvocationHandler的实现类)，返回代理对象
return Proxy.newProxyInstance(real.getClass().getClassLoader(), real.getClass().getInterfaces(), handler);
}
}
//测试main：
public static void main(String[] args) throws Exception {
Subject real = new RealSubject();
Subject proxy = (Subject) MyProxyFactory.getProxy(real);
proxy.operation();
}
通过上面的示例能够看到，动态代理更加的灵活，其增强方法的类完全是一个独立于代理过程的单元，只是单纯的被调用，能随时被替换。且像生成代理对象或调用真实对象方法的具体操作，都由Java API来提供。能够非常好的实现解耦。
接下来是AOP（aspect orient program）,下面的示例使用动态代理来模拟spring中的AOP。根据xml文件中的配置信息来确定动态代理的增强流程和方法。（在时间切面上插入增强方法，来增加整体程序的功能）。
//AOP接口，即动态代理中被代理类实现的接口
public interface AOP {
public void saveMoney();
public void getMoney();
}
//被代理类，实现接口中的方法
public class AOPImpl implements AOP {
public void saveMoney() {
System.out.println("正在存钱...");
}
public void getMoney() {
System.out.println("正在取钱...");
}
}
//动态代理中的handler：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Map;
public class AOPHandler implements InvocationHandler {
private Object obj;
private boolean flag;
public AOPHandler(Object obj){
this.obj = obj;
}
public void setFlag(Map<String, String> config) { //根据解析xml得到的map，设置标志位，进而影响invoke中的执行流程
if (config == null) {
flag = false;
} else {
if (config.containsKey("transaction") && "true".equalsIgnoreCase(config.get("transaction"))) {
flag = true;
} else {
flag = false;
}
}
}
//关键之处，接口方法，当通过代理对象调用真实类中的方法时，实际调用的是下面的invoke方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (flag) { //根据配置信息来决定是否执行
doBefore();
}
Object result = method.invoke(obj, args); //根据反射调用被代理类中的方法
if (flag) { //根据配置信息来决定是否执行
doAfter();
}
return result;
}
private void doBefore() { //增强处理，或叫时间切面长插入的方法
System.out.println("Transaction start...");
}
private void doAfter() {
System.out.println("Transaction commit...");
}
}
//通过DOM（ Document Object Model）来解析xml配置文件
//将xml配置文件中的配置信息，解析为<key, value>对的形式放入map中
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class XMLUtil {
public static Map<String, String> parseXML() throws Exception {
Map<String, String> result = new HashMap<String, String>();
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
InputStream in = XMLUtil.class.getClassLoader().getResourceAsStream("config.xml");
Document document = db.parse(in);
Element root = document.getDocumentElement();
NodeList xmlNodes = root.getChildNodes(); //将整个xml文件转换为NodeList形式
for (int i = 0; i < xmlNodes.getLength(); i++) { //遍历NodeList取得配置信息
Node config = xmlNodes.item(i); //Node封装了配置的节点名与值的信息
if (null != config && config.getNodeType() == Node.ELEMENT_NODE) {
String nodeName = config.getNodeName();
if ("transaction".equals(nodeName)) { //Node.getNodeName()
String textContent = config.getTextContent(); //Node.getTextContext()
result.put("transaction", textContent); //将配置信息放入map中
}
}
}
return result;
}
}
//调用解析方法，将xml文件的解析结果放入map中
import java.util.Map;
public class JVMCache {
private static Map<String, String> config; //储存解析xml得到的配置信息
public synchronized static Map<String, String> getConfig() throws Exception {
if (config == null) {
config = XMLUtil.parseXML();
}
return config;
}
}
/src/config.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<config>
<transaction>true</transaction> //此处为改为fals，则handler.invoke()中的两个增强方法就不会执行
</config>
//测试主函数：
public class Client {
public static void main(String[] args) throws Exception {
AOPImpl impl = new AOPImpl();
AOPHandler handler = new AOPHandler(impl); //在handler中，持有一个被代理对象
handler.setFlag(JVMCache.getConfig()); //将xml配置文件解析出来的map传入handler
//获取代理对象
AOP aop = (AOP) Proxy.newProxyInstance(AOPImpl.class.getClassLoader(), new Class<?>[] {AOP.class}, handler);
aop.saveMoney();
aop.getMoney();
}
}