动态代理的幕后

本文主要是介绍动态代理的幕后，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

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

静态代理的例子：

Java代码    
 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.");  
         }  
     }  
 }  
    

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

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

Java代码    
 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;  
     }  
 }  

实验截图：

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

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

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

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

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

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

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

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

这篇关于动态代理的幕后的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！