Java动态代理

Java的各种框架之中经常会使用到动态代理，包括AOP编程。

于是小弟下决心好好研究研究。

 

动态代理和静态代理的区别在于，动态代理会通过反射来生成一个静态代理对象。

通过静态代理对象来访问服务器的内部接口。

 

比如说一些日志组建的调用，安全性强的有事物的开启和关闭，数据库连接的开启和关闭。

这些接口如果在服务器上面，开放给客户端进行随意调用，很可能会出现问题。

 

所以代理Proxy在这个时候就起到了隔离的作用。只提供接口进行服务，但是具体除了完成接口的方法，还进行了额外的操作，对客户端进行屏蔽。

 

有个HelloWorld的接口和一个HelloWorldImpl的实现类：

 

package my.pat.proxy;

public class HelloWorldImpl implements HelloWorld {

    @Override
    public void sayHelloWorld() {
        System.out.println("HelloWorld!");
    }

}

 

 

 首先是静态代理类：

public class HelloWorldStaticProxy implements HelloWorld {
    
    private HelloWorldImpl impl ;
    
    public HelloWorldStaticProxy(HelloWorldImpl impl){
        this.impl = impl;
    }
    
    @Override
    public void sayHelloWorld() {
        doBefore();
        
        impl.sayHelloWorld();
        
        doAfter();
    }
    
    public void doBefore(){
        System.out.println("StaticProxy: do before funcion");
    }
    
    public void doAfter(){
        System.out.println("StaticProxy: do after funcion");
    }
}

 

动态代理实现InvocationHandler接口：

public class HelloWorldHandler implements InvocationHandler {
    // 要代理的原始对象
    private Object obj;

    public HelloWorldHandler(Object obj) {
        super();
        this.obj = obj;
    }

    /**
     * 在代理实例上处理方法调用并返回结果
     * 
     * @param proxy
     *            代理类
     * @param method
     *            被代理的方法
     * @param args
     *            该方法的参数数组
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        // 调用之前
        doBefore();
        // 调用原始对象的方法
        result = method.invoke(obj, args);
        // 调用之后
        doAfter();
        return result;
    }

    private void doBefore() {
        System.out.println("DynamicProxy: before method invoke");
    }

    private void doAfter() {
        System.out.println("DynamicProxy: after method invoke");
    }

}

 

测试代理对象：

 

public class HelloWorldTest {

    public static void main(String[] args) {
        HelloWorld helloWorld = new HelloWorldImpl();
        InvocationHandler handler = new HelloWorldHandler(helloWorld);

        // 创建动态代理对象
        HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(helloWorld.getClass().getClassLoader(), 
                helloWorld.getClass().getInterfaces(), 
                handler);
        proxy.sayHelloWorld();
        
        //静态代理：   
        HelloWorld  helloWorld2 = new HelloWorldStaticProxy(new HelloWorldImpl());
        helloWorld2.sayHelloWorld();
        
//   所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，
//   在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。
//   你当然可以把该class的实例当作这些interface中的任何一个来用。
//   当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，
//   在生成它的实例时你必须提供一个handler，由它接管实际的工作。

    }

}