动态代理的幕后

[size=medium]这篇文章将这样来组织：
1. 简单的例子展示静态代理和动态代理。
2. 两种代理的区别。
3. 动态代理的幕后。

静态代理的例子：[/size]

package com.piedra.proxy;

/**
 *  StaticProxy.java
 */
public class StaticProxy
{
	public static void main(String[] args){		
		MyProxy proxy = new MyProxy(new ConcreteSubject());
		proxy.saySomething("troubler","Hello,Proxy!");
		proxy.saySomething("piedra","Hello,Proxy!");				
	}	
}

abstract class Subject
{
	public abstract void saySomething(String name,String cont);
}

class ConcreteSubject extends Subject
{
	public void saySomething(String name,String cont){
		System.out.println(name + "说：" + cont);
	}
}


class MyProxy
{
	private Subject subject = null;

	public MyProxy(Subject subject){
		this.subject = subject;
	}

	public void saySomething(String name,String cont){
		if(name!=null && !name.equals("troubler")){
			subject.saySomething(name,cont);
		} else {
			System.out.println("Sorry! You are the troulber. You are not allowed to speak.");
		}
	}
}

[size=medium]代码解释：
这里我们让MyProxy来代理Subject对象，那么当我们调用MyProxy的saySomething方法的时候，他会先做一些处理，然后再根据需要调用相应的他所代理的对象的方法。如果需要更多代理模式的内容，你可以google下，会有很多好的资料。

动态代理的简单演示：
我在我的第一篇博文中有浅浅的讲解了动态代理的用法[/size][url]http://yimengzhu.iteye.com/blog/1133359[/url] [size=medium]不过这里我还是简单提下[/size]

package com.piedra.proxy;

import java.lang.reflect.*;

public class DynamicProxy
{
	public static void main(String[] args){
		MyTarget target = new MyTarget();//创建一个目标对象，即待会要被代理的对象。
		MyHandler handler = new MyHandler(target);//待会动态代理对象会将任务分发给这个handler对象的invoke方法处理
		Target proxy = (Target)Proxy.newProxyInstance(target.getClass().getClassLoader(),new Class[]{Target.class},handler);
		proxy.saySomething("piedra","hello,dynamic proxy.");
	}
}

interface Target
{
	public void saySomething(String name,String cont);
}

class MyTarget implements Target
{
	public void saySomething(String name,String cont){
		System.out.println(name + "说: " + cont);
	}
}

class MyHandler implements InvocationHandler
{	
	private Object target;

	public MyHandler(Object target){
		this.target = target;
	}

	public Object invoke(Object proxy,Method method,Object[] args)throws Throwable {
		method.invoke(target,args);
		return null;
	}
}

[size=medium]实验截图：
[/size]
[img]http://dl.iteye.com/upload/attachment/0065/7048/d463d324-cc26-34b9-a755-50ce1dac8cf2.jpg[/img]

[img]http://dl.iteye.com/upload/attachment/0065/7046/071794aa-a3bc-3141-b37e-8082695cbf53.jpg[/img]

[img]http://dl.iteye.com/upload/attachment/0065/7044/d7e99612-1dc4-390a-a44d-6a96e06dcab0.jpg[/img]

[size=medium]
如果你对代理或者动态代理还不是很熟悉，那么你看着可能有点吃力，那么你可能就应该到google上搜索资料好好的学习下了。

接着我将简单说一下我对静态代理和动态代理的区别的看法：
静态代理他要实现跟目标类一样的接口或者抽象类，然后里面需要实现的方法都要你显示的写出来。然而对于动态代理，你却会发现，只需要一个InvocationHandler就可以搞定了。

那么动态代理到底有什么神奇的力量会这么简单？原因是，当我们调用Proxy的newProxyInstance的时候，Proxy内部会帮助我们创建一个代表我们目标对象的代理对象。因为我们传入了我们的目标类说实现的接口，然后我们也传递给他一个ClassLoader，这样JVM就会知道利用那个ClassLoader去装载这个代理的class文件（Proxy帮我们创建的）。
我想这时候你应该已经明白了。真相就是Proxy帮我们创建的代理对象，然后将直接转发给我们的InvocationHandler对象，接着我们就可以在InvocationHandler对象里面的invoke方法里面为所欲为了。

你有没有发现，这样当我们的Target接口里面的方法变了。如果我们还是使用静态代理那么我们的代理对象也要跟着变，但是如果使用动态代理，我们不需要该表代理对象，只需要变化相应的目标对象就可以了。因为在动态代理中代理对象的生成是Proxy自动生成了。（具体使用的技术我还不懂得用）。

尽管这篇文章深度还不够。但是还是谢谢您的阅读。

但愿我的文章的内容对得起您宝贵的时间！

（注：转载请注明出处，爬虫请加个链接再发布，谢谢您的理解！）

GOF设计模式链接：[url]http://download.csdn.net/detail/hhxy_piedra/4184424[/url]

[/size]