java-中的代理

静态代理:

例子：

接口：

public interface InterfaceBase {

    void proxy();

}

接口实现类：

public class InterfaceBaseReal implements InterfaceBase{

    public void proxy() {

        System.out.println("InterfaceBase......");

    }

}

代理类：

public class InterfaceBaseRealProxy  implements InterfaceBase{

    //调用之前的功能

    private InterfaceBaseReal interfaceBaseReal;

    //通过构造函数进行被代理类的初始化

    public InterfaceBaseRealProxy(InterfaceBaseReal interfaceBaseReal) {

        this.interfaceBaseReal = interfaceBaseReal;

    }

    public void proxy() {

        System.out.println("InterfaceBaseRealProxy....before");

        //调用被代理类的功能，保留原来的不变

        interfaceBaseReal.proxy();

        System.out.println("InterfaceBaseRealProxy....after");

    }

}

动态代理：

动态代理的实现步骤：

    必须有的类：被代理的类

                被代理的类所实现的接口

                实现InvocationHandler接口的类

    流程：实现IncationHandler接口，

            接口要求：通过构造函数传入被代理的类

                      在重写invoke函数里面进行被代理类方法的调用

                      编写增强逻辑

            通过Proxy类的静态方法获得代理类：

                Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class<?>[] { Foo.class },handler);

                                                     获取类加载器，哪个类的都可以， 一般是使用当前类

                                                     被代理类所对应接口的Class对象数组，可以多个

                                                     实现InvocationHandler的类实例

第二个接口实现类:

public class InterfaceBaseReal2 implements InterfaceBase{

    public void proxy() {

        System.out.println("InterfaceBase22222......");

    }

}

处理调用程序:

//实现InvacationHandler接口的类，这个类被成为调用处理程序

public class BaseInvocationHandler implements InvocationHandler {

    //invocationHandler实现类里面必须传入被代理的类(实现被代理接口的类)

    //这里使用对象的顶层基类，主要可以传入不同的对象

    private Object  object;

    //通过构造函数传入

    public BaseInvocationHandler(Object  object) {

        this.object = object;

    }

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

        System.out.println("InterfaceBaseRealProxy....before");

        //调用被代理类的功能，保留原来的不变

        Object re =method.invoke(object,args);

        System.out.println("InterfaceBaseRealProxy....after");

       //返回真是代理对象，也可以通过 return proxy

        return re;

    }

}

获取代理实例：

public class HandlerTest {

    public static void main(String[] args) {

        //被代理类所实现的接口的Class对象

        Class[]inter = {InterfaceBase.class};

        //被代理的类的实例

        InterfaceBase interfaceBase = new InterfaceBaseReal();

        //实现接口InvocationHandler的类的实例（必须传入被代理的类）

        BaseInvocationHandler bh = new BaseInvocationHandler(interfaceBase);

        //通过Proxy的静态函数得到代理实例

        InterfaceBase ibproxy = (InterfaceBase) Proxy.newProxyInstance(InterfaceBase.class.getClassLoader(),inter,bh);

        ibproxy.proxy();

        System.out.println(ibproxy.getClass());

        System.out.println("2222222222222222222222222222222222");

        //第二个被代理的类

        InterfaceBase interfaceBase2 = new InterfaceBaseReal2();

        BaseInvocationHandler bh2 = new BaseInvocationHandler(interfaceBase2);

        InterfaceBase ibproxy2 = (InterfaceBase)Proxy.newProxyInstance(HandlerTest.class.getClassLoader(),inter,bh2);

        ibproxy2.proxy();

    }

}

注意：因为我们的处理调用程序当中设置传入的对象为Object,所以可以传入不同的对象

巴特西

java-中的代理

最新文章

热门文章