神刀安全网

设计模式之代理模式

代理模式:一个委托类,一个代理类,实现相同的接口,通常是在代理类中有一个委托类的对象,代理类并不会真正的执行方法,只是在委托类执行方法之前或之后提供一些服务。比如账户验证,权限查看啥的。


代理模式主要分为静态代理和动态代理。
静态代理:在它在运行的时候,代理类的.class文件就存在了。
动态代理:利用反射,在运行时动态的加载类。


静态代理

// Car.java package com.codeliu.dao;  public interface Car {     // 预订车     public void revCar();     // vip客户可以直接买车     public void buyCar(); }  
// CarImpl.java package com.codeliu.dao.impl;  import com.codeliu.dao.Car; /**  * 委托类  */ public class CarImpl implements Car {     public void revCar() {         System.out.println("我要去预订一辆车咯");     }      public void buyCar() {         System.out.println("我要买车咯");     } } 
/ CarProxy.java package com.codeliu.dao.impl;  import com.codeliu.dao.Car; /**  * 代理类  */ public class CarProxy implement Car {     private CarImpl ci;     public CarProxy(CarImpl ci) {         this.ci = ci;     }      public void revCar() {         System.out.println("该客户是否有足够的钱预订车");         ci.revCar();         System.out.println("该客户预订完成");     }      public void buyCar() {         System.out.println("该客户是否是vip客户");         ci.buyCar();         System.out.println("该客户买车完成");     } } 
package com.codeliu.test;  import com.codeliu.dao.impl.CarImpl; import com.codeliu.dao.impl.CarProxy; public class TestProxy {     public static void main(String[] args) {         CarImpl ci = new CarImpl();         CarProxy cp = new CarProxy(ci);         cp.revCar();         cp.buyCar();     } } 

静态代理是一个代理类只能为一个委托类服务,如果有多个委托类实现了同一个接口,则就要有多个代理类,除了委托类调用的方法不一样,
其他操作都一样,这样势必就会产生很多重复代码。这时就是动态代理类上场的时候了。


动态代理又分为JDK动态代理和Cglib动态代理。


JDK动态代理要使用Java提供的InvocationHandler接口和Proxy类的newProxyInstance方法。

// InvocationHandler接口 public interface InvocationHandler {     public Object invoke(Object proxy, Method method, Object[] args)         throws Throwable; } 

nvocationHandler接口接口中只有一个invoke方法,所有动态代理类都要实现这个接口,并实现invoke方法。
关于该方法的三个参数
proxy表示被代理的对象
method表示被代理对象的方法
args表示方法的参数

// Proxy类的newProxyInstance方法 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 

loader表示委托类的类加载器
interfaces表示委托类实现的接口(这就说明委托类一定要实现了接口才能使用)
h表示InvocationHandler接口的子实例,也就是动态代理类的实例


为了说明动态代理类和静态代理类的不同,我定义了两个委托类

// Car.java package com.codeliu.dao;  public interface Car {     // vip客户可以直接买车     public void buyCar(); }  
// CarImp1.java package com.codeliu.dao.impl; import com.codeliu.dao.Car; /**  * 委托类1  */ public class CarImp1 implements Car {     public void buyCar() {         System.out.println("我是vip1");     } } 
// CarImp2.java package com.codeliu.dao.impl; import com.codeliu.dao.Car; /**  * 委托类2  */ public class CarImp2 implements Car {     public void buyCar() {         System.out.println("我是vip2");     } } 
// CarProxy.java package com.codeliu.dao.impl;  import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;  /**  * 动态代理类  */ public class CarProxy implements InvocationHandler {     private Object target;     /**      * 绑定一个委托对象并获得一个代理类对象      * @param  target [description]      * @return        [description]      */     public Object bind(Object target) {         this.target = target;         // 取得代理对象         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),                                         this);     }      @Override     //这个方法并不是我们自己去调用     public Object invoke(Object proxy, Method method, Object[] args)             throws Throwable {         System.out.println("该客户是否是vip客户");         // 执行委托类的方法         Object result = method.invoke(target,args);         System.out.println("该客户买车完成");         return result;     } } 
package com.codeliu.test;  import com.codeliu.dao.impl.CarImp1; import com.codeliu.dao.impl.CarImp2; import com.codeliu.dao.impl.CarProxy; import com.codeliu.dao.Car; public class TestProxy {     public static void main(String[] args) {         CarProxy cp = new CarProxy();         // 传入一个实现了该接口的实例就行         Car car = (Car)cp.bind(new CarImp1());         // Car car = (Car)cp.bind(new CarImp2());         car.buyCar();     } }  

输出

该客户是否是vip客户 我是vip1 该客户买车完成 

以上就是一个JDK动态代理的例子,但我们可以看到,如果委托类没有实现接口的话,就不能使用newProxyInstance方法,进而不能使用JDK动态代理。这时候,Cglib动态代理上场了。


Cglib是针对类来实现代理的,对指定的目标类生成一个子类,通过方法拦截技术拦截所有父类方法的调用。因为是生成子类,所以就不能用在final修饰的类上。

要使用Cglib,首先的下载jar包。

package com.codeliu.cglibproxy; public class Train {     public void move() {         System.out.println("火车行驶中。。。。");     } } 
package com.codeliu.cglibproxy;  import java.lang.reflect.Method;  import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class CglibProxy implements MethodInterceptor {          private Enhancer enhancer = new Enhancer();          /**      * 获得代理类      * @return      */     public Object getProxy(Class<?> c) {         // 设置创建子类的类         enhancer.setSuperclass(c);         // 回调方法         enhancer.setCallback(this);         // 返回代理对象         return enhancer.create();     }      @Override     /**      * 拦截所有目标方法的调用      * obj 目标类的实例      * m 目标方法的反射对象      * args 方法的参数      * proxy 代理类的实例      */     public Object intercept(Object obj, Method m, Object[] args,             MethodProxy proxy) throws Throwable {         System.out.println("火车启动啦!!");         // 代理类调用父类的方法         Object result = proxy.invokeSuper(obj, args);         System.out.println("火车停止啦!!");         return result;     }  } 
package com.codeliu.cglibproxy; public class Test {     public static void main(String[] args) {         CglibProxy proxy = new CglibProxy();         Train t = (Train)proxy.getProxy(Train.class);         t.move();     } } 

输出

火车启动啦!! 火车行驶中。。。。 火车停止啦!! 


上面的程序我都是用sublime手敲的,不知道有没错误。


吃完饭我又在Eclipse运行了一遍,确保没有错误,要对自己和大家负责,不要传播错误的知识,嘿嘿。

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » 设计模式之代理模式

分享到:更多 ()