《Mybatis源码》第10章 MapperProxy代理

最新推荐文章于 2024-02-01 16:04:18 发布
最新推荐文章于 2024-02-01 16:04:18 发布
阅读量524 收藏 3
点赞数
分类专栏： 《Mybatis从0到1》 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44051038/article/details/121524498
版权

调用链

之前已经介绍到了如何创建DefaultSqlSession，下一步就是通过会话创建对应的Mapper接口了，但是按照我们Java的知识，接口是没有办法直接创建的，那么Mybatis是如何处理这个的？ 其实这里是采用了代理

// 我们自己编写的创建获取Mapper的代码
CarMapper mapper = sqlSession.getMapper(CarMapper.class);

DefaultSqlSession 类获取Mapper

@Override
public <T> T getMapper(Class<T> type) {
  // 通过配置文件获取Mapper
  return configuration.<T>getMapper(type, this);
}

Configuration 类关于Mapper的方法，看到底层都是通过一个注册类 mapperRegistry 来存储/获取

  // 注册Mapper
  public void addMappers(String packageName, Class<?> superType) {
    mapperRegistry.addMappers(packageName, superType);
  }

  public void addMappers(String packageName) {
    mapperRegistry.addMappers(packageName);
  }
  
  public <T> void addMapper(Class<T> type) {
    mapperRegistry.addMapper(type);
  }
  // 获取Mapper
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }
  // 包含Mapper
  public boolean hasMapper(Class<?> type) {
    return mapperRegistry.hasMapper(type);
  }

MapperRegistry

MapperRegistry 顾名思义，就是用于注册Mapper接口的，在里面存在一个Map来存储，同时在Configuration存在一个该实例，保证全局唯一

注意这里的key是Class类型，value是MapperProxyFactory类型，注意这里是代理工厂

public class MapperRegistry {
  // 全局配置
  private final Configuration config;
  // 注册的对象 存储到Map
  // 注意这里的value类型是MapperProxyFactory
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();

  public MapperRegistry(Configuration config) {
    this.config = config;
  }
  
  // 获取Mapper
  @SuppressWarnings("unchecked")
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      // 通过Mapper代理工厂创建代理类，返回
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }
  
  // 是否包含
  public <T> boolean hasMapper(Class<T> type) {
    return knownMappers.containsKey(type);
  }
    
  // 添加
  public <T> void addMapper(Class<T> type) {
    // Mapper类型必须是接口
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      // 是否加载完成标记
      boolean loadCompleted = false;
      try {
        // 存储到Map里面
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        // 映射器注解构建器
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        // 解析映射接口类，因为我们的mapper接口可以添加注解 
        // 该方法解析mapper标签下的所有方法和注解，并对解析出来的信息加以封装
        parser.parse();
        loadCompleted = true;
      } finally {
        // 如果完成加载 则移除这个映射类
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

  // 获取已经注册映射接口集合
  public Collection<Class<?>> getMappers() {
    // 返回不可修改的集合
    return Collections.unmodifiableCollection(knownMappers.keySet());
  }

  // 批量添加包下的Mapper
  public void addMappers(String packageName, Class<?> superType) {
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
    for (Class<?> mapperClass : mapperSet) {
      addMapper(mapperClass);
    }
  }

  // 批量添加
  public void addMappers(String packageName) {
    addMappers(packageName, Object.class);
  }
  
}

MapperProxyFactory

在上面的 MapperRegistry类的getMapper()，是通过代理工厂来创建一个代理类返回

public class MapperProxyFactory<T> {
  
  // 接口
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
  
  // 构造方法
  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }
  // getter方法
  public Class<T> getMapperInterface() {
    return mapperInterface;
  }
  // getter方法
  public Map<Method, MapperMethod> getMethodCache() {
    return methodCache;
  }
  // 通过代理类创建MapperProxy代理类
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    // 通过代理类返回指定接口的代理类实例
    // 参数1:类加载器
    // 参数2:接口
    // 参数3:代理对象 该对象需要实现InvocationHandler接口
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }
  
  public T newInstance(SqlSession sqlSession) {
    // 创建一个代理对象
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

MapperProxyFactory 代理工厂在最底层会创建一个代理对象 MapperProxy 返回，所以表面上看着是一个接口，但是通过Debug可以看到，就是代理对象，那我们调用接口里面的方法，其实就是调用代理对象中的方法

// Proxy代理类
// 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
public static Object newProxyInstance(ClassLoader loader,
                                      类<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException

MapperProxy

MapperProxy为代理对象类，该类实现了InvocationHandler接口，Mapper接口调用的方法都会被代理到invoke()

public class MapperProxy<T> implements InvocationHandler, Serializable {
  
  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  // 接口
  private final Class<T> mapperInterface;
  // 方法缓存
  private final Map<Method, MapperMethod> methodCache;
    
  // 构造方法
  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }
  
  /**
   * 代理方法回调
   * @param proxy 代理后的实例对象
   * @param method 对象被调用方法
   * @param args 调用时的参数
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      // 如果声明的类型是Object类型
      if (Object.class.equals(method.getDeclaringClass())) {
        // 直接执行
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {// 判断是否是 default 方法
        // 执行default方法
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    // 接口生成的方法转换成MapperMethod
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // 执行SQL 获取结果 处理后返回
    return mapperMethod.execute(sqlSession, args);
  }
  
  // 获取MapperMethod 没有则创建一个 并且存入
  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }
  
  // 执行默认方法
  @UsesJava7//该注解可以看到在JDK7的时候使用
  private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
      throws Throwable {
    final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
        .getDeclaredConstructor(Class.class, int.class);
    if (!constructor.isAccessible()) {
      constructor.setAccessible(true);
    }
    final Class<?> declaringClass = method.getDeclaringClass();
    return constructor
        .newInstance(declaringClass,
            MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
                | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
        .unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
  }

  // 因为JDK1.8以后接口支持默认方法，也就是被default修饰的方法 此方法是判断
  private boolean isDefaultMethod(Method method) {
    return ((method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC)
        && method.getDeclaringClass().isInterface();
  }
}

MapperMethod

上面的invoke()，会把方法转移到MapperMethod类，这个类就相当于是一个中间类，该类主要做几件事

  1. 处理参数，将java参数转换成sql参数，主要就是就是在里面另外添加 param0，param1，…
  2. 通过SQL的类型以及返回结果的类型，调用SqlSession里面对应的增/删/改/查 方法
  3. 处理返回结果，转换成对应的类型
public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    // 创建一个静态内部类 解析这个接口
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }
  // 执行方法
  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    // 判断SQL类型 通过switch-case判断
    // 1.转换参数  这个方法需要看一下，可以通过param0使用参数 就是因为这里
    // 2.底层就是通过sqlSession调用方法，这就和之前的Mybatis四大组件连接上了
    switch (command.getType()) {
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
      case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) {// 无返回
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {// 返回集合
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {// 返回Map
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {// 返回游标
          result = executeForCursor(sqlSession, args);
        } else {// 查询单个
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

  // 处理结果 返回修改的行数 或者 布尔值`
  private Object rowCountResult(int rowCount) {
    final Object result;
    if (method.returnsVoid()) {
      result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
      result = (long)rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
      result = rowCount > 0;
    } else {
      throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    return result;
  }
  
  // 用ResultHandler执行查询sql
  private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
    if (void.class.equals(ms.getResultMaps().get(0).getType())) {
      throw new BindingException("method " + command.getName() 
          + " needs either a @ResultMap annotation, a @ResultType annotation," 
          + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
    }
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
    } else {
      sqlSession.select(command.getName(), param, method.extractResultHandler(args));
    }
  }
    
  // 执行查询SQL，默认返回结果对象集合
  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.<E>selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      if (method.getReturnType().isArray()) {
        // 结果转换成数组
        return convertToArray(result);
      } else {
        // 
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
  }
  // 执行查询SQL，返回结果对象游标
  private <T> Cursor<T> executeForCursor(SqlSession sqlSession, Object[] args) {
    Cursor<T> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<T>selectCursor(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.<T>selectCursor(command.getName(), param);
    }
    return result;
  }
  // 将结果转换成返回类型 ,method返回类型必须是Collection的子类
  private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
    Object collection = config.getObjectFactory().create(method.getReturnType());
    MetaObject metaObject = config.newMetaObject(collection);
    metaObject.addAll(list);
    return collection;
  }
  
  // 转换成数组
  @SuppressWarnings("unchecked")
  private <E> Object convertToArray(List<E> list) {
    Class<?> arrayComponentType = method.getReturnType().getComponentType();
    Object array = Array.newInstance(arrayComponentType, list.size());
    if (arrayComponentType.isPrimitive()) {
      for (int i = 0; i < list.size(); i++) {
        Array.set(array, i, list.get(i));
      }
      return array;
    } else {
      return list.toArray((E[])array);
    }
  }
  // 执行查询SQL，返回结果对象映射
  private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
    Map<K, V> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
    } else {
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
    }
    return result;
  }
}

ParamMap 静态内部类

封装的HashMap，主要用于返回Mybatis特定的异常信息

public static class ParamMap<V> extends HashMap<String, V> {

    private static final long serialVersionUID = -2212268410512043556L;

    @Override
    public V get(Object key) {
      if (!super.containsKey(key)) {
        throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet());
      }
      return super.get(key);
    }

  }

SqlCommand 静态内部类

单独封装了一套静态内部类，根据内容判断主要就是为了解决接口继承的问题，因为我们调用的接口可能是父类接口的方法，然后又进了MappedStatement的获取，这样在使用的时候更方便

// Sql公共属性
public static class SqlCommand {
    // 类名+方法名 对应着唯一的方法
    private final String name;
    // DML标签的类型
    private final SqlCommandType type;
    
    // 构造方法
    public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
      // 接口方法名
      final String methodName = method.getName();
      // 接口类
      final Class<?> declaringClass = method.getDeclaringClass();
      // 获取DML标签封装类
      MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,configuration);
      if (ms == null) {// 正常都会获取到
        if (method.getAnnotation(Flush.class) != null) {
          name = null;
          type = SqlCommandType.FLUSH;
        } else {
          throw new BindingException("Invalid bound statement (not found): "
              + mapperInterface.getName() + "." + methodName);
        }
      } else {
        // name为类名+方法名
        name = ms.getId();
        // SQL类型
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
          throw new BindingException("Unknown execution method for: " + name);
        }
      }
    }

    public String getName() {
      return name;
    }

    public SqlCommandType getType() {
      return type;
    }
    // 解析DML标签
    private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
        Class<?> declaringClass, Configuration configuration) {
      //拼装statementId，取映射器接口包名+类名+'.'+方法名
      String statementId = mapperInterface.getName() + "." + methodName;
      if (configuration.hasStatement(statementId)) {
        // 也是从configuration里面获取解析好的
        return configuration.getMappedStatement(statementId);
      } else if (mapperInterface.equals(declaringClass)) {
        // 如果映射器接口类等于声明method的类
        return null;
      }
      // 遍历映射器接口类继承的所有接口
      for (Class<?> superInterface : mapperInterface.getInterfaces()) {
        if (declaringClass.isAssignableFrom(superInterface)) {
          MappedStatement ms = resolveMappedStatement(superInterface, methodName,
              declaringClass, configuration);
          if (ms != null) {
            return ms;
          }
        }
      }
      return null;
    }
  }

MethodSignature 静态内部类

// 类名意思为方法特征
public static class MethodSignature {
    
    private final boolean returnsMany;// 返回结果是集合类型
    private final boolean returnsMap; // 返回结果是Map类型
    private final boolean returnsVoid;// 无返回
    private final boolean returnsCursor;// 返回游标
    private final Class<?> returnType;// 返回类型
    private final String mapKey; // 
    private final Integer resultHandlerIndex;
    private final Integer rowBoundsIndex;
    private final ParamNameResolver paramNameResolver;// 参数解析器
    
    public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
      Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
      if (resolvedReturnType instanceof Class<?>) {
        this.returnType = (Class<?>) resolvedReturnType;
      } else if (resolvedReturnType instanceof ParameterizedType) {
        this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
      } else {
        this.returnType = method.getReturnType();
      }
      this.returnsVoid = void.class.equals(this.returnType);
      this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
      this.returnsCursor = Cursor.class.equals(this.returnType);
      this.mapKey = getMapKey(method);
      this.returnsMap = this.mapKey != null;
      this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
      this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
      this.paramNameResolver = new ParamNameResolver(configuration, method);
    }
    // 将Java参数转换成sql脚本参数
    // 假如方法传入了一个参数，那么这里一般会在这个基础上，增加一个param0 param1
    // 也就是我们在mapper文件中使用一个参数 可以通过参数名，或者 ‘param0’ 就是在这里处理的
    // 其实就是遍历添加到一个Map里面
    public Object convertArgsToSqlCommandParam(Object[] args) {
      return paramNameResolver.getNamedParams(args);
    }

    // 省略一些getter方法

    private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
      Integer index = null;
      final Class<?>[] argTypes = method.getParameterTypes();
      for (int i = 0; i < argTypes.length; i++) {
        if (paramType.isAssignableFrom(argTypes[i])) {
          if (index == null) {
            index = i;
          } else {
            throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
          }
        }
      }
      return index;
    }

    private String getMapKey(Method method) {
      String mapKey = null;
      if (Map.class.isAssignableFrom(method.getReturnType())) {
        final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class);
        if (mapKeyAnnotation != null) {
          mapKey = mapKeyAnnotation.value();
        }
      }
      return mapKey;
    }
  }

上面解析参数convertArgsToSqlCommandParam()用到了getNamedParams()

private static final String GENERIC_NAME_PREFIX = "param";

public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    if (args == null || paramCount == 0) {
      return null;
    } else if (!hasParamAnnotation && paramCount == 1) {
      return args[names.firstKey()];
    } else {
      final Map<String, Object> param = new ParamMap<Object>();
      int i = 0;
      for (Map.Entry<Integer, String> entry : names.entrySet()) {
        // 添加正常key-value
        param.put(entry.getValue(), args[entry.getKey()]);
        // add generic param names (param1, param2, ...)
        final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
        // ensure not to overwrite parameter named with @Param
        if (!names.containsValue(genericParamName)) {
          // 添加param1,param2,...
          param.put(genericParamName, args[entry.getKey()]);
        }
        i++;
      }
      return param;
    }
  }

aram = new ParamMap();
int i = 0;
for (Map.Entry<Integer, String> entry : names.entrySet()) {
// 添加正常key-value
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, …)
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
// 添加param1,param2,…
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
为人师表好少年
关注
专栏目录
【项目实战】MyBatis的基础源码 —— MapperProxy（Mapper接口的代理类）源码介绍
本本本添哥
04-17 624
MapperProxy是MyBatis中的一个重要类，它是Mapper接口的代理类。
Mybatis源码分析.pdf
08-30
MyBatis是一款优秀的持久层框架，它的源码分析对于深入理解其工作原理和优化数据库操作至关重要。MyBatis的核心设计理念是简化SQL操作，通过XML或注解的方式将SQL与Java代码分离，同时提供强大的动态SQL功能。 首先...
手敲Mybatis(一)-实现Mapper代理注册和使用
dfBeautifulLive的博客
05-23 1800
Mybatis使用最多的就是代理模式，要学会Mybatis必须会代理模式的使用，所以需要先了解java中的动态代理，也可以看我之前的博文，传送门如下： 理解代理模式MyBatis就掌握了一半(详解动态代理原理) 本章节学习来源是小傅哥博客，传送门：bugstack 虫洞栈，通过此博客学习Mybatis来学习它的思路，经历手敲、推敲、琢磨、来形成自己思路语言总结。 此章节主要是处理我们对于Dao接口，我们没有实现Dao却能够使用此接口反馈实现结果，原因是Mybatis的代理模式，所以我们要实现对于Myb
Mybatis源码解析之MapperProxy
恐龙弟旺仔的博客
01-04 4173
前言：     我们在前面Mybatis源码解析之一级缓存  介绍过使用SqlSession提供的方法直接操作JDBC的方式。     在实际工作中，我们一般都比较偏向于使用以下方式来进行JDBC操作 BlogMapper mapper = session.getMapper(BlogMapper.class); Blog blog3 = mapper.queryById(17);   ...
Mybatis源码解析(八)：Mapper代理原理
从基础到源码解析的学习记录
12-02 2417
文章主要围绕着如下几个点，展开源码解析：是如何进行解析的？是如何生成的代理对象？是怎么完成的增删改查操作？标签配置的包名下的Mapper接口文件都会被加载成对应的代理类工厂通过Mapper接口获取同包同名的xml文件，并解析Mapper接口通过jdk代理创建代理类，接口方法匹配xml中标签的id值，执行增删改查。
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
MyBatis源码详解学习.zip
09-30
《MyBatis源码详解学习》是一份专为对MyBatis源码感兴趣的开发者准备的资料，它旨在帮助读者深入理解这个流行持久层框架的工作原理。MyBatis作为一个轻量级的ORM（对象关系映射）框架，因其简单易用、高度可定制化的...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
MyBatis源码解析
12-18
MyBatis源码解析
Mybatis中方法和sql语句的桥梁——MapperProxy
m0_64363449的博客
09-02 197
事实上，Mybatis中getMapper获取实例对象的背后的逻辑就是通过动态代理的方式生成一个实现该接口的代理类。进一步，调用该实例对象执行对应sql的背后的逻辑也全部交给了SqlSession来处理。至于SqlSession中是如何执行sql的且听后续分解~~读源码，分析源码本身就是一件枯燥的事情。作者在行文排版上已经尽可能减少代码的的排版，因为作者觉得大段的粘贴代码只会降低行文的可读性。事实上，作者更喜欢用图示的信息来展现代码间的调用逻辑。希望文章中的图能对你理解MyBatis有所帮助。
Mybatis源码剖析之Mybatis执行流程（传统方式）
白鸽
01-15 386
预读 Mybatis在设计上，分为三层：接口层，数据处理层，框架支持层 在接口层中，分为 传统模式：通过sqlSession + statementId。 接口代理模式：sqlSession+mapper接口 准备 userMapper.xml mybatis核心配置文件 <configuration> <!--加载外部的properties文件--> <properties resource="jdbc.properties"></prop
Mybatis源码分析十之MapperProxy
solayang的博客
12-10 983
一、MapperProxyFactory 在使用mybatis的时候，配置好对应文件，只需要调用接口方法就可以实现对数据库操作。接口本身是不可以直接使用的，需要有具体的实现类，在mybatis中我们不需要去编写具体的实现类，只需要编写对应的接口就行。到这里，估计大家都已猜出，mybatis用代理的方式为我们做了实现，所以本文会重点分析mybatis中代理的实现。 在SqlSession中有个getMapper(Class< T > type)，我们只需要传递一个具体的接口，就可以得到其代理对象。
设计模式--代理模式
每天多学一点点. 的博客
12-30 276
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。 在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。 1 介绍 意图：为其他对象提供一种代理以控制对这个对象的访问。 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，...
MyBatis基础知识复习笔记
程哥哥的一亩三分地
03-16 557
Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。
Mapper动态代理原理
m0_58889888的博客
06-15 138
SqlSession的getMapper方法，最终是调用的是JDK动态代理方法，生成一个代理对象，类型就是传入的接口类型。 MapperProxy对象通过调用MapperMethod的execute方法定义了代理方式，该方法的底层调用的是SqlSession的方法。
【MyBatis】原理四：MapperProxy执行业务方法
winrh的博客
08-14 1028
1. mapperProxy调用业务方法，实则调用invoke // method就是EmployeeMapper定义的抽象方法： // public abstract org.example.bean.Employee org.example.dao.EmployeeMapper.getEmpById(java.lang.Integer) @Override public Object invoke(Object proxy, Method method, O...
MyBatis源码解读（2）——MapperProxy
qingtian211的博客
08-17 338
上篇文章，解析了SqlSession 的创建过程，本章延续上章的内容，接着SqlSession 来讲解MapperProxy。 1、通过sqlSession 调用getMapper() 方法，来解析过程。 接着上一篇讲到通过 DefaultSqlSessionFactory 可以得到一个 SqlSession 的实例 DefaultSqlSession 。 通过 DefaultSql...
源码分析Mybatis MapperProxy初始化之Mapper对象的扫描与构建(图文并茂)
最新发布
weixin_40466809的博客
02-01 459
温馨提示：本文基于Mybatis.3.x版本。 MapperScannerConfigurer，Spring整合Mybatis的核心类，其作用是扫描项目中Dao类，将其创建为Mybatis的Maper对象即MapperProxy对象。 首先进入源码学习之前，我们先看一下在项目中的配置文件信息。 我们注意到这里有两三个与Mapper相关的配置： SqlSessionFactory#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

为人师表好少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值