java动态代理机制

Java动态代理机制

1.       什么是动态代理机制？

Java的动态代理机制就是Java程序在运行的时候动态生成代理类，代理可以提供另一个类的访问，同时隐藏实际对象的具体事实，代理一般会实现它所表示的实际对象的接口，代理可以访问实际对象，但延迟实际对象的部分功能，延迟实际对象功能是为了处理一些从实际对象中拆分的非实际对象核心的功能模块，这是基于实际对象核心业务功能模块简洁性考虑的。代理隐藏了实际对象，用户并不知道操作的是实际对象还是代理对象。

2.       运用动态代理机制的好处？

在OO编程中，每个对象都有其特定的作用，如果在软件开发中能够很好的遵守OO设计思想，那么程序中的每个类对象都有其特定的作用，如果在有着特定作用的类中参杂太多的其他非核心代码，那么必然会加大该类对其他类的依赖性，这样类与类的耦合度加大，不利于代码的可移植性和重用性。所以运用动态代理来把非核心代码（枝节性代码）和功能性代码分开，降低代码之间的耦合度，符合OO设计的思想，也是开发结构性强，移植性和可重用性高的代码的一个不错选择。

3.       动态代理机制用到哪些AIP？

Java.lang.reflect包中的一个接口和一个类

a.       接口InvocationHandler，该接口是代理类必须实现的接口，它有一个方法：

Object

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

该方法是实际的代理对象调用的方法，里面一般包含有其他对象的非核心代码，和实际对象的功能性代码调用。

b.       类Proxy，该类是一个动态代理类，该类中主要方法如下：

static Object

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler inv)   返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序

loader是类加载器，interfaces是被代理的真实类的接口，inv是真实的代理类

该方法返回指定接口的代理类实例，通过返回的代理类实例可以调用接口中的方法。

 

以下我将通过代码来解释说明具体的操作：

 

先定义一个接口HiBye:

public interface HiBye{

                   public void sayHillo(String name);

                   public void sayGoogbye(String name);

}

 

 

 

 

 

 

 

 

定义一个接口实现类ManHillo：

public ManHillo implements HiBye {

                   public void sayHillo(String name) {

                            System.out.println(name+”你好啊！”);

                   }

 

        public void sayGoogbye(String name) {

                            System.out.println(name+”再见了！”);

                   }

 

}

 

定义一个操作者接口Process：

public interface Process {

                   public void start(Method method);

                   public void end(Method method);

}

定义一个操作者实现类ManProcess：

public ManProcess implements Process{

                   public void start(Method method) {

                            System.out.println(method.getName()+”method start…”);

 

                   }

                   public void end(Method method) {

                            System.out.println(method.getName()+”method end…”);

                   }

 

}

定义一个代理类ManProxy：

         public ManProxy implements InvocationHandler {

                   private Object obj;

                   private Object process;

                   public Object bind(Object obj,Object process) {

                            this.obj=obj;

                            this. process = process;

                            return Proxy.newProxyInstance(this.obj.getClass().getClassLoader(),

this.obj.getClass().getInterfaces(),

this );

                   }

//要处理的真实对象的方法只能在此方法中调用,method代表调用的方法,objs代表方法参数

                   public Object invoke(Object proxy,Method method,Object[] objs) {

                            Object result=null;

                            try{

                              Class clazz=this.process.getClass();    //得到操作者的Class的对象

                                     //得到操作者里的指定方法

                              Method start= clazz.getDeclaredMethod(“start”, new Class[]{Method.class});

                                     //执行方法

                              start.invoke(process,new Object[]{method});

 

                                     //执行真实对象的处理方法

                               result = method.invoke(this.obj, objs);
                                     //得到操作者里的方法

                              Method end=clazz.getDeclaredMethod(“end”,new Class[]{Method.class});

                              end.invoke(process,new Object[]{method});

                            }catch(Exception e) {

                            }

                            return result;

                   }

 

         }

 

定义一个测试类：

public Test {

         public void static main(String[] args) {

                   HiBye hi=( HiBye)new ManProxy().bind(new ManHillo(),new ManProcess());

                   hi.sayHillo(“Hillo liu”);

                   hi.sayGoogbye(“Googbye liu”);

 

         }

}

执行结果是：

sayHillo method start…

hill liu你好啊！

sayHillo method end…

sayGoogbye method start…

bye liu再见了！

sayGoogbye method end…