本文是作者原创,版权归作者所有.若要转载,请注明出处.本文以简单的insert语句为例,只贴我觉得比较重要的源码,其他不重要非关键的就不贴了

 

1.mybatis的底层是jdbc操作,我们先来回顾一下insert语句的执行流程,如下

 

//连接数据库 
    Class.forName("com.mysql.jdbc.Driver"); 
    String url="jdbc:mysql://localhost/kaikeba?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8"; 
    String user="root"; 
    String password="root"; 
    //建立连接 
    Connection conn = DriverManager.getConnection(url, user, password); 
    //sql语句 
    String sql="INSERT INTO dept(DNAME)VALUES (?)"; 
    //获得预处理对象 
    PreparedStatement preparedStatement = conn.prepareStatement(sql); 
    //将SQL语句占位符位置设置实际参数 
    preparedStatement.setString(1, "T"); //为问号赋值 
    //增删改都使用executeUpdate()提交,返回值是int,表示有多少条数据受到了影响 
    int i = preparedStatement.executeUpdate(); 
    System.out.println(i); 
    //释放资源 
    preparedStatement.close(); 
    conn.close();

 

执行完后,我们看下数据库结果

OK,语句生效了.

 

2.贴一下我用mybatis框架写的demo,贴一下主要代码,依次是写sql的xml,以及该xml所对应的接口,还有个是测试的代码

 

 

 还有mybatis的配置信息

<configuration>

<!-- 指定properties配置文件, 我这里面配置的是数据库相关 -->
<properties resource="db.properties"></properties>

<settings>
<!-- 该配置影响的所有映射器中配置的缓存的全局开关。默认值true -->
<setting name="cacheEnabled" value="true"/>
<!--配置默认的执行器。SIMPLE 就是普通的执行器;REUSE 执行器会重用预处理语句; BATCH 执行器将重用语句并执行批量更新。默认SIMPLE -->
<setting name="defaultExecutorType" value="SIMPLE"/>
</settings>

<!--别名-->
<typeAliases>
<typeAlias type="com.lusaisai.po.DeptInfo" alias="deptInfo"></typeAlias>
</typeAliases>

<!-- 和spring整合后mybatis的 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>

<!-- 加载mapper.xml -->
<mappers>
<!-- 第一种方式:通过resource指定 -->
<mapper resource="com/lusaisai/mapper/DemoMapper.xml" ></mapper>
<!--第二种方式,直接指定包,自动扫描-->
<!--<package name="com.lusaisai.mapper.*"/>-->
</mappers>

</configuration>

 

 

 执行完后,我们看下数据库结果

 

 

 

 

 

 OK,语句生效了.

 

3.现在是开始阅读源码环节,我在源码上加了自己的理解,这就是我上篇文章编译mybatis源码的好处,否则就只能干看了

 

从读取配置文件下面一行代码开始

 

//就是这个方法,注意后面两个参数均为空 
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { 
    try { 
      //XMLConfigBuilder看这个名字就是对mybatis的配置文件进行解析的类,现在他还是一个初始化对象,没有开始解析.用的是java的dom解析 
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties); 
      //这个就是读取方法,parser.parse()返回一个Configuration对象,该对象将存放读取配置文件的信息 
      //build(parser.parse())传入一个Configuration对象,并使用多态返回SqlSessionFactory接口的实体类DefaultSqlSessionFactory 
      //DefaultSqlSessionFactory只有一个属性,就是Configuration对象 
      return build(parser.parse()); 
    } catch (Exception e) { 
      throw ExceptionFactory.wrapException("Error building SqlSession.", e); 
    } finally { 
      ErrorContext.instance().reset(); 
      try { 
        //这里关闭了读取流inputStream,我们不用再手动关闭了 
        inputStream.close(); 
      } catch (IOException e) { 
        // Intentionally ignore. Prefer previous error. 
      } 
    } 
  }

 

 

一层一层看下去:先内层,返回Configuration对象,这个对象是用来存储解析xml文件的信息的

 

 

//调用此方法对mybatis配置文件进行解析 
  public Configuration parse() { 
    //注意:parsed默认为false,配置文件读取非常消耗资源,因此这里只读取一次,如果读取过则将parsed的值改为true,再次读取的时候就抛一个异常 
    if (parsed) { 
      throw new BuilderException("Each XMLConfigBuilder can only be used once."); 
    } 
    //在这里将parsed的值改为true 
    parsed = true; 
    //从配置文件configuration标签开始解析,具体解析过程在下面 
    parseConfiguration(parser.evalNode("/configuration")); 
    //返回Configuration对象用于存储mybatis配置文件信息 
    return configuration; 
  }

 

//此方法就是解析configuration节点下的子节点 
  private void parseConfiguration(XNode root) { 
    try { 
      //issue #117 read properties first,这里先读取properties标签,也就是数据库配置 
      //我们在configuration下面能配置的节点为以下10个节点 
      //properties标签这里一般配置数据源 
      propertiesElement(root.evalNode("properties")); 
      //settings标签可以配置缓存,执行器等信息 
      Properties settings = settingsAsProperties(root.evalNode("settings")); 
      loadCustomVfs(settings); 
      loadCustomLogImpl(settings); 
      typeAliasesElement(root.evalNode("typeAliases"));//解析别名,点进去看下 
      pluginElement(root.evalNode("plugins"));//解析插件 
      objectFactoryElement(root.evalNode("objectFactory")); 
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); 
      reflectorFactoryElement(root.evalNode("reflectorFactory")); 
      settingsElement(settings); 
      // read it after objectFactory and objectWrapperFactory issue #631 
      environmentsElement(root.evalNode("environments"));//解析jdbc信息 
      databaseIdProviderElement(root.evalNode("databaseIdProvider")); 
      typeHandlerElement(root.evalNode("typeHandlers")); 
      mapperElement(root.evalNode("mappers"));//解析mapper 
    } catch (Exception e) { 
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); 
    } 
  }
//解析settings标签,返回Properties对象 
  private Properties settingsAsProperties(XNode context) { 
    //如果没有settings标签,给一个默认值 
    if (context == null) { 
      return new Properties(); 
    } 
    //如果有settings标签,解析 
    Properties props = context.getChildrenAsProperties(); 
    // Check that all settings are known to the configuration class 
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory); 
    for (Object key : props.keySet()) { 
      if (!metaConfig.hasSetter(String.valueOf(key))) { 
        throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive)."); 
      } 
    } 
    return props; 
  }

 

 我们可以看到返回的Properties对象就是我们mybatis的配置信息里的值,当然还有很多默认属性这里就不一一列举了

 

下面我们看下怎么解析别名的

//解析别名的方法 
  private void typeAliasesElement(XNode parent) { 
    //解析别名标签 
    if (parent != null) { 
      for (XNode child : parent.getChildren()) { 
        //批量解析 
        if ("package".equals(child.getName())) { 
          String typeAliasPackage = child.getStringAttribute("name"); 
          configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage); 
        } else {//一个一个解析 
          String alias = child.getStringAttribute("alias"); 
          String type = child.getStringAttribute("type"); 
          try { 
            //根据type表示的全限定名拿到它的class对象 
            Class<?> clazz = Resources.classForName(type); 
            //注册别名,分两种情况,一种别名alias为空,一种不为空 
            if (alias == null) {//别名alias为空 
              typeAliasRegistry.registerAlias(clazz); 
            } else {//别名alias不为空 
              typeAliasRegistry.registerAlias(alias, clazz); 
            } 
          } catch (ClassNotFoundException e) { 
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e); 
          } 
        } 
      } 
    } 
  }
//Alias为空的注册别名方法 
  public void registerAlias(Class<?> type) { 
    String alias = type.getSimpleName(); 
    //看下注解上面有没有 
    Alias aliasAnnotation = type.getAnnotation(Alias.class); 
    //如果有注解,解析注解 
    if (aliasAnnotation != null) { 
      alias = aliasAnnotation.value(); 
    } 
    //否则,解析xml 
    registerAlias(alias, type); 
  } 
 
  //这就是注册别名的本质方法, 其实就是向保存别名的hashMap新增值而已 
  public void registerAlias(String alias, Class<?> value) { 
    if (alias == null) { 
      throw new TypeException("The parameter alias cannot be null"); 
    } 
    // issue #748 
    //别名统一处理,都转化为小写,所以别名不区分大小写 
    String key = alias.toLowerCase(Locale.ENGLISH); 
    if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) { 
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'."); 
    } 
    //将别名存进map 
    typeAliases.put(key, value); 
  }
//原来别名就通过一个HashMap来实现, key为别名, value就是别名对应的类型(class对象) 
  private final Map<String, Class<?>> typeAliases = new HashMap<>(); 
 
  //别名在这这个构造方法做默认的处理,以下就是mybatis默认为我们注册的预制别名 
  public TypeAliasRegistry() { 
    registerAlias("string", String.class); 
 
    registerAlias("byte", Byte.class); 
    registerAlias("long", Long.class); 
    registerAlias("short", Short.class); 
    registerAlias("int", Integer.class); 
    registerAlias("integer", Integer.class); 
    registerAlias("double", Double.class); 
    registerAlias("float", Float.class); 
    registerAlias("boolean", Boolean.class); 
 
    registerAlias("byte[]", Byte[].class); 
    registerAlias("long[]", Long[].class); 
    registerAlias("short[]", Short[].class); 
    registerAlias("int[]", Integer[].class); 
    registerAlias("integer[]", Integer[].class); 
    registerAlias("double[]", Double[].class); 
    registerAlias("float[]", Float[].class); 
    registerAlias("boolean[]", Boolean[].class); 
 
    registerAlias("_byte", byte.class); 
    registerAlias("_long", long.class); 
    registerAlias("_short", short.class); 
    registerAlias("_int", int.class); 
    registerAlias("_integer", int.class); 
    registerAlias("_double", double.class); 
    registerAlias("_float", float.class); 
    registerAlias("_boolean", boolean.class); 
 
    registerAlias("_byte[]", byte[].class); 
    registerAlias("_long[]", long[].class); 
    registerAlias("_short[]", short[].class); 
    registerAlias("_int[]", int[].class); 
    registerAlias("_integer[]", int[].class); 
    registerAlias("_double[]", double[].class); 
    registerAlias("_float[]", float[].class); 
    registerAlias("_boolean[]", boolean[].class); 
 
    registerAlias("date", Date.class); 
    registerAlias("decimal", BigDecimal.class); 
    registerAlias("bigdecimal", BigDecimal.class); 
    registerAlias("biginteger", BigInteger.class); 
    registerAlias("object", Object.class); 
 
    registerAlias("date[]", Date[].class); 
    registerAlias("decimal[]", BigDecimal[].class); 
    registerAlias("bigdecimal[]", BigDecimal[].class); 
    registerAlias("biginteger[]", BigInteger[].class); 
    registerAlias("object[]", Object[].class); 
 
    registerAlias("map", Map.class); 
    registerAlias("hashmap", HashMap.class); 
    registerAlias("list", List.class); 
    registerAlias("arraylist", ArrayList.class); 
    registerAlias("collection", Collection.class); 
    registerAlias("iterator", Iterator.class); 
 
    registerAlias("ResultSet", ResultSet.class); 
  }

我们再看下如何解析mappers标签

 

//解析com/lusaisai/mapper/DemoMapper.xml 方法 
  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"); 
      } 
      builderAssistant.setCurrentNamespace(namespace); 
      cacheRefElement(context.evalNode("cache-ref"));//解析缓存标签 
      cacheElement(context.evalNode("cache")); 
      parameterMapElement(context.evalNodes("/mapper/parameterMap")); 
      resultMapElements(context.evalNodes("/mapper/resultMap"));//解析resultMap标签 
      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); 
    } 
  }

 我们再看下mybatis是怎么解析sql的,贴一下重要代码

 

 可以看到originalSql 就是我们自己写的代码,在这个方法里将#{和}里的参数替换为占位符并返回

public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) { 
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters); 
    //INSERT INTO dept(DNAME) VALUES (#{dName})  将#{和}里的参数替换为占位符? 
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
  //这里点进去 String sql
= parser.parse(originalSql); return new StaticSqlSource(configuration, sql, handler.getParameterMappings()); }

 

这个就是解析sql的方法,主要方式是截取我们写的sql语句,将#{}的地方循环截取掉,将里面的参数改成?
 
 
public String parse(String text) {
if (text == null || text.isEmpty()) {
return "";
}
// search open token
int start = text.indexOf(openToken);
if (start == -1) {
return text;
}
char[] src = text.toCharArray();
int offset = 0;
final StringBuilder builder = new StringBuilder();
StringBuilder expression = null;
while (start > -1) {
if (start > 0 && src[start - 1] == '\\') {
// this open token is escaped. remove the backslash and continue.
builder.append(src, offset, start - offset - 1).append(openToken);
offset = start + openToken.length();
} else {
// found open token. let's search close token.
if (expression == null) {
expression = new StringBuilder();
} else {
expression.setLength(0);
}
builder.append(src, offset, start - offset);
offset = start + openToken.length();
int end = text.indexOf(closeToken, offset);
while (end > -1) {
if (end > offset && src[end - 1] == '\\') {
// this close token is escaped. remove the backslash and continue.
expression.append(src, offset, end - offset - 1).append(closeToken);
offset = end + closeToken.length();
end = text.indexOf(closeToken, offset);
} else {
expression.append(src, offset, end - offset);
break;
}
}
if (end == -1) {
// close token was not found.
builder.append(src, start, src.length - start);
offset = src.length;
} else {
//这里就是将#{}里的参数 替换为?的方法
builder.append(handler.handleToken(expression.toString()));
offset = end + closeToken.length();
}
}
start = text.indexOf(openToken, offset);
}
if (offset < src.length) {
builder.append(src, offset, src.length - offset);
}
return builder.toString();
}
 
 
点进去看下,找到了,就是这里将#{}里的参数替换为占位符?
@Override 
    public String handleToken(String content) { 
      parameterMappings.add(buildParameterMapping(content)); 
      return "?"; 
    }

 

 

 

最后封装到Configuration对象的mappedStatements属性的sqlsource里面

 

 到此为止,我们已经把配置文件中的所有配置封装到Configuration对象中.

 

我们看下解析完的Configuration对象都有哪些属性,首先是jdbc配置参数

 

 

然后是这个,混个眼熟,name的值是SIMPLE

然后是这个,刚刚我们看到sql相关

,

 

点开看一下

 

 

 我们可以看到有sql的xml信息和接口信息.

好,回到这里,继续下一层

 

 

 点进去

好了,这里我们知道其实返回了DefaultSqlSessionFactory对象.继续看下去

 

 

 

 这里帮我们关闭了读取流inputStream,我们不用再手动关闭了,继续看下去

 

 

返回的DefaultSqlSessionFactory就是SqlSessionFactory接口的实现类,
这个类只有一个属性,就是Configuration对象,Configuration对象用来存放读取xml配置的信息
继续下一行,点进去

 

 

 刚刚我们看到过这个属性,不知道干啥的,很眼熟,name的值是SIMPLE,继续往下看

 

 

 看下tx这个对象,其他的不仔细看了

 

 

 (猜测:有个属性autoCommit默认是false,不自动提交,这里就对应了上面,我们手动提交事务了,继续往下看DefaultSqlSession)

 

 

 我们发现和上文一样,也是SqlSession接口的实现类

 

现在,可以走出去了

 

 

 


返回的DefaultSqlSession是SqlSession接口的实现类,它应该是与数据库打交道的对象,
对象中有上面传来的Configuration对象,还有executor处理器对象,executor处理器有一个dirty属性,默认为false,如下图

 

 

 现在进入sqlSession的insert方法看下

 

 

 继续点进去看下

 

 

 可以看到,我们拿出了上面提到的sql相关的信息,我们看下ms有哪些属性

 

 

ms对象有两个重要属性:sqlSource是用来存sql语句的,id是DemoMapper接口的.insertDept方法名
继续往下看,下面那个方法应该就是执行的方法了,一层一层点进去

 

 

 这里判断参数是什么类型,我们是string类型,直接原样返回,其他集合类型,数组类型有是专门的处理,继续点下去

 

 我们点进那个执行方法

 

 继续点进那个执行方法

 

我们看下handler对象,它是Statement对象的处理器,看看它有哪些属性,如下

 

 

 我们可以看到,里面有一条完整的可执行语句,我猜下面就是jdbc操作了,点进去看下

 

 

 真是失望,看源码就是封装的太多了,看着看着就晕了,继续点进去看

 

 

 

 终于看到PreparedStatement预编译对象了,

我们可以看下返回rows那行代码,点进去发现如下

 

执行了ClientPreparedStatement对象的方法,这个对象好像没见过

别着急,我们在idea内点击右键,选择 Diagrams,查看类的继承关系图

 

 

 好了,我们知道这个对象本质也是PreparedStatement对象,在那个方法里返回了受影响的行数,其他的目前不必深究

 

 

 到这里我们就要结束了,最后看下这个commit方法吧,点进去

 注意,这里有个dirty属性为true,我猜是脏数据,不会写入数据库,我们让他继续执行

 

 

 

 变成false了,哈哈,现在不是脏数据了,肯定可以写入数据库了.最后看下数据库

 

 

 ,这些数据是我debug好几次写入的数据,不管它们,我们把commit方法注释掉,再执行一次

 

我们把注释放开,继续执行一次

 

所以insert语句要commit,手动执行提交事件,将数据提交到数据库中,才真正成功插入到数据库中,否则会回滚,数据库看不到数据
好了,这篇文章到这里就结束了.谢谢大家的观看,大家有空的话就帮我点个赞吧
文章中若有错误和疏漏之处,还请各位大佬不吝指出
若要下载我的源代码和注释,这里是我的GitHub地址:https://github.com/lusaisai1019/mybatis-master


发布评论

分享到:

IT源码网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

(1)复习jdbc操作,编译mybatis源码,准备为你的简历加分吧讲解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。