跟屌丝大哥学习设计模式---代理模式之动态代理

动态代理

java中动态代理机制的引入使得代理模式的思想更加完善与进步，它允许动态的创建代理并支持对动态的对所代理的方法进行调用。Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类： 

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。 

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容： 

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。 

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。 

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。 

 

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。 下面我们通过动态代理来重新实现上面发送信息的例子！

 

在上面的例子基础上，我们先添加一个通过短信来发送消息的处理类：

public class SmsMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println("SMS Message :" + msg+" sent !");
}
}
//动态代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicMessageProxy implements InvocationHandler {
private static int count;
private MessageHandler msgHandler;
public DynamicMessageProxy(MessageHandler handler) {
msgHandler = handler;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("++++++++=============+++++++++");
System.out.println("proxy:" + proxy.getClass());
System.out.println("method:" + method);
System.out.println("++++++++=============+++++++++");
if (args != null args.length == 1 checkMessage((String) args[0])) {
count++;
System.out.println("Message sent:" + count);
return method.invoke(msgHandler, args);
}
return null;
}
private boolean checkMessage(String msg) {
return msg != null msg.length()
}
}
//下面是调用
import java.lang.reflect.Proxy;
public class MainClass {
private static void runProxy(MessageHandler handler) {
handler.sendMessage("message for test");
}
/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
// runProxy(new EmailMessage());
// System.out.println("++++++++++++++++Proxy++++++++++++++++++");
// runProxy(new MessageProxy());
MessageHandler handler = new EmailMessage();
runProxy(handler);
MessageHandler proxy = (MessageHandler) Proxy.newProxyInstance(
MessageHandler.class.getClassLoader(),
new Class[] { MessageHandler.class }, new DynamicMessageProxy(
handler));
runProxy(proxy);
System.out.println("++++++++++++++++++++++++++++++++++");
// 短信方式
handler = new SmsMessage();
runProxy(handler);
proxy = (MessageHandler) Proxy.newProxyInstance(MessageHandler.class
.getClassLoader(), new Class[] { MessageHandler.class },
new DynamicMessageProxy(handler));
runProxy(proxy);
}
}
下面为以上方法的输出：
message for test send!!
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:1
message for test send!!
++++++++++++++++++++++++++++++++++
SMS Message :message for test sent !
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:2
SMS Message :message for test sent !

以上例子中，通过调用Proxy.newProxyInstance方法创建动态代理对象，该方法需要传入一个 类加载器、一组希望代理实现的接口列表、InvocationHandler 接口的一个具体实现。动态代理可以将所有调用重定向到调用处理器，通常我们会向该处理器传递一个时间对象的引用。invoke()方法中传递进来了代理对象，当你需要区分请求来源时这是非常有用的，例如你可以通过判断传入的方法名屏蔽掉某些方法的执行！动态代理机制并不是会很频繁使用的方法，它通常用来解决一些特定情况下的问题，因此不要盲目的为了使用而使用，要根据自己的实际需求来决定！

动态代理的应用十分广泛，在struts2的拦截器中就用到了动态代理机制。还是以买车票为例子，现在用动态代理来实现，其中不懂的接口方法查查Java api就会明白了，在此不多做解释，代码如下(注意PassengerProxy类)：

import java.lang.reflect.*;

public interface Passenger {
public void buyTicket();
}

public class RealPassenger implements Passenger {

@Override
public void buyTicket() {
   // TODO Auto-generated method stub
   System.out.println("购买了车票");
}
}

// 用动态代理实现

//InvocationHandler 是代理实例的调用处理程序 实现的接口。 每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到//它的调用处理程序的 invoke 方法。
public class PassengerProxy implements InvocationHandler {
public Object obj;

// 把obj交给代理类
public Object obj(Object obj) {
   this.obj = obj;
   return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
     .getClass().getInterfaces(), this);
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
   // TODO Auto-generated method stub
   System.out.println("通过代理");
   method.invoke(obj, args);
   return null;
}
}

public class Client {
public static void main(String[] args) {
   PassengerProxy proxy = new PassengerProxy();
   Passenger passenger = (Passenger) proxy.obj(new RealPassenger());
   passenger.buyTicket();
}
}

再来一个更牛的例子

public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {       public void xiangQin() {           System.out.println("张三去相亲，娶个漂亮老婆。");       }   import java.lang.reflect.InvocationHandler;   import java.lang.reflect.Method;    * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。   * @author zhengt   * @time Jun 3, 2095 3:15:48 PM   */   public class ReadyInvocationHandler implements InvocationHandler {       //相亲接口的实现类，也就是张三相亲类       private Object zhangSan = null;       public ReadyInvocationHandler(Object realSubject) {           this.zhangSan = realSubject;       }       public Object invoke(Object proxy, Method m, Object[] args) {           Object result = null;           try {               /**               * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，               * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，               * 也就是ReadyInvocationHandler类的invoke方法。               * 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0，               * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。               */               /**               * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道，               * 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了               */               System.out.println(proxy.getClass().getSimpleName());               System.out.println("张三相亲前，代理人给他打扮了打扮。");               result = m.invoke(zhangSan, args);           } catch (Exception ex) {               System.exit(1);           }           return result;       }   import java.lang.reflect.InvocationHandler;   import java.lang.reflect.Method;   import java.lang.reflect.Proxy;    * 张三来到了婚介所(相亲现场)，开始相亲。   * @author zhengt   * @time Jun 3, 2095 3:17:16 PM   */   public class HunJieSuo {       public static void main(String args[]) {           //先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象           XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();           /**           * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。           * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，           * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，           * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,           * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法           */           /**           * 在java种怎样实现动态代理呢           * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，           * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。           * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，           * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，           * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。           * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。           */           XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(                   zhangSan.getClass().getClassLoader(),                   zhangSan.getClass().getInterfaces(),                   new ReadyInvocationHandler(zhangSan));           proxy.xiangQin();           /**           * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？           * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和           * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口           * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class ? ... interfaces)           * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。           * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。           * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，           * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类           * 方法执行前后做额外工作的类ReadyInvocationHandler。           * 这 段代码 Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))           * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。           * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。           */       }   }  

网上看到一个牛人读过这个动态代理的源代码，现把网址留在这里，希望对网友们有帮助。 
http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。 

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现，如下，DiaoSi接口定义的 业务方法，DiaoSiNanImpl是DiaoSi接口的实现， DiaoSiNanHandler是 InvocationHandler接口实现。代码如下：
业务接口:
        // TODO Auto-generated method stub
        System.out.println("我是撸管王");
    }

InvocationHandler实现，需要在接口方法调用前后加入一部份处理工作，这里仅仅在方法调用前后向后台输出两句字符串，其代码如下： package proxy;

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

public class DiaoSiNanHander implements InvocationHandler{
    //要代理的原始对象 
    
private Object diaosinan; 
/**

* 构造函数。

* @param obj 要代理的原始对象。

*/ 
public DiaoSiNanHander(Object diaosinan) {

    this.diaosinan = diaosinan;
}
    @Override
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        Object result ;
        doBefore(); 
        //调用原始对象的方法 
        result = method.invoke(this.diaosinan ,args); 
        //方法调用之后 
        doafter();
        return result;

        
    }
    private void doafter() {
        // TODO Auto-generated method stub
System.out.println("after method invoke!"); 
    }
    private void doBefore() {
        // TODO Auto-generated method stub
        System.out.println("before method invoke!"); 
    }


}
测试代码： package proxy;

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

public class Test {
public static void main(String[] args) {
DiaoSi ds = new DiaoSiNan();

DiaoSiNanHander handler = new DiaoSiNanHander(ds);

DiaoSi proxy = (DiaoSi) Proxy.newProxyInstance(

ds.getClass().getClassLoader(),

ds.getClass().getInterfaces(),

handler);
/*public static Object newProxyInstance(ClassLoader loader,
        Class ? [] interfaces,
        InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}*/
proxy.luGuan();

        

}
}
Ø 首先获取一个业务接口的实现对象; 

Ø 获取一个InvocationHandler实现，此处是 DiaoSiNanHanderHandler对象; Ø 创建动态代理对象; 

Ø 通过动态代理对象调用luGuan()方法，此时会在原始对象DiaoSiNan.luGuan()方法前后输出两句字符串。 

运行测试类输出如下: 

before method invoke!
我试撸管王
after method invoke!


此处Test类中的方法调用代码比较多，在我们的实际应用中可以通过配置文件来来简化客户端的调用实现。另外也可以通过动态代理来实现简单的AOP。

 

====================================分割线================================

最新内容请见作者的GitHub页：http://qaseven.github.io/

前端仔学学设计模式--单例模式 设计模式知识提取将分为N篇文章，本篇文章是个开篇文，后期会进行其他相关的同步（会就分享，不会就折腾），旨在提升技能，更好地享受敲键盘的快感～
设计模式之代理模式（文末赠书） JDK动态代理的实现原理是动态创建代理类并通过指定类加载器进行加载，在创建代理对象时将InvocationHandler对象作为构造参数传入。当调用代理对象时，会调用 InvocationHandler.invoke() 方法，从而执行代理逻辑，并最终调用真正业务对象的相应方法。
设计模式最佳套路4 —— 愉快地使用模板模式 模板模式（Template Pattern） 又叫模板方法模式，其定义了操作的流程，并将流程中的某些步骤延迟到子类中进行实现，使得子类在不改变操作流程的前提下，即可重新定义该操作的某些特定步骤。例如做菜，操作流程一般为 准备菜 - 放油 - 炒菜 - 调味 - 装盘 ，但可能对于不同的菜要放不同类型的油，不同的菜调味方式也可能不一样。
写代码写了好几年，才发现自己天天都在用设计模式！ 本文作者：黄小斜 转载请务必在文章开头注明出处和作者。 系列文章介绍 本系列文章主要围绕程序员，特别是Java或者后端程序员必须掌握的一些技术和技能，这些文章都是结合我个人的编程学习经历，总结和沉淀下来的方法论。
有这样一个人，看到别人一个个开餐馆赚了好多钱，于是自己也很想在餐饮业这方面大展拳脚，他从别人那里学到了他们的理念，还学习到了他们真正开店的经验。不但如此，他还引进了除了吃饭意外其他的服务，例如说提供了本该是酒吧才有的歌手驻场来提供好的就餐氛围这样的服务。