作者：一字马胡
转载标志【2017-11-03】

更新日志

日期	更新内容	备注
2017-11-03	添加转载标志	持续更新

Java静态代理

代理，即是将自己需要做的一些事情交给某个代理机构来做，代理机构应该和我有一样的行为，但是可以做更多的事情，比如火车票代购点，其实就是一个代理，它是为火车站做代理的，它和火车站一样，可以卖票，可以办理退票等手续，而且还可以在代理点做更多的操作，比如每次代理都收取5块钱的手续费。

在java中，代理分为静态代理和动态代理。它们的区别在于静态代理在运行之前就已经存在代理类的字节码文件了（.class文件），而动态代理是在运行时通过反射技术来实现的。为了使得代理对象拥有真实对象的行为，我们应该使真实对象和代理对象实现相同的接口，然后代理对象使用真实对象来操作，其中添加一些增强的细节。下面的代码展示了一个典型的静态代理实现：


/**
 * Created by hujian06 on 2017/10/9.
 *
 * java static proxy demo
 */
public class JavaStaticProxyDemo {

    /**
     * the interface
     */
    interface Interface {
        void doSomething();
    }

    static class InterfaceImpl implements  Interface {

        @Override
        public void doSomething() {
            System.out.println("InterfaceImpl.doSomething()");
        }
    }

    static class InterfaceProxy implements Interface {
        private Interface anInterface;

        public InterfaceProxy(Interface anInterface) {
            this.anInterface = anInterface;
        }

        @Override
        public void doSomething() {
            System.out.println("before-work of doSomething");

            this.anInterface.doSomething();

            System.out.println("after-work of doSomething");
        }
    }

    public static void main(String ... args) {

        Interface real = new InterfaceImpl();
        InterfaceProxy proxy = new InterfaceProxy(real);

        proxy.doSomething();
    }

}

你可以使用静态代理对真实对象进行增强实现，比如火车票代理点可以增加5块钱的手续费。静态代理的优点是简单，实现起来非常方便，需要注意的一点是，静态代理实质上是通过和真实对象实现同样的接口来增强类的功能的，而后文中要说到的Cglib则是通过继承类来实现增强功能的。静态代理的缺点也是比较明显的，因为代理是实现了和委托类一样的接口，所以，如果委托类需要增加一个方法，那么代理类也需要增加一个方法，而且一帮情况下一个代理对象只能有一种类型的委托对象，所以要代理多个类型的对象就需要实现多个代理对象。

Java动态代理

相比于静态代理，java动态代理不需要你实现和委托类一样的接口，所有的代理类只需要实现InvocationHandler接口就可以，这个接口只提供了一个方法：


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

proxy: 这是需要被代理的对象
method：这是对象的方法
args:这是方法的参数列表

如果你想要代理一个类，那么你只需要实现这个接口，然后获取到委托类就可以代理了，下面是一个典型的java动态代理实现：


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by hujian06 on 2017/10/9.
 *
 * java dynamic demo
 */
public class JavaDynamicProxyDemo {

    interface InterfaceA {
        void doSomething();
    }

    static class InterfaceAImpl implements InterfaceA {

        @Override
        public void doSomething() {
            System.out.println("InterfaceImplA.doSomething()");
        }
    }

    static class InterfaceInvocationHandler implements InvocationHandler {
        private Object obj;

        public InterfaceInvocationHandler(Object o) {
            this.obj = o;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return method.invoke(this.obj, args);
        }
    }

    public static void main(String ... args) {

        InterfaceA interfaceA = new InterfaceAImpl();

        InterfaceA a = (InterfaceA) Proxy.newProxyInstance(
                interfaceA.getClass().getClassLoader(),
                interfaceA.getClass().getInterfaces(),
                new InterfaceInvocationHandler(interfaceA));

        a.doSomething();
    }

}

在实现动态代理时，我们使用了Proxy.newProxyInstance这个方法，下面是这个方法：


    public static Object newProxyInstance(ClassLoader loader, 
                Class[] interfaces, InvocationHandler h)

loader：类加载器
interfaces：代理类要实现的接口列表
h: 代理处理handler

动态代理和静态代理一样，只能代理接口，静态代理需要实现和委托类一样的接口，而动态代理需要实现InvocationHandler接口，为了不依赖接口而实现代理，就需要使用Cglib了。

Cglib动态代理

Cglib是一个高性能的代码生成工具，Spring使用Cglib来做AOP，Cglib可以拦截方法的执行，然后对方法进行增强，而且Cglib实现代理不依赖接口，所以不需要向java的静态代理和动态代理那样实现接口。下面简单介绍Cglib可以做的一些事情，对于更为深入的学习，可以阅读源码。

反射

使用Cglib实现反射非常简单，下面是一个简单的示例：


    static class FastClassDemo {

        public void m() {
            System.out.println("FastClass.m()");
        }

        public void m(int a) {
            System.out.println("FastClass.m(int)");
        }

        public void m(String s) {
            System.out.println("FastClass.m(String)");
        }

        public String m(int a, String s) {
            System.out.println("FastClass.m(int, String)");

            return s + "=" + a;
        }

    }
    
        FastClassDemo fastClassDemo = new FastClassDemo();

        FastClass fastClass = FastClass.create(FastClassDemo.class);

        FastMethod fastMethod;

        fastMethod = fastClass.getMethod("m", new Class[]{});
        fastMethod.invoke(fastClassDemo, new Object[]{});

        fastMethod = fastClass.getMethod("m", new Class[]{int.class});
        fastMethod.invoke(fastClassDemo, new Object[]{12});

        fastMethod = fastClass.getMethod("m", new Class[]{String.class});
        fastMethod.invoke(fastClassDemo, new Object[]{"hello cglib"});

        fastMethod = fastClass.getMethod("m", new Class[]{int.class, String.class});
        fastMethod.invoke(fastClassDemo, new Object[]{12, "hello cglib"});

类的增强

如果想增强一个现有类的功能，可以使用Cglib提供的MethodInterceptor，MethodInterceptor可以拦截方法，你可以在执行被拦截的方法之前和之后做一些事情，这不就是AOP嘛？所以Spring使用了Cglib来实现AOP。下面的代码展示了MethodInterceptor的使用：


    static class WeakClass {

        public WeakClass() {

        }

        public void method() {
            System.out.println("I am a weak class's method !");
        }

        public void filterMethod() {
            System.out.println("WeakClass.filterMethod()");
        }

    }

    static class MethodInterceptorImpl implements MethodInterceptor {

        @Override
        public Object intercept(Object o, Method method, Object[] objects,
                                MethodProxy methodProxy) throws Throwable {
            System.out.print("intercept ->" + method + ":");

            methodProxy.invokeSuper(o, objects);

            return null;
        }
    }


        Enhancer enhancer = new Enhancer();

        enhancer.setSuperclass(WeakClass.class);

        WeakClass weakClass;

        enhancer.setCallback(new MethodInterceptorImpl());

        weakClass = (WeakClass) enhancer.create();

        weakClass.method();

你应该使用一个Enhancer对象来增强对象的能力，上面的代码在对象WeakClass的方法执行前会输出一行内容，这也算是对WeakClass类的一种增强吧。因为Cglib是通过继承类来实现的，所以在intercept方法里面执行的是methodProxy.invokeSuper(o, objects)方法，从继承这个角度来说，final类型的方法是无法被增强的。

Cglib还可以对方法进行过滤处理，对选中的方法进行某种类型的intercept。看下面的代码：


    static class CallbackFilterImpl implements CallbackFilter {

        @Override
        public int accept(Method method) {
            if (method.getName().equals("method")) {
                return 1;
            } else {
                return 0;
            }
        }
    }

        Callback[] callbacks = new Callback[]{new MethodInterceptorImpl(), NoOp.INSTANCE};

        enhancer.setCallbacks(callbacks);
        enhancer.setCallbackFilter(new CallbackFilterImpl());

        weakClass = (WeakClass) enhancer.create();

        weakClass.method();
        weakClass.filterMethod();

CallbackFilter的accept方法返回的是一种下标，就是我们设置的callbacks这个数组的下标，比如上面的处理当方法名字为“method”的时候，返回1，否则返回0，说明当方法名字为“method”的时候，会使用callbacks数组里面的下标为1的MethodInterceptor，而其他情况则使用下标为0的MethodInterceptor。

Mixin功能

首先展示一段代码：


    interface IfaceA {
        void doA();
    }

    interface IfaceB {
        void doB();
    }

    static class IfacAImpl implements IfaceA {

        @Override
        public void doA() {
            System.out.println("IfacAImpl.doA()");
        }
    }

    static class IfacBImpl implements IfaceB {

        @Override
        public void doB() {
            System.out.println("IfacBImpl.doB()");
        }
    }


        Class[] classes = new Class[]{IfaceA.class, IfaceB.class};

        Object[] delegates = new Object[]{new IfacAImpl(), new IfacBImpl()};

        Object obj = Mixin.create(classes, delegates);

        IfaceA ifaceA = (IfaceA) obj;
        IfaceB ifaceB = (IfaceB) obj;

        ifaceA.doA();
        ifaceB.doB();

这就是Mixin。可以委托多个类给Cglib，然后在需要的时候获取想要的类就可以了，这更像是一个对象池，Cglib的作用是正确判断申请的对象类型，然后从池子里面返回正确的类型。

Java静态代理和动态代理

更新日志

Java静态代理

Java动态代理

Cglib动态代理

你可能感兴趣的:(Java静态代理和动态代理)