第一次看视频的时候一直疑惑Proxy怎么能实现对了class的代理呢？后来看了篇文章，说由于Java不能支持多继承，故无法实现对class的代理。
对动态代理还是雾里看花，似懂非懂。
哪位仁兄给俺出个练习做做？

　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求在输出前增加标识：“黑马程序员第6届”，你当然可以去修改输出语句，或在前面增加一输出语句，但如果变成“黑马程序员第7届”呢，又要逐个修改，一般的方法是：写一个类，里面有输出标识的方法；用时调用这个类的方法。
　　静态代理将上面含有输出标识的方法的类，分成三个类：接口类、接口的实现类 、静态代理类。有什么好处先不管，看看例子：（可以先写写，再看代码）
１．接口类

1. public interface TestProxy {      
   
2.     public void print();      
   
3. }
   

复制代码

２．接口的实现类

1. public class TestProxyImpl implements TestProxy{      
   
2.       
   
3.     public void print(){      
   
4.         System.out.println("黑马程序员");      
   
5.     }
   
6. }
   

复制代码

３．静态代理类

1. public class StaticProxy implements TestProxy{      
   
2.       
   
3.     public TestProxy testProxy ;      
   
4.     public StaticProxy(TestProxy testProxy){      
   
5.         this.testProxy = testProxy;      
   
6.     }      
   
7.            
   
8.     public void print(){      
   
9.         testProxy.print();   //   
   
10.         System.out.println("第6届");      
    
11.     }
    
12. }
    

复制代码

４．测试

1. public class TestStaticProxy {
   
2.     public static void main(String[] args){      
   
3.         TestProxy testProxy = new TestProxyImpl();      
   
4.         StaticProxy staticProxy = new StaticProxy(testProxy);      
   
5.         staticProxy.print();      
   
6.     }      
   
7. }

复制代码

动态代理且看下回分解．

黄秋 发表于 2012-1-27 02:23
　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求 ...

谢谢，动态代理就留给我解吧~

黄秋 发表于 2012-1-27 02:23
　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求 ...

按你的意思，重新编题。有个接口提供几何图形的一些操作，其中有一方法是求面积。写一个为这个接口提供服务的代理类。其中有一个实现好的几何图形，名为圆的累实现了求面积的方法。有了代理类以后，今后如果出现更多的图形来，都可以交给这个代理去处理了。
被代理的接口：

1. package staticproxy;
   
2. 
   
3. interface GeometryUtils {
   
4.         public void Space();
   
5. }
   

复制代码

圆：

1. package staticproxy;
   
2. 
   
3. class Cirlce implements GeometryUtils {
   
4.         private int r;
   
5.         private double s ;
   
6.         private final double PI = 3.14;
   
7.         public int getR() {
   
8.                 return r;
   
9.         }
   
10. 
    
11.         public void setR(int r) {
    
12.                 this.r = r;
    
13.         }
    
14. 
    
15.         @Override
    
16.         public void Space() {
    
17.                 // TODO Auto-generated method stub
    
18.                 s = r*r*PI;
    
19.                 System.out.println("圆的面积： " + s);
    
20.         }
    
21. 
    
22. }
    

复制代码

静态代理类：

1. package staticproxy;
   
2. class Advice{
   
3.         public static void before(){
   
4.                 System.out.println("代理类服务开始");
   
5.         }
   
6.         public static void after(){
   
7.                 System.out.println("代理类服务完成");
   
8.         }
   
9. }
   
10. class MyStaticProxy implements GeometryUtils {
    
11.         private GeometryUtils obj = null;
    
12.         public MyStaticProxy(Object obj){
    
13.                 super();
    
14.                 this.obj = (GeometryUtils)obj;
    
15.         }
    
16.         @Override
    
17.         public void Space() {
    
18.                 // TODO Auto-generated method stub
    
19.                 Advice.before();
    
20.                 obj.Space();
    
21.                 Advice.after();
    
22.         }
    
23. }
    

复制代码

测试：

1. package staticproxy;
   
2. 
   
3. import org.junit.Test;
   
4. 
   
5. public class staticProxyTest {
   
6.         @Test
   
7.         public void test01(){
   
8.                 Cirlce c = new Cirlce();
   
9.                 c.setR(2);
   
10.                 MyStaticProxy proxy = new MyStaticProxy(c);
    
11.                 proxy.Space();
    
12.         }
    
13. }
    

复制代码

写得好，动态代理我也不是十分了解．感觉反射熟练的话，动态代理则会易明白．动态代理中的代理类是由java.lang.reflect.Proxy类在运行期时根据接口定义，采用Java反射功能动态生成的。个人体会，当看动态代理困难时，先复习下反射．

动态代理来做的话如下：
Circle类和GeometryUtils接口不变。

1. package staticproxy;
   
2. import java.lang.annotation.Target;
   
3. import java.lang.reflect.InvocationHandler;
   
4. import java.lang.reflect.Method;
   
5. import java.lang.reflect.Proxy;
   
6. 
   
7. import org.junit.Test;
   
8. 
   
9. class Advice{
   
10.         public static void before(Object obj){
    
11.                 System.out.println("代理类服务开始");
    
12.                 if(obj instanceof Circle)((Circle)obj).setR(2);
    
13.         }
    
14.         public static void after(){
    
15.                 System.out.println("代理类服务完成");
    
16.         }
    
17. }
    
18. 
    
19. public class MyDynamicProxyTest {
    
20.         @Test
    
21.         public void test01(){
    
22.                 GeometryUtils proxy = (GeometryUtils) Proxy.newProxyInstance(GeometryUtils.class.getClassLoader(),
    
23.                                 new Class[]{GeometryUtils.class},
    
24.                                 new InvocationHandler() {
    
25.                                         Circle target = new Circle();
    
26.                                         @Override
    
27.                                         public Object invoke(Object proxy, Method method, Object[] args)
    
28.                                                         throws Throwable {
    
29.                                                 // TODO Auto-generated method stub
    
30.                                                 Object reval = null;
    
31.                                                 Advice.before(target);
    
32.                                                 reval = method.invoke(target, null);
    
33.                                                 Advice.after();
    
34.                                                 return reval;
    
35.                                         }
    
36.                                 });
    
37.                 proxy.Space();
    
38.         }
    
39. }
    

复制代码

黄秋 发表于 2012-1-27 12:26
写得好，动态代理我也不是十分了解．感觉反射熟练的话，动态代理则会易明白．动态代理中的代理类是由java.l ...

反射是挺有意思的。动态代理中的方法调用确实是反射实现的，这个也挺有趣。

{:soso_e113:}学习了，最近没事，就回头看看大家学习中的问题，感觉还是收获蛮大的。

太受教了