黑马程序员技术交流社区

标题: 代理和动态代理 [打印本页]
作者: 文江江    时间: 2014-3-18 11:27
标题: 代理和动态代理
本帖最后由 文江江 于 2014-3-18 15:05 编辑

动态代理和代理的区别？如何创建动态代理？（简要明了哦，有demo有注释哦。。）谢谢了哦。。。
作者: 房建斌    时间: 2014-3-18 13:08
首先来说静态代理：静态代理，是要为每一个需要代理的类生成一个对象，假如有一万个类，那么就要写1万个代理，这是非常恐怖的。下面是静态代理的实现；
代理和目标都要实现相同的接口：
  1. /**
  2. * 代理和目标类都要实现的接口
  3. * @author real
  4. *
  5. */
  6. public interface PersonInterface {

  8.         void getName();
  9. }
复制代码

目标类：
  1. /**
  2. * 需要被代理的类，目标类
  3. * @author real
  4. *
  5. */
  6. public class Person implements PersonInterface{

  8.         @Override
  9.         public void getName() {
  10.                 System.out.println("Person getName 执行");        
  11.         }
  12. }
复制代码
代理类：
  1. public class PersonProxy implements PersonInterface{

  3.         private PersonInterface person;
  4.         
  5.         public PersonProxy(PersonInterface person) {
  6.                 this.person = person;
  7.         }
  8.         
  9.         @Override
  10.         public void getName() {
  11.                 //在执行目标的真实方法之前，可以做其他事情，例如记录日志等。
  12.                 System.out.println("PersonProxy 的getName方法执行");
  13.                 //执行真实的目标类方法
  14.                 person.getName();
  15.         }

  17. }
复制代码
测试类：
  1. public class PersonTest {
  2.         
  3.         public static void main(String[] args) {
  4.                 //真实的Person
  5.                 PersonInterface person = new Person();
  6.                 //Person的代理，需要把Person穿进去
  7.                 PersonInterface personProxy = new PersonProxy(person);
  8.                
  9.                 //直接调用person的方法
  10.                 person.getName();
  11.                 //通过代理调用person的方法
  12.                 personProxy.getName();

  14.         }
  15. }
复制代码
以上代码就是实现静态代理的方法，上面的问题就是如果需要代理的类太多，就得用到了动态代理。在jdk中可以动态的生成代理类。
下面是一个动态代理类：

  2. public class Proxy1 {

  4.         private Object target;
  5.         
  6.         //将需要被代理的类通过对象传入进来
  7.         public Proxy1(Object target) {
  8.                 this.target = target;
  9.         }
  10.         
  11.         /**
  12.          * 通过jdk的Proxy动态的生成target的代理类。
  13.          * @return
  14.          */
  15.         public Object getProxy() {
  16.                
  17.                 /**
  18.                  * Proxy.newProxyInstance()方法需要的三个参数分别问，这个代理类的ClassLoader，
  19.                  * 这个类所有实现的接口，还有一个InvocationHandler,所有的代理方法都要通过里面的invoke方法，
  20.                  * 然后我们可以在invoke方法内部调用target的真实方法，还可以执行其他代码
  21.                  */
  22.                 return Proxy.newProxyInstance(target.getClass().getClassLoader(),
  23.                                 target.getClass().getInterfaces(),
  24.                                 new InvocationHandler() {                        
  25.                         
  26.                                         @Override
  27.                                         public Object invoke(Object proxy, Method method, Object[] args)
  28.                                                         throws Throwable {
  29.                                                 //retVal就是目标对象方法执行后的返回值
  30.                                                 System.out.println("动态代理类。记录日志");
  31.                                                 Object retVal = method.invoke(target, args);
  32.                                                 return retVal;
  33.                                         }
  34.                                 });               
  35.         }
  36. }
复制代码

测试代理类：
  1.                 Proxy1 p1 = new Proxy1(person);
  2.                 PersonInterface personProxy1 = (PersonInterface) p1.getProxy();
  3.                 personProxy1.getName();
复制代码

有了动态代理，就可以代理任何你传入的对象了。不会像静态代理一样限制类型了。



作者: 文江江    时间: 2014-3-18 15:04
房建斌 发表于 2014-3-18 13:08
首先来说静态代理：静态代理，是要为每一个需要代理的类生成一个对象，假如有一万个类，那么就要写1万个代 ...

谢谢啊，很简洁，好！



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