关于java:从未有人将代理模式分析得如此透彻

1 从动态代理到动静代理

举个例子,有些人到了适婚年龄,会被父母催婚。而当初在各种压力之下,很多人都抉择晚婚晚育。于是焦急的父母就开始到处为子女相亲,比子女本人还焦急。上面来看代码实现。创立顶层接口IPerson的代码如下。


public interface IPerson {

    void findLove();

}

儿子张三要找对象,实现ZhangSan类。


public class ZhangSan implements IPerson {

    public void findLove() {
        System.out.println("儿子张三提出要求");
    }

}

父亲张老三要帮儿子张三相亲,实现ZhangLaosan类。


public class ZhangLaosan implements IPerson {

    private ZhangSan zhangsan;

    public ZhangLaosan(ZhangSan zhangsan) {
        this.zhangsan = zhangsan;
    }

    public void findLove() {
        System.out.println("张老三开始物色");
        zhangsan.findLove();
        System.out.println("开始来往");
    }

}

来看客户端测试代码。


public class Test {
    public static void main(String[] args) {
        ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
        zhangLaosan.findLove();
    }
}

运行后果如下图所示。

然而,下面的场景有个弊病,就是本人的父亲只会帮本人的子女去物色对象,他人家的孩子是不会管的。但社会上这项业务倒退成了一个产业,呈现了媒婆、婚介所等,还有各种各样的定制套餐。如果还应用动态代理老本就太高了,须要一个更加通用的解决方案,满足任何独身人士找对象的需要。这就由动态代理降级到了动静代理。采纳动静代理基本上只有是人(IPerson)就能够提供相亲服务。动静代理的底层实现个别不必咱们亲自去实现,曾经有很多现成的API。在Java生态中,目前广泛应用的是JDK自带的代理和CGLib提供的类库。首先基于JDK的动静代理反对来降级一下代码。
首先创立媒婆(婚介所)类JdkMeipo。


public class JdkMeipo implements InvocationHandler {
    private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("双方同意,开始来往");
    }

    private void before() {
        System.out.println("我是媒婆,曾经收集到你的需要,开始物色");
    }
}

而后创立一个类ZhaoLiu。


public class ZhaoLiu implements IPerson {

    public void findLove() {
        System.out.println("合乎赵六的要求");
    }

    public void buyInsure() {

    }

}

最初客户端测试代码如下。


    public static void main(String[] args) {
        JdkMeipo jdkMeipo = new JdkMeipo();

        IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
        zhaoliu.findLove();

    }
        

运行后果如下图所示。

2 三层架构中的动态代理

小伙伴们可能会感觉还是不晓得如何将代理模式利用到业务场景中,咱们来看一个理论的业务场景。在分布式业务场景中,通常会对数据库进行分库分表,分库分表之后应用Java操作时就可能须要配置多个数据源,咱们通过设置数据源路由来动静切换数据源。首先创立Order订单类。


public class Order {
    private Object orderInfo;
    private Long createTime;
    private String id;

    public Object getOrderInfo() {
        return orderInfo;
    }
    public void setOrderInfo(Object orderInfo) {
        this.orderInfo = orderInfo;
    }
    public Long getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Long createTime) {
        this.createTime = createTime;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}

创立OrderDao长久层操作类。


public class OrderDao {
    public int insert(Order order){
        System.out.println("OrderDao创立Order胜利!");
        return 1;
    }
}

创立IOrderService接口。


public interface IOrderService {
    int createOrder(Order order);
}

创立OrderService实现类。



public class OrderService implements IOrderService {
    private OrderDao orderDao;

    public OrderService(){
        //如果应用Spring,则应该是主动注入的
        //为了使用方便,咱们在构造方法中间接将orderDao初始化
        orderDao = new OrderDao();
    }

    @Override
    public int createOrder(Order order) {
        System.out.println("OrderService调用orderDao创立订单");
        return orderDao.insert(order);
    }
}

而后应用动态代理,次要实现的性能是:依据订单创立工夫主动按年进行分库。依据开闭准则,咱们批改原来写好的代码逻辑,通过代理对象来实现。创立数据源路由对象,应用ThreadLocal的单例实现DynamicDataSourceEntry类。


//动静切换数据源
public class DynamicDataSourceEntry {
   
    //默认数据源  
    public final static String DEFAULT_SOURCE = null;  
  
    private final static ThreadLocal<String> local = new ThreadLocal<String>();  

    private DynamicDataSourceEntry(){}

    //清空数据源
    public static void clear() {
        local.remove();
    }  
    
    //获取以后正在应用的数据源名字
    public static String get() {
         return local.get();  
    }  

    //还原以后切换的数据源
    public static void restore() {
        local.set(DEFAULT_SOURCE);
    }  
  
    //设置已知名字的数据源 
    public static void set(String source) {
        local.set(source); 
    }

    //依据年份动静设置数据源
    public static void set(int year) {
        local.set("DB_" + year);
    }
}

创立切换数据源的代理类OrderServiceSaticProxy。


public class OrderServiceStaticProxy implements IOrderService {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService){
        this.orderService = orderService;
    }

    public int createOrder(Order order) {
        before();
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("动态代理类主动调配到【DB_" + dbRouter + "】数据源解决数据");
        DynamicDataSourceEntry.set(dbRouter);
        orderService.createOrder(order);
        after();
        return 0;
    }

    private void before(){
        System.out.println("Proxy before method.");
    }

    private void after(){
        System.out.println("Proxy after method.");
    }

}

来看客户端测试代码。


    public static void main(String[] args) {

        try {

            Order order = new Order();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2017/02/01");
            order.setCreateTime(date.getTime());

            IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();;
        }

}

运行后果如下图所示。

由上图可知,后果合乎预期。再来回顾一下类图,看是否与咱们最先画的统一,如下图所示。

动静代理和动态代理的基本思路是统一的,只不过动静代理的性能更弱小,随着业务的扩大,适应性更强。

3 应用动静代理实现无感知切换数据源

在了解了下面的案例后,再来看数据源动静路由业务,帮忙小伙伴们加深对动静代理的印象。创立动静代理的类OrderServiceDynamicProxy,代码如下。


public class OrderServiceDynamicProxy implements InvocationHandler {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
    private Object target;

    public Object getInstance(Object target){
        this.target = target;
        Class<?> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args[0]);
        Object object = method.invoke(target,args);
        after();
        return object;
    }

    private void before(Object target){
        try {
            System.out.println("Proxy before method.");
            Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
            Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
            System.out.println("动态代理类主动调配到【DB_" + dbRouter + "】数据源解决数据");
            DynamicDataSourceEntry.set(dbRouter);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private void after(){
        System.out.println("Proxy after method.");
    }
}

编写客户端测试代码如下。


public static void main(String[] args) {

    try {

        Order order = new Order();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Date date = sdf.parse("2018/02/01");
        order.setCreateTime(date.getTime());

        IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy(). 
        getInstance(new OrderService());
        orderService.createOrder(order);
    }catch (Exception e){
        e.printStackTrace();
    }

}

由下面代码能够看出,仍然可能达到雷同的运行成果。然而,应用动静代理实现之后,不仅能实现Order的数据源动静路由,还能够实现其余任何类的数据源路由。当然,有一个比拟重要的约定,必须实现getCreateTime()办法,因为路由规定是依据工夫来运算的。能够通过接口标准达到束缚的目标,在此不再举例。

4 手写JDK动静代理外围原理

不仅知其然,还得知其所以然。既然JDK动静代理的性能如此弱小,那么它是如何实现的呢?当初来探索一下原理,并模拟JDK动静代理手写一个属于本人的动静代理。
咱们都晓得JDK动静代理采纳字节重组,从新生成对象来代替原始对象,以达到动静代理的目标。JDK动静代理生成对象的步骤如下。
(1)获取被代理对象的援用,并且获取它的所有接口,反射获取。
(2)JDK动静代理类从新生成一个新的类,同时新的类要实现被代理类实现的所有接口。
(3)动静生成Java代码,新加的业务逻辑办法由肯定的逻辑代码调用(在代码中体现)。
(4)编译新生成的Java代码.class文件。
(5)从新加载到JVM中运行。
以上过程就叫作字节码重组。JDK中有一个标准,在ClassPath下只有是$结尾的.class文件,个别都是主动生成的。那么有没有方法看到代替后的对象的“真容”呢?做一个这样的测试,将内存中的对象字节码通过文件流输入到一个新的.class文件,而后应用反编译工具查看源码。


    public static void main(String[] args) {
        try {
            IPerson obj = (IPerson)new JdkMeipo().getInstance(new Zhangsan());
            obj.findLove();

            //通过反编译工具查看源代码
            byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IPerson.class});
            FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
            os.write(bytes);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
        

运行以上代码,能够在E盘找到一个$Proxy0.class文件。应用Jad反编译,失去$Proxy0.jad文件,关上文件看到如下内容。


import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IPerson {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    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 void findLove() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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 buyInsure() throws  {
        try {
            super.h.invoke(this, m4, (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")});
            m3 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
                    .getMethod("findLove", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
                    .getMethod("buyInsure", 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());
        }
    }
}

咱们发现,$Proxy0继承了Proxy类,同时实现了Person接口,而且重写了findLove()等办法。在动态代码块中用反射查找到了指标对象的所有办法,而且保留了所有办法的援用,重写的办法用反射调用指标对象的办法。小伙伴们此时肯定会好奇:这些代码是从哪里来的?其实是JDK主动生成的。当初咱们不依赖JDK,本人来动静生成源码、动静实现编译,而后代替指标对象并执行。
创立GPInvocationHandler接口。


public interface GPInvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

创立GPProxy类。


/**
 * 用来生成源码的工具类
 * Created by Tom.
 */
public class GPProxy {

    public static final String ln = "\r\n";

    public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces, 
    GPInvocationHandler h){
       try {
           //1.动静生成源码.java文件
           String src = generateSrc(interfaces);
           //2.Java文件输入磁盘
           String filePath = GPProxy.class.getResource("").getPath();

           File f = new File(filePath + "$Proxy0.java");
           FileWriter fw = new FileWriter(f);
           fw.write(src);
           fw.flush();
           fw.close();

           //3.把生成的.java文件编译成.class文件
           JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
           StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
           Iterable iterable = manage.getJavaFileObjects(f);

          JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
          task.call();
          manage.close();

           //4.编译生成的.class文件加载到JVM中
          Class proxyClass =  classLoader.findClass("$Proxy0");
          Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
          f.delete();

           //5.返回字节码重组当前的新的代理对象
           return c.newInstance(h);
       }catch (Exception e){
           e.printStackTrace();
       }
        return null;
    }

    private static String generateSrc(Class<?>[] interfaces){
            StringBuffer sb = new StringBuffer();
            sb.append(GPProxy.class.getPackage() + ";" + ln);
            sb.append("import " + interfaces[0].getName() + ";" + ln);
            sb.append("import java.lang.reflect.*;" + ln);
            sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
                sb.append("GPInvocationHandler h;" + ln);
                sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
                    sb.append("this.h = h;");
                sb.append("}" + ln);
                for (Method m : interfaces[0].getMethods()){
                    Class<?>[] params = m.getParameterTypes();

                    StringBuffer paramNames = new StringBuffer();
                    StringBuffer paramValues = new StringBuffer();
                    StringBuffer paramClasses = new StringBuffer();

                    for (int i = 0; i < params.length; i++) {
                        Class clazz = params[i];
                        String type = clazz.getName();
                        String paramName = toLowerFirstCase(clazz.getSimpleName());
                        paramNames.append(type + " " +  paramName);
                        paramValues.append(paramName);
                        paramClasses.append(clazz.getName() + ".class");
                        if(i > 0 && i < params.length-1){
                            paramNames.append(",");
                            paramClasses.append(",");
                            paramValues.append(",");
                        }
                    }

                    sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "("                               + paramNames.toString() + ") {" + ln);
                        sb.append("try{" + ln);
                            sb.append("Method m = " + interfaces[0].getName() + ".class. getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
                            sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
                        sb.append("}catch(Error _ex) { }");
                        sb.append("catch(Throwable e){" + ln);
                        sb.append("throw new UndeclaredThrowableException(e);" + ln);
                        sb.append("}");
                        sb.append(getReturnEmptyCode(m.getReturnType()));
                    sb.append("}");
                }
            sb.append("}" + ln);
            return sb.toString();
    }

    private static Map<Class,Class> mappings = new HashMap<Class, Class>();
    static {
        mappings.put(int.class,Integer.class);
    }

    private static String getReturnEmptyCode(Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "return 0;";
        }else if(returnClass == void.class){
            return "";
        }else {
            return "return null;";
        }
    }

    private static String getCaseCode(String code,Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "((" + mappings.get(returnClass).getName() +  ")" + code + ")." +                             returnClass.getSimpleName() + "Value()";
        }
        return code;
    }

    private static boolean hasReturnValue(Class<?> clazz){
        return clazz != void.class;
    }

    private static String toLowerFirstCase(String src){
        char [] chars = src.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

}

创立GPClassLoader类。


public class GPClassLoader extends ClassLoader {

    private File classPathFile;
    public GPClassLoader(){
        String classPath = GPClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        String className = GPClassLoader.class.getPackage().getName() + "." + name;
        if(classPathFile  != null){
            File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1){
                        out.write(buff,0,len);
                    }
                    return defineClass(className,out.toByteArray(),0,out.size());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

创立GPMeipo类。


public class GpMeipo implements GPInvocationHandler {
    private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("双方同意,开始来往");
    }

    private void before() {
        System.out.println("我是媒婆,曾经收集到你的需要,开始物色");
    }
}

客户端测试代码如下。


    public static void main(String[] args) {
        GpMeipo gpMeipo = new GpMeipo();
        IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();


    }

至此,手写JDK动静代理就实现了。小伙伴们是不是又多了一个面试用的“撒手锏”呢?

5 CGLib动静代理API原理剖析

简略看一下CGLib动静代理的应用,还是以媒婆为例,创立CglibMeipo类。


public class CGlibMeipo implements MethodInterceptor {

    public Object getInstance(Class<?> clazz) throws Exception{
        //相当于JDK中的Proxy类,是实现代理的工具类
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)                              throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }

    private void before(){
        System.out.println("我是媒婆,我要给你找对象,当初曾经确认你的需要");
        System.out.println("开始物色");
    }

    private void after(){
        System.out.println("双方同意,筹备办婚事");
    }
}

创立独身客户类Customer。


public class Customer {

    public void findLove(){
        System.out.println("符合要求");
    }
}

这里有一个小细节,CGLib动静代理的指标对象不须要实现任何接口,它是通过动静继承指标对象实现动静代理的,客户端测试代码如下。


public static void main(String[] args) {

        try {

            //JDK采纳读取接口的信息
            //CGLib笼罩父类办法
            //目标都是生成一个新的类,去实现加强代码逻辑的性能

            //JDK Proxy对于用户而言,必须要有一个接口实现,指标类相对来说简单
            //CGLib能够代理任意一个一般的类,没有任何要求

            //CGLib生成代理的逻辑更简单,调用效率更高,生成一个蕴含了所有逻辑的FastClass,不再需                要反射调用
            //JDK Proxy生成代理的逻辑简略,执行效率绝对要低,每次都要反射动静调用

            //CGLib有一个毛病,CGLib不能代理final的办法

            Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
            System.out.println(obj);
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

CGLib动静代理的实现原理又是怎么的呢?咱们能够在客户端测试代码中加上一句代码,将CGLib动静代理后的.class文件写入磁盘,而后反编译来一探到底,代码如下。


public static void main(String[] args) {
    try {

        //应用CGLib的代理类能够将内存中的.class文件写入本地磁盘
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/");

        Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);
        obj.findLove();

    } catch (Exception e) {
        e.printStackTrace();
    }
}

从新执行代码,咱们会发现在E://cglib_proxy_class目录下多了三个.class文件,如下图所示。

通过调试跟踪发现,Customer$$EnhancerByCGLIB$$3feeb52a.class就是CGLib动静代理生成的代理类,继承了Customer类。


package com.tom.pattern.proxy.dynamicproxy.cglibproxy;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;

public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer
    implements Factory
{

    ...

    final void CGLIB$findLove$0()
    {
        super.findLove();
    }

    public final void findLove()
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 37;
           goto _L3 _L4
_L3:
        break MISSING_BLOCK_LABEL_21;
_L4:
        break MISSING_BLOCK_LABEL_37;
        this;
        CGLIB$findLove$0$Method;
        CGLIB$emptyArgs;
        CGLIB$findLove$0$Proxy;
        intercept();
        return;
        super.findLove();
        return;
    }

    ...
   
}

咱们重写了Customer类的所有办法,通过代理类的源码能够看到,代理类会取得所有从父类继承来的办法,并且会有MethodProxy与之对应,比方Method CGLIB$findLove$0$Method、MethodProxy CGLIB$findLove$0$Proxy等办法在代理类的findLove()办法中都有调用。



//代理办法(methodProxy.invokeSuper()办法会调用)
    final void CGLIB$findLove$0()
    {
        super.findLove();
    }

//被代理办法(methodProxy.invoke()办法会调用
//这就是为什么在拦截器中调用methodProxy.invoke会产生死循环,始终在调用拦截器)
    public final void findLove()
    {
        ...
        //调用拦截器
        intercept();
        return;
        super.findLove();
        return;
    }

调用过程为:代理对象调用this.findLove()办法→调用拦截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理对象findLove()办法。
此时,咱们发现MethodInterceptor拦截器就是由MethodProxy的invokeSuper()办法调用代理办法的,因而,MethodProxy类中的代码十分要害,咱们剖析它具体做了什么。


package net.sf.cglib.proxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import net.sf.cglib.core.AbstractClassGenerator;
import net.sf.cglib.core.CodeGenerationException;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;
import net.sf.cglib.reflect.FastClass.Generator;

public class MethodProxy {
    private Signature sig1;
    private Signature sig2;
    private MethodProxy.CreateInfo createInfo;
    private final Object initLock = new Object();
    private volatile MethodProxy.FastClassInfo fastClassInfo;

    public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
        MethodProxy proxy = new MethodProxy();
        proxy.sig1 = new Signature(name1, desc);
        proxy.sig2 = new Signature(name2, desc);
        proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
        return proxy;
    }

    ...
    
    private static class CreateInfo {
        Class c1;
        Class c2;
        NamingPolicy namingPolicy;
        GeneratorStrategy strategy;
        boolean attemptLoad;

        public CreateInfo(Class c1, Class c2) {
            this.c1 = c1;
            this.c2 = c2;
            AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
            if(fromEnhancer != null) {
                this.namingPolicy = fromEnhancer.getNamingPolicy();
                this.strategy = fromEnhancer.getStrategy();
                this.attemptLoad = fromEnhancer.getAttemptLoad();
            }

        }
    }
     ...
    
}

持续看invokeSuper()办法。


public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        this.init();
        MethodProxy.FastClassInfo fci = this.fastClassInfo;
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException var4) {
        throw var4.getTargetException();
    }
}

...

private static class FastClassInfo {
    FastClass f1;
    FastClass f2;
    int i1;
    int i2;

    private FastClassInfo() {
    }
}

下面代码调用获取代理类对应的FastClass,并执行代理办法。还记得之前生成的三个.class文件吗?Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class就是代理类的FastClass,Customer$$FastClassByCGLIB$$2669574a.class就是被代理类的FastClass。
CGLib动静代理执行代理办法的效率之所以比JDK高,是因为CGlib采纳了FastClass机制,它的原理简略来说就是:为代理类和被代理类各生成一个类,这个类会为代理类或被代理类的办法调配一个index(int类型);这个index被当作一个入参,FastClass能够间接定位要调用的办法并间接进行调用,省去了反射调用,因而调用效率比JDK代理通过反射调用高。上面咱们来反编译一个FastClass。


public int getIndex(Signature signature)
    {
        String s = signature.toString();
        s;
        s.hashCode();
        JVM INSTR lookupswitch 11: default 223
        …
        JVM INSTR pop ;
        return -1;
    }

//局部代码省略

    //依据index间接定位执行办法
    public Object invoke(int i, Object obj, Object aobj[])
        throws InvocationTargetException
    {
        (Customer)obj;
        i;
        JVM INSTR tableswitch 0 10: default 161
           goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
_L2:
        eat();
        return null;
_L3:
        findLove();
        return null;
        …
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

FastClass并不是跟代理类一起生成的,而是在第一次执行MethodProxy的invoke()或invokeSuper()办法时生成的,并被放在了缓存中。


//MethodProxy的invoke()或invokeSuper()办法都调用了init()办法
private void init() {
    if(this.fastClassInfo == null) {
        Object var1 = this.initLock;
        synchronized(this.initLock) {
            if(this.fastClassInfo == null) {
                MethodProxy.CreateInfo ci = this.createInfo;
                MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
//如果在缓存中,则取出;如果没在缓存中,则生成新的FastClass
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                fci.i1 = fci.f1.getIndex(this.sig1);//获取办法的index
                fci.i2 = fci.f2.getIndex(this.sig2);
                this.fastClassInfo = fci;
            }
        }
    }
}

至此,咱们根本分明了CGLib动静代理的原理,对代码细节感兴趣的小伙伴们能够自行深入研究。

6 CGLib和JDK Proxy比照剖析

(1)JDK动静代理实现了被代理对象的接口,CGLib动静代理继承了被代理对象。
(2)JDK动静代理和CGLib动静代理都在运行期生成字节码,JDK动静代理间接写Class字节码,CGLib动静代理应用ASM框架写Class字节码。CGLib动静代理实现更简单,生成代理类比JDK动静代理效率低。
(3)JDK动静代理调用代理办法是通过反射机制调用的,CGLib动静代理是通过FastClass机制间接调用办法的,CGLib动静代理的执行效率更高。

本文为“Tom弹架构”原创,转载请注明出处。技术在于分享,我分享我高兴!
如果本文对您有帮忙,欢送关注和点赞;如果您有任何倡议也可留言评论或私信,您的反对是我保持创作的能源。关注微信公众号『 Tom弹架构 』可获取更多技术干货!

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据