java动态代理例子

 1  先看一个简单点动态代理的例子（没有用到factory）
 2  1  定义接口
 3  package  com.dynamic.simple;
 4 
 5  import  com.dynamic.simple.Subject;
 6 
 7  public   interface  Subject{   
 8       public   void  request();   
 9  }  
10 
11  2  实现真实类
12  package  com.dynamic.simple;
13 
14  public   class  RealSubject  implements  Subject{    
15       public  RealSubject(){}    
16       public   void  request() {
17          System.out.println( " From real subject. " );    
18      }    
19  }   
20 
21  3  定义动态代理
22  package  com.dynamic.simple;
23 
24  import  java.lang.reflect.Method;    
25  import  java.lang.reflect.InvocationHandler;    
26  public   class  DynamicSubject  implements  InvocationHandler {    
27       private  Object sub;    
28      
29       public  DynamicSubject() {    
30      }    
31      
32       public  DynamicSubject(Object obj) {    
33          sub  =  obj;    
34      }    
35      
36       public  Object invoke(Object proxy, Method method, Object[] args)  throws  Throwable {    
37          System.out.println( " before calling  "   +  method);    
38          method.invoke(sub,args);    
39          System.out.println( " after calling  "   +  method);    
40           return   null ;    
41      }    
42  }  
43 
44  4  客户端
45  package  com.dynamic.simple;
46 
47  import  java.lang.reflect.InvocationHandler;    
48  import  java.lang.reflect.Proxy;    
49 
50  public   class  Client{    
51       static   public   void  main(String[] args)  throws  Throwable{    
52          RealSubject rs  =   new  RealSubject();  // 在这里指定被代理类    
53          InvocationHandler ds  =   new  DynamicSubject(rs);  // 初始化代理类    
54          Class cls  =  rs.getClass();    
55          Subject subject  =  (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );    
56          subject.request();    
57      }   
58  }

 

运行客户端结果为：

before calling public abstract void com.dynamic.simple.Subject.request()
From real subject.
after calling public abstract void com.dynamic.simple.Subject.request()

 

 

  1  下面看一个复杂点的动态代理实现（用到了factory）
  2  1  定义接口
  3  package  com.proxy;
  4 
  5  import  com.proxy.SomeClass;
  6  import  com.proxy.SomeClassImpl;
  7 
  8  public   interface  SomeClass {
  9       public   void  someMethod();
 10      
 11       public   void  someOtherMethod( final  String text);
 12  }
 13 
 14  2  定义实现类
 15  package  com.proxy;
 16 
 17 
 18  public   class  SomeClassImpl  implements  SomeClass{
 19       private  String name;
 20      
 21       public  SomeClassImpl( final  String name){
 22           this .name  =  name;
 23      }
 24      
 25       public   void  someMethod(){
 26          System.out.println( this .name);
 27      }
 28      
 29       public   void  someOtherMethod( final  String text){
 30          System.out.println(text);
 31      }
 32  }
 33 
 34  3  定义2个代理SomeClassProxy和SomeClassCountingProxy(静态代理时才需要)
 35  /* SomeClassProxy */
 36  package  com.proxy;
 37 
 38 
 39  public   class  SomeClassProxy  implements  SomeClass{
 40      
 41       private   final  SomeClassImpl impl;
 42      
 43       public  SomeClassProxy(SomeClassImpl impl){
 44           this .impl  =  impl;
 45      }
 46      
 47       public   void  someMethod(){
 48           this .impl.someMethod();
 49      }
 50      
 51       public   void  someOtherMethod( final  String text){
 52           this .impl.someOtherMethod(text);
 53      }
 54  }
 55 
 56  /* SomeClassCountingProxy */
 57  package  com.proxy;
 58 
 59 
 60  public   class  SomeClassCountingProxy  implements  SomeClass{
 61       private   final  SomeClassImpl impl;
 62      
 63       private   int  invocationCount  =   0 ;
 64      
 65       public  SomeClassCountingProxy(SomeClassImpl impl){
 66           this .impl  =  impl;
 67      }
 68      
 69       public   void  someMethod(){
 70           this .invocationCount  ++ ;
 71           this .impl.someMethod();
 72      }
 73      
 74       public   void  someOtherMethod( final  String text){
 75           this .invocationCount  ++ ;
 76           this .impl.someOtherMethod(text);
 77      }
 78 
 79       public   int  getInvocationCount() {
 80           return  invocationCount;
 81      }
 82 
 83       public   void  setInvocationCount( int  invocationCount) {
 84           this .invocationCount  =  invocationCount;
 85      }
 86  }
 87 
 88  4  定义工厂
 89  package  com.proxy;
 90 
 91  import  java.lang.reflect.InvocationHandler;
 92  import  java.lang.reflect.Proxy;
 93 
 94 
 95  public   class  SomeClassFactory {
 96       /* //static proxy
 97      public static final SomeClass getStaticSomeClassProxy(){
 98          SomeClassImpl impl = new SomeClassImpl(System.getProperty("user.name"));
 99          if (false) {//generally when debuging
100              return new SomeClassCountingProxy(impl);
101          } else {
102              return new SomeClassProxy(impl);
103          }
104      }
105       */
106      
107       // dynamic proxy
108       public   static   final  SomeClass getDynamicSomeClassProxy(){
109          SomeClassImpl impl  =   new  SomeClassImpl(System.getProperty( " user.name " ));
110          ClassLoader loader  =  SomeClassImpl. class .getClassLoader();
111          Class[] interfaces  =   new  Class[] {SomeClass. class };
112          InvocationHandler handler  =   new  MethodCountingHandler(impl);
113          SomeClass proxy  =  (SomeClass)Proxy.newProxyInstance(loader, interfaces, handler);
114           return  proxy;
115      }
116  }
117 
118  5  定义InvocationHandler，主要通过这个类实现动态代理功能及其扩展
119  package  com.proxy;
120 
121  import  java.lang.reflect.InvocationTargetException;
122  import  java.lang.reflect.InvocationHandler;
123  import  java.lang.reflect.Method;
124 
125 
126  public   class  MethodCountingHandler  implements  InvocationHandler{
127 
128       private   final  Object impl;
129       private   int  invocationCount  =   0 ;
130      
131       public  MethodCountingHandler( final  Object impl){
132           this .impl  =  impl;
133      }
134      
135       public   int  getInvocationCount(){
136           return  invocationCount;
137      }
138      
139      @Override
140       public  Object invoke(Object proxy, Method method, Object[] args)
141               throws  Throwable {
142           try  {
143               this .invocationCount ++ ;
144              Object result  =  method.invoke(impl, args);
145               return  result;
146          }  catch  ( final  InvocationTargetException e) {
147               throw  e.getTargetException();
148          }
149      }
150  }
151 
152 
153  6  定义客户端
154  package  com.proxy;
155 
156  import  java.lang.reflect.InvocationHandler;
157  import  java.lang.reflect.Proxy;
158 
159 
160  public   class  DemoDynamic {
161 
162       /**
163       *  @param  args
164        */
165       public   static   void  main(String[] args) {
166           /* //no use factory
167          SomeClassImpl real = new SomeClassImpl(System.getProperty("user.name"));
168          InvocationHandler dynamic = new MethodCountingHandler(real);
169          Class clz = real.getClass();
170          SomeClass obj = (SomeClass)Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), dynamic);
171          obj.someMethod();
172          obj.someOtherMethod("test");
173           */
174          
175           // use factory to get a real object
176          SomeClass obj  =  (SomeClass)SomeClassFactory.getDynamicSomeClassProxy();
177          obj.someMethod();
178          obj.someOtherMethod( " test " );
179          
180           // the invocationhandler works as proxy function, extend the function of real object
181          InvocationHandler handler  =  Proxy.getInvocationHandler(obj);
182           if  (handler  instanceof  MethodCountingHandler) {
183              System.out.println(((MethodCountingHandler)handler).getInvocationCount());
184          }
185      }
186  }

运行结果为：

Administrator
test
2

 

参照链接：

http://callan.javaeye.com/blog/161806

http://aronlulu.javaeye.com/blog/613461

http://blog.csdn.net/goodluckforlove/archive/2009/10/13/4663079.aspx