黑马程序员技术交流社区

标题: 求Proxy练习一枚 [打印本页]
作者: 大梅    时间: 2012-1-26 11:22
标题: 求Proxy练习一枚
本帖最后由 大梅 于 2012-1-27 18:18 编辑

第一次看视频的时候一直疑惑Proxy怎么能实现对了class的代理呢？后来看了篇文章，说由于Java不能支持多继承，故无法实现对class的代理。
对动态代理还是雾里看花，似懂非懂。
哪位仁兄给俺出个练习做做？
作者: 黄秋    时间: 2012-1-27 02:23
　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求在输出前增加标识：“黑马程序员第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 09:24
黄秋 发表于 2012-1-27 02:23
　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求 ...

谢谢，动态代理就留给我解吧~
作者: 大梅    时间: 2012-1-27 12:08
黄秋 发表于 2012-1-27 02:23
　　代理分静态代理和动态代理，先弄清楚简单些的静态代理。
　　比如，你已写了多个计算面积的类，现要求 ...

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

  3. interface GeometryUtils {
  4.         public void Space();
  5. }
复制代码
圆：
  1. package staticproxy;

  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.         }

  11.         public void setR(int r) {
  12.                 this.r = r;
  13.         }

  15.         @Override
  16.         public void Space() {
  17.                 // TODO Auto-generated method stub
  18.                 s = r*r*PI;
  19.                 System.out.println("圆的面积： " + s);
  20.         }

  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;

  3. import org.junit.Test;

  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. }
复制代码
作者: 黄秋    时间: 2012-1-27 12:26
写得好，动态代理我也不是十分了解．感觉反射熟练的话，动态代理则会易明白．动态代理中的代理类是由java.lang.reflect.Proxy类在运行期时根据接口定义，采用Java反射功能动态生成的。个人体会，当看动态代理困难时，先复习下反射．
作者: 大梅    时间: 2012-1-27 13:07
动态代理来做的话如下：
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;

  7. import org.junit.Test;

  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. }

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

反射是挺有意思的。动态代理中的方法调用确实是反射实现的，这个也挺有趣。
作者: 罗全涛    时间: 2012-2-4 00:28
{:soso_e113:}学习了，最近没事，就回头看看大家学习中的问题，感觉还是收获蛮大的。
作者: djx900    时间: 2012-2-28 02:15
太受教了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2