动态代理

public class UserManager implements UserManagerInterface {
    @Override
    public void function(){
        System.out.println("this is a function");
    }


    public UserManager() {
    }
}

package linag.test.dubbo.core.designmodel;

public interface UserManagerInterface {
    void function();
}

静态代理

package linag.test.dubbo.core.designmodel;


public class StaticProxy implements  UserManagerInterface{
    private UserManagerInterface userManagerInterface;
    public StaticProxy(UserManagerInterface userManagerInterface) {
        this.userManagerInterface = userManagerInterface;
    }

    @Override
    public void function() {
        System.out.println("执行之前做一些准备工作");
        userManagerInterface.function();
        System.out.println("执行之后做一些准备工作");
    }

    public static void main(String[] args) {
        StaticProxy staticProxy = new StaticProxy(new UserManager());
        staticProxy.function();
    }
}

装饰代理

package linag.test.dubbo.core.designmodel;

/**
 * @author wb-zgl234479
 * @create 2018/08/28 11:52
 **/

public class DecoratorProxyFilter implements UserManagerInterface{
    UserManagerInterface userManagerInterface;
    public DecoratorProxyFilter(UserManagerInterface userManagerInterface) {
        this.userManagerInterface = userManagerInterface;
    }

    @Override
    public void function() {
        System.out.println(this.toString());
        userManagerInterface.function();
    }

    public static void main(String[] args) {
        DecoratorProxyFilter filter1 = new DecoratorProxyFilter(new UserManager());
        DecoratorProxyFilter filter2 = new DecoratorProxyFilter(filter1);
        filter2.function();
    }
}

jdk代理

原理：http://www.cnblogs.com/zhangxinly/p/6974283.html
1、继承一个InvocationHandler接口，实现增强代码
2、获取接口的方法名、参数、返回值、异常等信息，通过生成字节码来生成代理类，代理类继承需要被代理的接口和Proxy类，Proxy类有一个构造方法

 protected Proxy(InvocationHandler var1) {
        Objects.requireNonNull(var1);
        this.h = var1;
    }

代理类的构造方法需要传入一个InvocationHandler的实现类，赋值到内部属性h,代理类存储接口的Method字段，字节码写入同名的方法。
代理类的调用逻辑是：
Proxy0.function(String arg) > h.invoke(Object proxy, Method method, String arg)(反射) > target.function(String arg)

代理类反编译以后的代码

final class $Proxy0 extends Proxy implements pro {
        //fields    
        private static Method m1;
        private static Method m2;
        private static Method m3;
        private static Method m0;

        public $Proxy0(InvocationHandler var1) throws  {
            super(var1);
        }

        public final boolean equals(Object var1) throws  {
            try {
                return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
            } catch (RuntimeException | Error var3) {
                throw var3;
            } catch (Throwable var4) {
                throw new UndeclaredThrowableException(var4);
            }
        }

        public final String toString() throws  {
            try {
                return (String)super.h.invoke(this, m2, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }

        public final void text() throws  {
            try {
                //实际就是调用代理类的invoke方法 
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }

        public final int hashCode() throws  {
            try {
                return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }

        static {
            try {
                //这里每个方法对象 和类的实际方法绑定
                m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
                m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
                m3 = Class.forName("spring.commons.api.study.CreateModel.pro").getMethod("text", new Class[0]);
                m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

package linag.test.dubbo.core.designmodel;

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



public class JdkProxy implements InvocationHandler {
    private Object proxyedObject;

    public JdkProxy(Object o) {
        proxyedObject = o;
    }


    @Override
    public Object invoke(Object object, Method method, Object[] arguments)
        throws Throwable {
        System.out.println(method.getName()+"执行之前做一些准备工作");
        Object res =  method.invoke(proxyedObject, arguments);
        System.out.println(method.getName()+"执行之后做一些准备的工作");
        return res;
    }

    public static void main(String[] args) {
        UserManagerInterface userManager =  (UserManagerInterface)Proxy.newProxyInstance(
            UserManagerInterface.class.getClassLoader(),
            new Class[] { UserManagerInterface.class },
            new JdkProxy(new UserManager())
        );
        userManager.function();
    }
}

cglib代理

package linag.test.dubbo.core.designmodel;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;


public class GglibProxy  {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        //生成指定类对象的子类,也就是重写类中的业务函数，在重写中加入intercept()函数而已。
        enhancer.setSuperclass(UserManager.class);
        //这里是回调函数，enhancer中肯定有个MethodInterceptor属性。
        //回调函数是在setSuperclass中的那些重写的方法中调用---猜想
        enhancer.setCallback(new CglibMethodInterceptor());
        //创建这个子类对象
        Object proxy = enhancer.create();
        //通过生成子类的方式创建代理类
        UserManager um = (UserManager)proxy;
        um.function();
    }



    public static class CglibMethodInterceptor implements MethodInterceptor{
        @Override
        public Object intercept(Object obj, Method method, Object[] args,
                                MethodProxy proxy) throws Throwable {
            System.out.println(method.getName()+"执行之前做一些准备工作");
            //一不小心写成下面被注释一行代码了。 StackOverflowError
            Object result = proxy.invokeSuper(obj,args);
            System.out.println(method.getName()+"执行之后做一些准备的工作");
            return result;
        }
    }
}

javassist代理

package linag.test.dubbo.core.designmodel;

import javassist.*;
import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyFactory;
import javassist.util.proxy.ProxyObject;

import java.lang.reflect.Method;


public class JavasistProxy{
    public static void main(String[] args) {
        test2();
    }
    private static void test2() {
        try {
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.setSuperclass(UserManager.class);
            Class<ProxyObject> proxyObjectClass = proxyFactory.createClass();
            UserManager proxyObject =(UserManager) proxyObjectClass.newInstance();
            UserManager targer = new UserManager();
            ((ProxyObject) proxyObject).setHandler(new MethodHandler() {
                @Override
                public Object invoke(Object o, Method method, Method method1, Object[] objects) throws Exception {
                    System.out.println("start");
                    method.invoke(targer, objects);
                    System.out.println("end");
                    return null;
                }
            });
            proxyObject.function();



        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
    private static void test1() {
        try {
        // 创建类池，true 表示使用默认路径
        ClassPool classPool = new ClassPool(true);

        String className = UserManager.class.getName();
        // 创建一个类 RayTestJavassistProxy
        CtClass ctClass = classPool.makeClass(className + "JavassistProxy");

        // 添加超类
        // 设置 RayTestJavassistProxy 的父类是 RayTest.
        ctClass.setSuperclass(classPool.get(UserManager.class.getName()));

        // 添加默认构造函数
        ctClass.addConstructor(CtNewConstructor.defaultConstructor(ctClass));

        // 添加属性
        ctClass.addField(CtField.make("public " + className + " real = new " +
            className + "();", ctClass));


        // 添加方法，里面进行动态代理 logic
        ctClass.addMethod(CtNewMethod.make("public void function() { real.function();}",
            ctClass));
        Class<UserManager> testClass = null;

            testClass = ctClass.toClass();

        UserManager userManager = testClass.newInstance();
        userManager.function();
        } catch (CannotCompileException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
    }


}