模拟实现Java动态代理机制

       前一篇文章 我们分析了Java Proxy动态代理类,只是从表面知道他就是打着他人的旗帜，干着自己的勾当！ 但是本质上还没有搞清楚它的非法运营模式，这一章我们就来模拟一下犯罪现场，以及解决前一章遗留的问题。模拟开始先~

一、定义委托高层接口

/**  
 * 模拟Java动态代理机制  
 */  
package com.demo.delegator;   
  
/**  
 * 定义委托高层接口  
 * @author Andy  
 * @since 2012.02.17 15:59 PM  
 * @version 1.0  
 *  
 */  
public final class IDelegator {   
  
    /**  
     * 接口一  
     *  
     */  
    public static interface One{   
        public void sing();   
    }   
       
   /**  
     * 接口二  
     *  
     */  
    public static interface Two{   
        public int write();   
    }   
       
    /**  
     * 接口三  
     *   
     */  
    public static interface Three{   
        public String read();   
    }   
}  

二、定义委托实现类

/**
 * 模拟java动态代理机制
 */
package com.demo.delegator.impl;

import com.demo.delegator.IDelegator;

/**
 * 委托实现类
 * 
 * @author Andy
 * @see	com.demo.delegator.IDelegator.One
 * @see	com.demo.delegator.IDelegator.Two
 * @see	com.demo.delegator.IDelegator.Three
 * @since 2012.02.17 15:59 PM
 * @version 1.0
 */
public class DelegatorImpl implements IDelegator.One , IDelegator.Two , IDelegator.Three {

	@Override
	public String read() {
		this.print();
		return "";
	}

	@Override
	public int write() {
		this.print();
		return 0;
	}

	@Override
	public void sing() {
		this.print();
	}

	private void print(){
		String message = "Invoke " + Thread.currentThread().getStackTrace()[2].getClassName() + "." + Thread.currentThread().getStackTrace()[2].getMethodName();
		System.out.println(message);
	}
}

三、定义代理类

/**
 * 模拟Java动态代理机制
 */
package com.demo.proxy;

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

import com.demo.delegator.IDelegator;

/**
 * 模拟JAVA动态代理类
 * 
 * 
 * JAVA原生动态代理类由ProxyGenerator动态生成实现代理接口的字节码，并注入classloader中。
 * 参见源码：
 * String proxyName = proxyPkg + "$proxy" + num;
 * byte[] proxyClassFile =	ProxyGenerator.generateProxyClass(proxyName, interfaces);
 * proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
 * 
 * 代理机制：
 * 代理类和委托代理类都实现了代理接口，当代理类调用代理接口时，首先会触发调用处理程序。
 * 再由处理程序分发调用委托代理类的接口。从而实现了代理类对委托代理类的隔离。
 * 
 * @author Andy
 * @see	com.demo.delegator.IDelegator.One
 * @see	com.demo.delegator.IDelegator.Two
 * @see	com.demo.delegator.IDelegator.Three
 * @since 2012.02.17 15:59 PM
 * @version 1.0
 */
public final class DynamicProxy implements IDelegator.One , IDelegator.Two , IDelegator.Three {

	// 引用调用处理对象
	private static InvocationHandler handler;
	private static Class<?>[] interfaces = null;
        private static Map<Class<?>, DynamicProxy> cachMap = Collections.synchronizedMap(new HashMap<Class<?> , DynamicProxy>());

        private DynamicProxy(Class<?>[] interfaces , InvocationHandler handler){
		DynamicProxy.handler = handler;
		DynamicProxy.interfaces = interfaces;
	}
	
	public static Object newInstance(Class<?> clazz, Class<?>[] interfaces,InvocationHandler handler){
		DynamicProxy proxy = cachMap.get(clazz);
		if(null == proxy){
			proxy = new DynamicProxy(interfaces , handler);
			cachMap.put(clazz, proxy);
		}
		return proxy;
	}

	@Override
	public String read() {
		return String.valueOf(this.invoke());
	}

	@Override
	public int write() {
		return Integer.valueOf(this.invoke().toString());
	}

	@Override
	public void sing() {
		this.invoke();
	}
	
	
	private Object invoke(){
		Object obj = null;
		try {
			StackTraceElement[] elements = Thread.currentThread().getStackTrace();
			String methodName = elements[2].getMethodName();
			
			for (int i = 0; i < interfaces.length; i++) {
				Class<?> clazz = interfaces[i];
				Method[] methods = clazz.getMethods();
				for (int j = 0; j < methods.length; j++) {
					Method method = methods[j];
					if(methodName.equals(method.getName())){
						Class<?> args[] = method.getParameterTypes();
						obj = handler.invoke(this, method, args);
						break;
					}
				}
			}
			
			return obj;
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
}

四、定义委托调用处理程序

/**
 * 
 */
package com.demo.proxy;

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

/**
 * 委托接口调用处理程序
 * 
 * @author Andy
 * @see	java.lang.reflect.InvocationHandler
 * @since 2012.02.17 15:59 PM
 * @version 1.0
 */
public class AOPHandler implements InvocationHandler {

	private Object instance = null;
	
	private AOPHandler(Class<?> clazz){
		try {
			this.instance = clazz.newInstance();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static Object getProxyInstance(Class<?> clazz , Class<?> interfaces[]){
		return DynamicProxy.newInstance(clazz , interfaces , new AOPHandler(clazz));
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println(method.getName() + " invoke start.");
		Object returnValue = method.invoke(this.instance, args);
		System.out.println(method.getName() + " invoke end.");
		return returnValue;
	}
}

五、模拟代理测试类

/**
 * 模拟Java动态代理机制
 */
package com.demo;

import com.demo.delegator.IDelegator;
import com.demo.delegator.impl.DelegatorImpl;
import com.demo.proxy.AOPHandler;

/**
 * 代理测试类
 * @author Andy
 *
 */
public class ProxyTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 创建调用处理程序
		IDelegator.One proxy = (IDelegator.One)AOPHandler.getProxyInstance(DelegatorImpl.class , DelegatorImpl.class.getInterfaces());
		proxy.sing();
	}
}

       总结：委托类与代理类都实现了委托高层接口，故代理类可以处理委托类的请求。当代理类拦截到接口请求时，首先进行委托调用处理程序（所谓的拦截器），在委托调用处理程序中才真正决定是否分发委托类的请求。代理就这样轻松的实现了委托授权，隔离委托类的直接调用。 分析了代理的机制，上一章ProxyGenerator.generateProxyClass(String s, Class clazz[])也不再是个谜。不难推测它就是Proxy的帮凶（子类），并动态实现委托接口，充当代码生成器的凶手。