Mybatis源码-CglibProxyFactory(cglib工厂类)

最新推荐文章于 2024-07-22 17:05:27 发布
最新推荐文章于 2024-07-22 17:05:27 发布
阅读量539 收藏 1
点赞数
分类专栏： mybatis源码 MyBatis源码 文章标签： cglib CglibProxyFactory 延迟加载 loader proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37355951/article/details/98107619
版权

Cglib 代理工厂类，为了实现延迟加载属性

1、源码（Cglib代理工厂类）

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

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

import org.apache.ibatis.executor.loader.AbstractEnhancedDeserializationProxy;
import org.apache.ibatis.executor.loader.AbstractSerialStateHolder;
import org.apache.ibatis.executor.loader.ProxyFactory;
import org.apache.ibatis.executor.loader.ResultLoaderMap;
import org.apache.ibatis.executor.loader.WriteReplaceInterface;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.reflection.ExceptionUtil;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.property.PropertyCopier;
import org.apache.ibatis.reflection.property.PropertyNamer;
import org.apache.ibatis.session.Configuration;

/**
 * cglib代理工厂类，实现延迟加载属性
 * @author Clinton Begin
 */
public class CglibProxyFactory implements ProxyFactory {

  /**
   * finalize方法
   */
  private static final String FINALIZE_METHOD = "finalize";
  /**
   * writeReplace方法
   */
  private static final String WRITE_REPLACE_METHOD = "writeReplace";

  /**
   * 加载Enhancer，这个是Cglib的入口
   */
  public CglibProxyFactory() {
    try {
      Resources.classForName("net.sf.cglib.proxy.Enhancer");
    } catch (Throwable e) {
      throw new IllegalStateException("Cannot enable lazy loading because CGLIB is not available. Add CGLIB to your classpath.", e);
    }
  }

  /**
   * 创建代理对象
   * @param target 目标对象
   * @param lazyLoader 延迟加载器
   * @param configuration 配置类
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造函数类型[]
   * @param constructorArgs  构造函数的值[]
   * @return
   */
  @Override
  public Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
  }

  /**
   * 创建一个反序列化代理
   * @param target 目标
   * @param unloadedProperties
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造函数类型数组
   * @param constructorArgs 构造函数值
   * @return
   */
  public Object createDeserializationProxy(Object target, Map<String, ResultLoaderMap.LoadPair> unloadedProperties, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    return EnhancedDeserializationProxyImpl.createProxy(target, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
  }

  @Override
  public void setProperties(Properties properties) {
      // Not Implemented
  }

  /**
   * 返回代理对象， 这个代理对象在调用任何方法都会调用本类的intercept方法
   * Enhancer 认为这个就是自定义类的工厂，比如这个类需要实现什么接口
   * @param type 目标类型
   * @param callback 结果对象代理实现类，当中有invoke回调方法
   * @param constructorArgTypes 构造函数类型数组
   * @param constructorArgs 构造函数对应字段的值数组
   * @return
   */
  static Object crateProxy(Class<?> type, Callback callback, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
    // enhancer 配置调节代理对象的一些参数
    // 设置回调方法
    // 设置超类
    //判断当传入目标类型是否有writeReplace方法，没有则配置一个有writeReplace方法的接口（序列化写出）
    Enhancer enhancer = new Enhancer();
    enhancer.setCallback(callback);
    enhancer.setSuperclass(type);
    try {
      type.getDeclaredMethod(WRITE_REPLACE_METHOD);
      // ObjectOutputStream will call writeReplace of objects returned by writeReplace
      if (LogHolder.log.isDebugEnabled()) {
        LogHolder.log.debug(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
      }
    } catch (NoSuchMethodException e) {
      //这个enhancer增加一个WriteReplaceInterface接口
      enhancer.setInterfaces(new Class[]{WriteReplaceInterface.class});
    } catch (SecurityException e) {
      // nothing to do here
    }
    //根据构造函数创建一个对象
    //无参构造
    //有参构造
    Object enhanced;
    if (constructorArgTypes.isEmpty()) {
      enhanced = enhancer.create();
    } else {
      Class<?>[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
      Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
      enhanced = enhancer.create(typesArray, valuesArray);
    }
    return enhanced;
  }

  /**
   * 结果对象代理实现类，
   * 它实现方法拦截器的intercept方法
   */
  private static class EnhancedResultObjectProxyImpl implements MethodInterceptor {

    private final Class<?> type;
    private final ResultLoaderMap lazyLoader;
    private final boolean aggressive;
    private final Set<String> lazyLoadTriggerMethods;
    private final ObjectFactory objectFactory;
    private final List<Class<?>> constructorArgTypes;
    private final List<Object> constructorArgs;

    /**
     * 代理对象创建
     * @param type 目标class类型
     * @param lazyLoader 延迟加载器
     * @param configuration 配置信息
     * @param objectFactory 对象工厂
     * @param constructorArgTypes 构造函数类型数组
     * @param constructorArgs 构造函数值数组
     */
    private EnhancedResultObjectProxyImpl(Class<?> type, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      this.type = type;
      this.lazyLoader = lazyLoader;
      this.aggressive = configuration.isAggressiveLazyLoading();
      this.lazyLoadTriggerMethods = configuration.getLazyLoadTriggerMethods();
      this.objectFactory = objectFactory;
      this.constructorArgTypes = constructorArgTypes;
      this.constructorArgs = constructorArgs;
    }

    /**
     * 创建代理对象, 将源对象值赋值给代理对象
     * @param target 目标对象
     * @param lazyLoader 延迟加载器
     * @param configuration 配置对象
     * @param objectFactory 对象工厂
     * @param constructorArgTypes 构造函数类型数组
     * @param constructorArgs 构造函数值数组
     * @return
     */
    public static Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      //获取目标的类型
      //创建一个结果对象代理实现类（它实现cglib的MethodInterface接口，完成回调作用invoke方法）
      final Class<?> type = target.getClass();
      EnhancedResultObjectProxyImpl callback = new EnhancedResultObjectProxyImpl(type, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
      Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
      PropertyCopier.copyBeanProperties(type, target, enhanced);
      return enhanced;
    }

    /**
     * 回调方法
     * @param enhanced 代理对象
     * @param method 方法
     * @param args 方法参数
     * @param methodProxy 代理方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      //获取方法名
      final String methodName = method.getName();
      try {
        // 同步获取延迟加载对象
        // 如果是执行writeReplace方法(序列化写出）
        // 实例化一个目标对象的实例
        synchronized (lazyLoader) {
          if (WRITE_REPLACE_METHOD.equals(methodName)) {
            Object original;
            if (constructorArgTypes.isEmpty()) {
              original = objectFactory.create(type);
            } else {
              original = objectFactory.create(type, constructorArgTypes, constructorArgs);
            }
            // 将enhanced中的属性复制到orignal对象中
            // 如果延迟加载数量>0,
            PropertyCopier.copyBeanProperties(type, enhanced, original);
            if (lazyLoader.size() > 0) {
              return new CglibSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
            } else {
              return original;
            }
          } else {
            //不是writeReplace方法
            // 延迟加载长度大于0， 且不是finalize方法
            // configuration配置延迟加载参数，延迟加载触发的方法包含这个方法
            // 延迟加载所有数据
            if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
              if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                lazyLoader.loadAll();
                // setter方法，直接移除
              } else if (PropertyNamer.isSetter(methodName)) {
                final String property = PropertyNamer.methodToProperty(methodName);
                lazyLoader.remove(property);
                // getter方法， 加载该属性
              } else if (PropertyNamer.isGetter(methodName)) {
                final String property = PropertyNamer.methodToProperty(methodName);
                if (lazyLoader.hasLoader(property)) {
                  lazyLoader.load(property);
                }
              }
            }
          }
        }
        return methodProxy.invokeSuper(enhanced, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
  }

  /**
   * 他继承抽象反序列化代理和实现了方法拦截
   */
  private static class EnhancedDeserializationProxyImpl extends AbstractEnhancedDeserializationProxy implements MethodInterceptor {

    private EnhancedDeserializationProxyImpl(Class<?> type, Map<String, ResultLoaderMap.LoadPair> unloadedProperties, ObjectFactory objectFactory,
            List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      super(type, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
    }

    /**
     * 创建代理对象
     * @param target
     * @param unloadedProperties
     * @param objectFactory
     * @param constructorArgTypes
     * @param constructorArgs
     * @return
     */
    public static Object createProxy(Object target, Map<String, ResultLoaderMap.LoadPair> unloadedProperties, ObjectFactory objectFactory,
            List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      final Class<?> type = target.getClass();
      EnhancedDeserializationProxyImpl callback = new EnhancedDeserializationProxyImpl(type, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
      Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
      PropertyCopier.copyBeanProperties(type, target, enhanced);
      return enhanced;
    }

    @Override
    public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      final Object o = super.invoke(enhanced, method, args);
      return o instanceof AbstractSerialStateHolder ? o : methodProxy.invokeSuper(o, args);
    }

    @Override
    protected AbstractSerialStateHolder newSerialStateHolder(Object userBean, Map<String, ResultLoaderMap.LoadPair> unloadedProperties, ObjectFactory objectFactory,
            List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      return new CglibSerialStateHolder(userBean, unloadedProperties, objectFactory, constructorArgTypes, constructorArgs);
    }
  }

  private static class LogHolder {
    private static final Log log = LogFactory.getLog(CglibProxyFactory.class);
  }

}

1.1、总结

  1. 通过cglib创建代理对象，然后实现延迟加载数据，填充某个属性
  2. 创建代理对象，每次代理调用方法实现，首先会调用MethodInterceptor的intercept方法
往前的
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis源码分析——mybatis-config.xml解析
有米oooooooo
06-23 894
在源码分析过程中，会使用到一些额外的知识，比如 Mybatis中使用的spring接口 Mybatis中使用的设计模式 Mybatis初始化配置文件分为三个阶段，如下 mybatis-config.xml解析 mapper.xml文件解析 mapper跟dao绑定 本篇分析的是第一阶段。 本系列的文章都是基于这个demo来分析的 Mybatis入门，一个简单的demo 首先，看一下初始化入口 ...
mybatis源码-自己写源码注释和demo
09-25
3. 入口类：org.apache.mybatis.demo.Mytest 4. 本次上传，只是一个基本入口，整体能跑通；并且能直接分析mybatis源码 5. mysql数据库： CREATE TABLE USER ( ID INT (20) NOT NULL PRIMARY KEY, NAME VARCHAR (30...
【Mybatis源码分析】10-CglibProxyFactory
smart_an的专栏
05-11 405
我们着重分析一下重要的intercept方法，首先判断如果调用了懒加载对象的writeReplace方法，则返回CglibSerialStateHolder对象，这个对象实现了writeExternal和readExternal用于支持对象的序列化，这不是我们分析的重点。EnhancedResultObjectProxyImpl实现了MethodInterceptor接口，此接口是Cglib拦截目标对象方法的入口，对目标对象方法的调用都会通过此接口的intercept的方法。最后调用目标对象的真实方法。
Mybatis源码-JavassistProxyFactory
往前的娘娘
08-02 1696
学习一下JavassistProxyFactory类，其实它跟CglibProxyFactory几乎是一样的用法 1、JavassistProxyFactory 1.1、源码注释 import java.lang.reflect.Method; import java.util.List; import java.util.Map; import java.util.Properties; i...
mybatis源码-配置文件解析过程
不准动我的小老弟
11-12 330
本文github地址: 点击 本文gitee 地址： 点击 我们在使用Mybatis时，一般都会构建一个SqlSessionFactory 对象出来 String resouce = "mybatis-config.xml"; InputStream is = Resources.getResourcesStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is); 上述代码
花里胡哨系列之Mybatis源码---配置文件解析(二)
崩玉~雅的博客
07-17 290
一.配置文件介绍 官网描述：MyBatis 的配置文件会深深影响 MyBatis 行为的设置和属性信息 配置文件基本结构 二.配置文件解析流程 String resource = "org/mybatis/example/mybatis-config.xml"; //将 配置文件路径转为输入流 InputStream inputStream = Resources.getResourceAsStream(resource); //根据输入流 创建SqlSessionFac...
Mybatis源码剖析
最新发布
weixin_70630201的博客
07-22 320
Mybatis关键源码剖析，超详细版
品读Mybatis源码---（1）解析配置文件
weixin_33850890的博客
02-06 100
为什么80%的码农都做不了架构师？>>> ...
MyBatis 源码分析 - 配置文件解析过程
攻城狮不是猫
04-15 1176
在上一篇文章中，我介绍了 MyBatis 的一些基础知识，用于为本文及后续的源码分析文章进行铺垫。经过前面的铺垫，我觉得是时候后分析一下 MyBatis 源码了。在本篇文章中，我将从 MyBatis 解析配置文件的过程着手进行分析。并会在分析的过程中，向大家介绍一些配置的使用方式和用途。MyBatis 的配置比较丰富，很难在一篇文章中把所有配置的解析过程分析完。所以关于配置文件的解析，这里会分两篇文章进行讲解。本篇文章将会分析诸如settings以及等标签的解析过程。
MyBatis源码分析(2)
u010156553的博客
07-24 173
全局配置文件可配置参数：https://mybatis.org/mybatis-3/zh/configuration.htmlConfiguration对象// 允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。默认为false protected boolean safeRowBoundsEnabled;// 允许在嵌套语句中使用分页（ResultHandler）。
mybatis-plus源码（mybatis-plus-3.5.1.zip）
03-03
此源码包`mybatis-plus-3.5.1.zip`包含了MyBatis-Plus 3.5.1版本的全部源代码，有助于我们深入理解其内部实现机制和工作原理。 MyBatis-Plus的主要功能包括： 1. **CRUD操作**：MyBatis-Plus提供了简化版的CRUD...
MyBatis源码-包含注释
05-10
Mybatis源码，包含注释，注释写的很详细，如果对源码感兴趣的话，可以下载下来研究研究，这个是易哥编写的，而且也有相应的书籍，源码结合书籍更通俗易懂，书籍名称叫《通用源码阅读指导书-MyBatis源码详解》，提供...
mybatis-plus-boot-starter-3.1.0.jar
04-13
mybatis-plus-boot-starter.jar 各个版本下载， SpringBoot 集成 MybatisPlus jar 包下载， Mybatis-Plus（简称MP）是一个基于MyBatis的增强工具库，它简化了与数据库的交互操作并提供了一系列增强功能，使开发者...
mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip
07-20
mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip mybatis-plus最新代码生成器项目源码 ：mybatis-plus-generator.zip ...
Mybatis源码-cursor(游标)
往前的娘娘
07-27 6662
今天学习一下cursor包的下源码，了解mybatis大致游标实现 目录1、Cursor(游标接口类）1.1源码1.2总结2、DefaultCursor(默认游标实现类)2.1、源码2.2、总结 1、Cursor(游标接口类） 1.1源码 /** * Copyright 2009-2019 the original author or authors. * * License...
Mybatis源码-keygen包（Key）
往前的娘娘
07-31 3550
今天主要学习是executor包下一个子包keygen,这个包功能就是自动生成一个key，例如@SelectKey注解设置字段，然后返回，生成key有两种，一种是通过jdbc生成，一种通过执行sql语句获取某个字段值实现生成key 1、Jdbc3KeyGenerator /** * 这个类的功能就是在执行完sql获取 stmt.getGeneratedKeys()生成keys的值，然后通过下...
Mybatis源码-VFS（虚拟文件系统）
往前的娘娘
08-05 2655
VFS 是虚拟文件系统通用API，不需关心不同服务的存储媒介什么，高层的抽象，这个在mybatis是一个抽象类，它有两个实现类一个是默认，一个是JBoss的 1、继承图示 1.1. 子类需要实现只有两个方法： isValid()是否有效 list(URL url, String forPath) 列出某个path对应URL的所有子资源，递归获取 2、VFS源码（注释） /** * Pr...
mybatis-plus-boot-starter和mybatis-plus-generator
03-01
mybatis-plus-generator是MyBatis-Plus框架提供的代码生成器工具，它可以根据数据库表结构自动生成对应的实体类、Mapper接口、Service接口以及Controller类等。使用mybatis-plus-generator可以大大减少手动编写重复...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值