mybatis-3.4.x 从源码看configuration[笔记二]

最新推荐文章于 2024-06-04 00:09:49 发布
最新推荐文章于 2024-06-04 00:09:49 发布
阅读量241 收藏
点赞数
分类专栏： 学习笔记 数据库 文章标签： 数据库 mybatis 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41051202/article/details/83347689
版权

mapper sql的映射接口 mybatis的接口是如何与xml的sql关联的
sql映射现在有两种方式

  1. 注解方式
  2. xml配置方法

注册mapper接口

  /*******解析mapper xml 详见XMLMapperBuilder.java*************/
   private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      //设定正在解析的mapper名称空间
      builderAssistant.setCurrentNamespace(namespace);
      /*解析引用的缓存*/
      cacheRefElement(context.evalNode("cache-ref"));
      /*解析自己名称空间的缓存*/
      cacheElement(context.evalNode("cache"));
      /*解析参数映射的map*/
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      /*解析结果集映射*/
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      /*解析sql模板*/
      sqlElement(context.evalNodes("/mapper/sql"));
      /*解析增删改查的sql*/
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }

mapper接口执行逻辑分析

  1. mapper 接口MapperProxyFactory生成动态代理对象MapperProxy
  2. MapperProxy 执行接口方法Method 映射的MapperMethod方法获取方法执行结果
  3. MapperMethod对象调用sqlSession对象执行数据库 增删改查操作
  4. sqlSession将操作代理给Executor执行
  5. Executor根据接口映射的MappedStatement对象执行底层数据库操作
  6. MappedStatement 获取sqlSource,并根据参数生成最终的sql语句，GenericTokenParser【${} 直接替换成参数值,#{} 替换成 ？】 解析替换sql内的参数表达式
  7. MappedStatement 获取到Statement ，如果是PreparedStatement,则跟根据参数类型选择合适的typeHandler，为PreparedStatement设置查询的参数值，优先已参数上设置的typeHandler为准，不设置，则自动判断来获取
  8. Statement执行sql，结果集交给ResultSetHandler处理，自动转换成需要的Pojo对象
  9. 获取到结果，如果存在ResultHandler,则交给ResultHandler处理结果
  10. 处理事务，关闭资源

mapper生成代理对象

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;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public Map<Method, MapperMethod> getMethodCache() {
    return methodCache;
  }

  /*获取mapper接口的动态代理对象*/
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    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);
  }

}

代理对象的实际执行逻辑

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;
  }

  //mapper 接口的实际执行逻辑
  @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)) {
        //如果是接口默认方法则直接调用
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    //接口声明的sql映射类方法，执行对应的MapperMethod方法
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    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
  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);
  }

  /**
   * Backport of java.lang.reflect.Method#isDefault()
   */
  /*是否默认方法*/
  private boolean isDefaultMethod(Method method) {
    return (method.getModifiers()
        & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) == Modifier.PUBLIC
        && method.getDeclaringClass().isInterface();
  }
}

接口方法映射的MapperMethod，实际的sql执行的路由逻辑，根据SqlCommand方式路由到SqlSession中执行对应的方法

public class MapperMethod {
  //sql的类型 update/delete/insert/select/flush
  private final SqlCommand command;
  //mapper方法的元信息
  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;
    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()) {
          //处理带有ResultHandler参数方式的接口
          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;
  }
  
  /*
  * INSERT UPDATE  DELETE 返回值只有四种 void，int,long,boolean
  * */
  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;
  }
  ...

public static class MethodSignature {
    //是否返回多条记录
    private final boolean returnsMany;
    //是否返回map
    private final boolean returnsMap;
    //是否没有返回值
    private final boolean returnsVoid;
    //是否返回游标
    private final boolean returnsCursor;
    //返回类型
    private final Class<?> returnType;
    //返回值为Map是作为key的属性
    private final String mapKey;
    //resultHandler参数的参数索引位置
    private final Integer resultHandlerIndex;
    //rowBounds参数的参数索引位置
    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);
    }
    ...

sqlSession 根据commandName获取到对应的MappedStatement，交给executor执行

public final class MappedStatement {
  //资源文件
  private String resource;
  //核心配置类
  private Configuration configuration;
  //唯一标识
  private String id;
  //sql设置的fetchSize
  private Integer fetchSize;
  private Integer timeout;
  //Statement 类型
  private StatementType statementType;
  private ResultSetType resultSetType;
  //sql的信息
  private SqlSource sqlSource;
  //对应的缓存地址
  private Cache cache;
  //配置的参数映射集合
  private ParameterMap parameterMap;
  //结果集映射
  private List<ResultMap> resultMaps;
  //是否刷新缓存
  private boolean flushCacheRequired;
  //是否使用缓存
  private boolean useCache;
  private boolean resultOrdered;
  //sql的类型
  private SqlCommandType sqlCommandType;
  //主键生成策略
  private KeyGenerator keyGenerator;
  private String[] keyProperties;
  private String[] keyColumns;
  private boolean hasNestedResultMaps;
  private String databaseId;
  private Log statementLog;
  private LanguageDriver lang;
  private String[] resultSets;
  ...

executor查询

  /*详见BaseExecutor.java*/
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //根据参数获取需要执行的sql
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

 /***详见MappedStatement.java***/
  public BoundSql getBoundSql(Object parameterObject) {
    //根据参数获取需要执行的sql,将${},#{}处理掉，处理掉条件语句，组装成最终的SQL
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }

    return boundSql;
  }

/*详见CachingExecutor.java*/
@Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    //获取mapper对应的缓存
    Cache cache = ms.getCache();
    if (cache != null) {
      //如果需要刷新缓存就清掉二级缓存
      flushCacheIfRequired(ms);
      //如果使用缓存，且没有resultHandler则先试着从缓存读取结果
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          //没有缓存，则执行后面的代理操作
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

/*详见BaseExecutor.java*/
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //从一级缓存读取查询结果
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      //如果LocalCacheScope为STATEMENT，则不缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
MyBatis-Plus(spring版)学习笔记
java
08-03 740
尚硅谷mybatisplus学习笔记
MyBatis-Plus3.5.2 学习指南
nangon1234的博客
12-03 830
是的，如果没有锁，小李的操作就完全被小王的覆盖了。小李正在玩游戏，耽搁了一个小时。① 同样以用户 ID 为例，假如我们一开始就规划了 10 个数据库表，可以简单地用 user_id % 10 的值来表示数据所属的数据库表编号，ID 为 985 的用户放到编号为 5 的子表中，ID 为 10086 的用户放到编号为 6 的子表中。​ 首先是一个符号位，1 bit 标识，由于 long 基本类型在 Java 中是带符号的，最高位是符号位，正数是 0，负数是 1，所以 id 一般是正数，最高位是 0。
MyBatis 3.4 中文手册
05-11
MyBatis 3.4 中文手册，包括手册、源代码xref、Java api doc、测试源代码xref。 文档日期： 17 四月 2016 | 版本: 3.4.0 chm编日期：2016年5月11日 文件大小：2.98MB
Mybatis（7）- 源码解析（1）读取配置 Configuration
sql2008help的博客
05-02 1749
Mybatis（3）- 源码解析（1）读取配置 Configuration 从MyBatis入门使用文章中可知，MyBatis在使用前有一些前置的配置，并且每个Mapper接口需要对应一个 *Mapper.xml 的配置文件，这篇文章将解析 Mybatis 读取配置文件的过程。 public class Main { public static void main(String[] args) { String resource = "mybatis-config.xml";
Mybatis-Configuration(一)
zl979899的博客
01-11 347
Properties（属性） 1.Properties文件 jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mybatis jdbc.username=root jdbc.password=123456 2.properties（属性） <!-- mybatis可以使用properties来引入外部properties配置文件的内容； resource：引入类路径下的资源 url：引入网..
02-mybatis源码探究
weixin_42323655的博客
02-18 205
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { SqlSessionFactory var5; try { XMLConfigBuilder parser = new XMLConfigB...
Mybatis主配置—Configuration
乐只悠悠
09-19 3934
Mybatis配置信息主要分为Mybatis项目级配置信息（Configuration）和执行SQL语句的Mapper配置文件，那么什么是Mybatis项目级配置信息Configuration呐？Configuration的主要职责就是用于描述Mybatis的配置信息，其内部定义了大量用于控制Mybatis运行时行为的属性。其它组件可以通过调用Configuration对象的形式来获取配置信息。
mybatis源码学习4---Configuration解析
qq_45100361的博客
05-28 206
Configuration类解析 Configuration类位于mybatis包的org.apache.ibatis.session目录下，是mybatis的全局变量，属性就是对应于mybatis的全局配置文件mybatis-config.xml的配置，将XML配置中的内容解析赋值到Configuration对象中。 由于XML配置项有很多，所以Configuration类的属性也很多。先来看下Configuration对于的XML配置文件示例： <?xml version="1.0" encodi
Mybatis-Plus 新手入门，一篇足以
m0_65992672的博客
05-08 676
MyBatis-Plus.简介、入门案例、增删改查、BaseMapper、通用Service、IService、常用注解、@TableName、@TableId、@TbaleField、@TableLogic、条件构造器、QueryWrapper、UpdateWrapper、LambdaQueryWrapper、分页插件、乐观锁、通用枚举、代码生成器、多数据源、MyBatisX插件
Mybatis源码分析三之Configuration
solayang的博客
11-25 929
一、Configuration Configuration对应的就是mybatis的配置文件，是mybatis的核心类之一，影响着mybatis的各种设置和运行行为，运行mybatis的第一步就是把配置文件转换成Configuration对象。 回到SqlSessionFactoryBuilder的build方法，configuration配置文件的解析是通过XMLConfigBuilder来实现。调用其parse()方法返回Configuration对象。 ...
Mybatis解析——Configuration
qq_18991441的博客
06-28 681
    从之前的《Mybatis解析——SqlSessionFactoryBean》可以看出，Configuration在SqlSessionFactory的创建过程中是一个很重要的环节。    在SqlSessionFactoryBean.class可以看到Configuration的创建方式，在未配置configurationProperties的情况下，这里主要的参数是configLocat...
Mybatis Configuration 源码
10-24 1192
注解解携
深入浅出MyBatis-Configuration
热门推荐
追求极致的人
06-12 4万+
Configuration是干嘛的 Configuration就像是Mybatis的总管，Mybatis的所有配置信息都存放在这里，此外，它还提供了设置这些配置信息的方法。Configuration可以从配置文件里获取属性值，也可以通过程序直接设置。Configuration里可供配置的属性有： 1.       properties属性 1)       配置示例 2
mybatis-3.4.x 从源码看configuration[笔记一]
cityLight的博客
10-23 238
前提小知识 数据库操作的常规步骤 1.加载数据库驱动 2.根据认证信息获取数据库连接 3.开启事务 4.创建statement 5.执行sql 6.处理结果集 7.提交事务 8.关闭资源 mybatis官方学习文档地址 http://www.mybatis.org/mybatis-3/ 从源码看mybatis configuration 中几个主要的配置都是什么作用 /** ...
MyBatis3.4全集笔记
最新发布
weixin_64646820的博客
06-04 1441
1. MyBatis 简介 2. Maven MyBatis搭建 3. Mapper.xml文件的注册和自动扫描 4.解决后台提示找不到对应xml文件 5.两种处理操作数据库的方式 6.关闭自动提交事务 7.Xml配置方式的增删改查 8.多参数传递 9.Java中的Map结构传递 10.Map结构传递 11.注解的使用 12.动态SQL的if使用 – 非常重要 13.动态SQL的where使用 14.动态SQL的choose when使用 15.逆向工程mybatis-generator-maven-plu
MyBatis_Plus(Spring版本笔记)
生命不息，编程不止的博客
08-06 1067
对MyBatis_plus进行的较为细致的讲解
mybatis源码解析2——Configuration
ShewMi的专栏
05-09 709
上一篇解析了SqlSession的源码，本篇继续解读有关流程，继续来看这个例子： public int update(int id) { SqlSession session = SQLSessionFactory.getSessoinFactory().openSession(); int i = session.update(namespace+"updateOne",id); s...
mybatis学习笔记 3.4 XML配置——mappers（映射器）
nothingavenger的博客
09-24 280
目录resource 相对路径（推荐）file 绝对路径（弃掉） 四种方式 resource 相对路径（推荐） 在前面的案例里，都用的这个，就不说了 没什么BUG，路径写对就行了 推荐使用 file 绝对路径（弃掉） 绝对路径不安全，直接不考虑这个 class 类名 要写全的相对路径 当前结构 接口和xml名字不一样 mybatis的xml配置文件修改 执行，报错： java.lang.ClassNotFoundException: Cannot find class: com.study.mybat
Configuration源码
蔡里都傻的博客
09-27 213
#mermaid-svg-qQxRQDn3Y9I8eOkW .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-qQxRQDn3Y9I8eOkW .label text{fill:#333}#mermaid-svg-qQxRQDn3Y9I8eOkW .node rect,#mermaid-svg-qQxRQDn3Y9
Mybatis源码解析(二) —— 加载 Configuration
qq_22178703的博客
11-08 1128
Mybatis源码解析(二) —— 加载 Configuration    正如上文所看到的 Configuration 对象保存了所有Mybatis的配置信息，也就是说mybatis-config.xml 以及 mapper.xml 中的所有信息都可以在 Configuration 对象中获取到。所以一般情况下，Configuration 对象只会存在一个。通过上篇文章我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值