Java 动态代理(转载)

JAVA的动态代理
代理模式
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。

首先看一下静态代理：
1、Count.java

 1 package net.battier.dao;  
 2   
 3 /** 
 4  * 定义一个账户接口 
 5  *  
 6  * @author Administrator 
 7  *  
 8  */  
 9 public interface Count {  
10     // 查看账户方法  
11     public void queryCount();  
12   
13     // 修改账户方法  
14     public void updateCount();  
15

2、CountImpl.java

 1     package net.battier.dao.impl;  
 2       
 3     import net.battier.dao.Count;  
 4       
 5     /** 
 6      * 委托类(包含业务逻辑) 
 7      *  
 8      * @author Administrator 
 9      *  
10      */  
11     public class CountImpl implements Count {  
12       
13         @Override  
14         public void queryCount() {  
15             System.out.println("查看账户方法...");  
16       
17         }  
18       
19         @Override  
20         public void updateCount() {  
21             System.out.println("修改账户方法...");  
22       
23         }  
24       
25     }  
26       
27     、CountProxy.java  
28     package net.battier.dao.impl;  
29       
30     import net.battier.dao.Count;  
31       
32     /** 
33      * 这是一个代理类（增强CountImpl实现类） 
34      *  
35      * @author Administrator 
36      *  
37      */  
38     public class CountProxy implements Count {  
39         private CountImpl countImpl;  
40       
41         /** 
42          * 覆盖默认构造器 
43          *  
44          * @param countImpl 
45          */  
46         public CountProxy(CountImpl countImpl) {  
47             this.countImpl = countImpl;  
48         }  
49       
50         @Override  
51         public void queryCount() {  
52             System.out.println("事务处理之前");  
53             // 调用委托类的方法;  
54             countImpl.queryCount();  
55             System.out.println("事务处理之后");  
56         }  
57       
58         @Override  
59         public void updateCount() {  
60             System.out.println("事务处理之前");  
61             // 调用委托类的方法;  
62             countImpl.updateCount();  
63             System.out.println("事务处理之后");  
64       
65         }  
66       
67     }

3、TestCount.java

 1     package net.battier.test;  
 2       
 3     import net.battier.dao.impl.CountImpl;  
 4     import net.battier.dao.impl.CountProxy;  
 5       
 6     /** 
 7      *测试Count类 
 8      *  
 9      * @author Administrator 
10      *  
11      */  
12     public class TestCount {  
13         public static void main(String[] args) {  
14             CountImpl countImpl = new CountImpl();  
15             CountProxy countProxy = new CountProxy(countImpl);  
16             countProxy.updateCount();  
17             countProxy.queryCount();  
18       
19         }  
20     }

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。
再来看一下动态代理：
JDK动态代理中包含一个类和一个接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

Ps:类加载器
在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是类加载器，在Java中主要有一下三种类加载器;
Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的；
Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类;
AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

动态代理
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

动态代理示例:
1、BookFacade.java

1     package net.battier.dao;  
2       
3     public interface BookFacade {  
4         public void addBook();  
5     }

2、BookFacadeImpl.java

 1     package net.battier.dao.impl;  
 2       
 3     import net.battier.dao.BookFacade;  
 4       
 5     public class BookFacadeImpl implements BookFacade {  
 6       
 7         @Override  
 8         public void addBook() {  
 9             System.out.println("增加图书方法。。。");  
10         }  
11       
12     }  
13       
14     、BookFacadeProxy.java  
15       
16     package net.battier.proxy;  
17       
18     import java.lang.reflect.InvocationHandler;  
19     import java.lang.reflect.Method;  
20     import java.lang.reflect.Proxy;  
21       
22     /** 
23      * JDK动态代理代理类 
24      *  
25      * @author student 
26      *  
27      */  
28     public class BookFacadeProxy implements InvocationHandler {  
29         private Object target;  
30         /** 
31          * 绑定委托对象并返回一个代理类 
32          * @param target 
33          * @return 
34          */  
35         public Object bind(Object target) {  
36             this.target = target;  
37             //取得代理对象  
38             return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
39                     target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)  
40         }  
41       
42         @Override  
43         /** 
44          * 调用方法 
45          */  
46         public Object invoke(Object proxy, Method method, Object[] args)  
47                 throws Throwable {  
48             Object result=null;  
49             System.out.println("事物开始");  
50             //执行方法  
51             result=method.invoke(target, args);  
52             System.out.println("事物结束");  
53             return result;  
54         }  
55       
56     }

3、TestProxy.java

 1     package net.battier.test;  
 2       
 3     import net.battier.dao.BookFacade;  
 4     import net.battier.dao.impl.BookFacadeImpl;  
 5     import net.battier.proxy.BookFacadeProxy;  
 6       
 7     public class TestProxy {  
 8       
 9         public static void main(String[] args) {  
10             BookFacadeProxy proxy = new BookFacadeProxy();  
11             BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
12             bookProxy.addBook();  
13         }  
14       
15     }

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
示例
1、BookFacadeCglib.java

1     package net.battier.dao;  
2       
3     public interface BookFacade {  
4         public void addBook();  
5     }

2、BookCadeImpl1.java

 1     package net.battier.dao.impl;  
 2       
 3     /** 
 4      * 这个是没有实现接口的实现类 
 5      *  
 6      * @author student 
 7      *  
 8      */  
 9     public class BookFacadeImpl1 {  
10         public void addBook() {  
11             System.out.println("增加图书的普通方法...");  
12         }  
13     }

3、BookFacadeProxy.java

 1     package net.battier.proxy;  
 2       
 3     import java.lang.reflect.Method;  
 4       
 5     import net.sf.cglib.proxy.Enhancer;  
 6     import net.sf.cglib.proxy.MethodInterceptor;  
 7     import net.sf.cglib.proxy.MethodProxy;  
 8       
 9     /** 
10      * 使用cglib动态代理 
11      *  
12      * @author student 
13      *  
14      */  
15     public class BookFacadeCglib implements MethodInterceptor {  
16         private Object target;  
17       
18         /** 
19          * 创建代理对象 
20          *  
21          * @param target 
22          * @return 
23          */  
24         public Object getInstance(Object target) {  
25             this.target = target;  
26             Enhancer enhancer = new Enhancer();  
27             enhancer.setSuperclass(this.target.getClass());  
28             // 回调方法  
29             enhancer.setCallback(this);  
30             // 创建代理对象  
31             return enhancer.create();  
32         }  
33       
34         @Override  
35         // 回调方法  
36         public Object intercept(Object obj, Method method, Object[] args,  
37                 MethodProxy proxy) throws Throwable {  
38             System.out.println("事物开始");  
39             proxy.invokeSuper(obj, args);  
40             System.out.println("事物结束");  
41             return null;  
42       
43       
44         }  
45       
46     }

4、TestCglib.java

 1     package net.battier.test;  
 2       
 3     import net.battier.dao.impl.BookFacadeImpl1;  
 4     import net.battier.proxy.BookFacadeCglib;  
 5       
 6     public class TestCglib {  
 7           
 8         public static void main(String[] args) {  
 9             BookFacadeCglib cglib=new BookFacadeCglib();  
10             BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
11             bookCglib.addBook();  
12         }  
13     }

动态创建代理类

代理模式：代理模式的作用=为其他对象提供一种代理以控制对这个对象的访问。

代理模式的角色：

抽象角色：声明真实对象和代理对象的共同接口

代理角色：代理角色内部包含有真实对象的引用，从而可以操作真实对象。

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

动态代理：

java.lang.reflect.Proxy	Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类
InvocationHandler	是代理实例的调用处理程序实现的接口，每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

动态Proxy是这样的一种类:

它是在运行生成的类，在生成时你必须提供一组Interface给它，然后该class就宣称它实现了这些interface。你可以把该class的实例当作这些interface中的任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现InvocationHandler接口

步骤：

1、定义抽象角色

public interface Subject {

public void Request();

}

2、定义真实角色

public class RealSubject implements Subject {

@Override

public void Request() {

// TODO Auto-generated method stub

System.out.println("RealSubject");

}

3、定义代理角色

public class DynamicSubject implements InvocationHandler {

private Object sub;

public DynamicSubject(Object obj){

this.sub = obj;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// TODO Auto-generated method stub

System.out.println("Method:"+ method + ",Args:" + args);

method.invoke(sub, args);

return null;

}

4、通过Proxy.newProxyInstance构建代理对象

RealSubject realSub = new RealSubject();

InvocationHandler handler = new DynamicSubject(realSub);

Class<?> classType = handler.getClass();

Subject sub = (Subject)Proxy.newProxyInstance(classType.getClassLoader(),

realSub.getClass().getInterfaces(), handler);

System.out.println(sub.getClass());

5、通过调用代理对象的方法去调用真实角色的方法。

sub.Request();

输出：

class $Proxy0 新建的代理对象，它实现指定的接口

Method:public abstract void DynamicProxy.Subject.Request(),Args:null

RealSubject 调用的真实对象的方法

posted on 2014-05-04 14:41 信平阅读(132) 评论(0) 编辑收藏举报