本文是作者原创,版权归作者所有.若要转载,请注明出处.本文以简单的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
												


																

最新文章
	

    
						
  1. SQL Server 2012 Managed Service Account
		
    2. 
						
  2. MySQL数据库安装与配置详解
		
    3. 
						
  3. C# 中的 == 和 equals()有什么区别？
		
    4. 
						
  4. python中关于正则表达式四
		
    5. 
						
  5. PHP-traits新特性详解
		
    6. 
						
  6. Content-Disposition的使用方法
		
    7. 
						
  7. ISAPI_Rewrite 3  伪静态软件
		
    8. 
						
  8. 《玩转Bootstrap（基础）》笔记
		
    9. 
						
  9. SQL数据库文件修复/用友/金蝶/管家婆/速达/思讯数据库恢复 硬盘恢复
		
    10. 
						
  10. 如何动态修改网页的标题（title）？
		
    11. 
						
  11. 令状态寄存器访问指令（MRS,MSR）
		
    12. 
						
  12. The First of my text
		
    13. 
						
  13. 【CSS Demo】网站页面变灰
		
    14. 
						
  14. 20165321 实验三 敏捷开发与XP实践
		
    15. 
						
  15. linux平台的oracle11201借用expdp定时备份数据库
		
    16. 
						
  16. 用Executors工具类创建线程池
		
    17. 
						
  17. 牛客练习赛16 E - 求值
		
    18. 
						
  18. es6编写generator报错
		
    19. 
						
  19. 替换res\drawable中的图片
		
    20. 
						
  20. TCP之三：TCP/IP协议中backlog参数（队列参数）
		
    21. 
		

	


热门文章
	

    
									
  1. linux系统破解密码。
			
    2. 
						
  2. sql server 怎么查看blocked的线程
			
    3. 
						
  3. windows和linux下的本机IP的获取(亲测有效)
			
    4. 
						
  4. oauth2.0授权详解
			
    5. 
						
  5. java中的case里嵌套if条件句；   输入一个年份的某一个月份，判断这个月有多少天
			
    6. 
						
  6. Codeforces 975C
			
    7. 
						
  7. JDBC之PreparedStatement
			
    8. 
						
  8. Jenkins教程——从安装到部署Docker服务（二）声明式流水线HelloWorld
			
    9. 
						
  9. coco标注信息与labelme标注信息的详解、相互转换及可视化
			
    10. 
						
  10. Constructing Roads  HDU 1102
			
    11.