Proxy的简单例子

Java反射包中的Proxy类通过创建一个类的代理，让我们轻松地拦截该类实例的方法，甚至可以改变方法的行为。下面是使用Proxy的一个简单例子。

 

主要有4步：

1. 定义接口
2. 实现接口
3. 定义拦截处理器
4. 创建代理对象

 

1.       定义接口

public interface Student {

    public void study();

}

 

2.       实现接口

public class StudentImpl implements Student {

    public void study() {

        System.out.println("I'm studying.");

    }

}

 

3.       定义拦截处理器

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

 

public class StudentInvocationHandler implements InvocationHandler {

       //一般来讲，handler需要负责持有被代理对象的引用

    private Student target;

   

    /** Creates a new instance of MyHandler */

    public StudentInvocationHandler(Student target) {

        this.target = target;

    }

 

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("adding somthing before the method " + method.getName());

        method.invoke(target, args);

        System.out.println("adding somthing after the method " + method.getName());

        return null;

    }

   

}

 

4.       创建代理对象

public class ProxyTest {

    public static void main(String[] args) {

        Student student = (Student) Proxy.newProxyInstance(Student.class.getClassLoader(),

                new Class[] { Student.class },                        //必须为接口

                new StudentInvocationHandler(new StudentImpl()));     //传进被代理对象

        student.study();

    }

}

 

Proxy通过静态方法newProxyInstance为我们创建了一个student的代理类，当调用此类实例的方法时，StudentInvocationHandler进行了拦截，并在调用其study()方法之前与之后分别输出了一行字。

 

而对于用户代码来讲，其只是要求调用student的study()方法，根本不知道此方法已被拦截，甚至不知道此方法已被修改。如果更彻底，通过以下的工厂方法来产生一个student，那么用户就不会怀疑所返回的student竟然不会他所要的:

 

Student student = StudentFactory.getStudent();

 

工厂类：

public class StudentFactory() {

       public static Student getStudent() {

return (Student) Proxy.newProxyInstance(Student.class.getClassLoader(),

                new Class[] { Student.class },

                new StudentInvocationHandler(new StudentImpl()));

       }

}

 

我想到了一个场景：我让我的男秘书帮我去把我相中的姑娘带回来，而实际上，他带给我的却是她的孪生妹妹。以后的事实证明，我爱的姑娘跟他私奔了！

 

 

结论：

因此，通过Proxy，我们可以在运行时动态地改变类的行为。而活用工厂模式，将产生一个类实例的时间从编译时延缓到运行时，将使我们的类更加灵活。