Mybatis源码解读

最新推荐文章于 2024-07-31 16:08:46 发布
最新推荐文章于 2024-07-31 16:08:46 发布
阅读量513 收藏
点赞数
文章标签： Mybatis源码解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37817685/article/details/78329098
版权

一：先看下面一个简单的mybatis的程序

package com.hanwei;

import org.junit.Before;

import com.hanwei.dao.Istudent;
import com.hanwei.dao.impl.IstudentImpl;
import com.hanwei.pojo.Student;

public class Test {
	
	private Istudent student;
	private Student stu;

	@Before
	public void before() {
		student = new IstudentImpl();
		stu = new Student();
		//test();
	}
	
	@org.junit.Test
	public void test() {
		
		stu.setGrade("一年级");
		stu.setName("2111");
		stu.setSex("男");
		stu.setAge("7");
		
		//插入一个对象
		student.insert(stu);
		student.insertgetUserIDcatche(stu);
		
		//插入一个变量
		student.insertoneparame("7");
		
	}
	
	
	/*public  static void main(String args[]) {
		new Test().before();
	}
	*/
	
}





package com.hanwei.dao;

import com.hanwei.pojo.Student;

public interface Istudent {
  
	 public void insert(Student student);//插入
}


package com.hanwei.dao.impl;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.hanwei.dao.Istudent;
import com.hanwei.pojo.Student;

public class IstudentImpl implements Istudent{

	@Override
	public void insert(Student stu) {
		// TODO Auto-generated method stub
		SqlSession sqlSession=null;
		InputStream inputStream=null;
		try {
			//创建主配置文件
			inputStream = Resources.getResourceAsStream("mybatis.xml");
			//创建sqlSessionFactory对象  这里的build方法已经把inputStream关闭了，所以后面不需要再关闭一次
			SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
			//创建sqlsession对象
			sqlSession=sqlSessionFactory.openSession();
			
			System.out.println(sqlSession);
			//sqlSession.insert("student", stu);
			sqlSession.insert("student", stu);
			//最终事务提交  
			sqlSession.commit();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			/*
			 * 
			*/  //事务关闭    事务提交后就不用回滚  否则回滚数据不会写到数据库
			if(sqlSession!=null) {
				sqlSession.close();
			}
		}
		
		
		
	}
	
	
	
	@Override
	public void insertgetUserIDcatche(Student student) {//插入并且获取刚插入的id
		
		
		// TODO Auto-generated method stub
				SqlSession sqlSession=null;
				InputStream inputStream=null;
				try {
					//创建主配置文件
					inputStream = Resources.getResourceAsStream("mybatis.xml");
					//创建sqlSessionFactory对象  这里的build方法已经把inputStream关闭了，所以后面不需要再关闭一次
					SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
					//创建sqlsession对象
					sqlSession=sqlSessionFactory.openSession();
					
					System.out.println(sqlSession);
					//sqlSession.insert("student", stu);
					System.out.println("插入前学生信息"+student.getId());
					
					sqlSession.insert("getUserinsertIDcatche", student);
					
					
					//最终事务提交  
					sqlSession.commit();
					
					System.out.println("插入后学生信息"+student.getId());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					/*
					 * 
					*/  //事务关闭    事务提交后就不用回滚  否则回滚数据不会写到数据库
					if(sqlSession!=null) {
						sqlSession.close();
					}
				}
				
		
	}



	@Override
	public void insertoneparame(String studentage) {//只给谋列插入单个值
		// TODO Auto-generated method stub
		// TODO Auto-generated method stub
		SqlSession sqlSession=null;
		InputStream inputStream=null;
		try {
			//创建主配置文件
			inputStream = Resources.getResourceAsStream("mybatis.xml");
			//创建sqlSessionFactory对象  这里的build方法已经把inputStream关闭了，所以后面不需要再关闭一次
			SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
			//创建sqlsession对象
			sqlSession=sqlSessionFactory.openSession();
			
			System.out.println(sqlSession);
			//sqlSession.insert("student", stu);
			//System.out.println("插入前学生信息"+student.getId());
			
			sqlSession.insert("student", studentage);
			
			
			//最终事务提交  
			sqlSession.commit();
			
			//System.out.println("插入后学生信息"+student.getId());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			/*
			 * 
			*/  //事务关闭    事务提交后就不用回滚  否则回滚数据不会写到数据库
			if(sqlSession!=null) {
				sqlSession.close();
			}
		}
		
	}
	

}





mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration 
PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- ?代表只能小于等于1个 -->
<configuration>


        <!-- 引进数据库变量配置文件 -->
        <properties resource="jdbc.properties"/> 
         
         <!-- 简化mapper文件中很长的实体类名位置parameterType   alias别名-->
         <typeAliases>
            <typeAlias type="com.hanwei.pojo.Student" alias="xxx"/>
         </typeAliases>
         
         
<!-- 可以来选择用什么数据库环境，本地还是服务器或者MySQL还是Oracle -->
     <environments default="mysqlEM">
       
           <!-- 大于等于0个 -->
         <environment  id="mysqlEM">
         <!--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>     
         <!-- 注册映射文件    也可以url="指向硬盘物理路径"-->
         
            <mappers>
               <mapper  resource="com/hanwei/dao/mapper/studentmapper.xml"/>
            </mappers>
     
    
</configuration>



mapper.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="xxx">

  <insert id="student" parameterType="xxx">
  insert into T_student (name,age,grade,sex) values(#{name}, #{age},#{grade},#{sex}) 
 </insert>
  
 <!--这里的#{}只是一个占位符  里面可以包含任何值-->
  <insert id="insertoneparame" parameterType="xxx">
  insert into T_student (age) values(#{zzzzz}) 
 </insert>

 <insert id="getUserinsertIDcatche" parameterType="xxx">
  insert into T_student (name,age,grade,sex) values(#{name}, #{age},#{grade},#{sex}) 
    <selectKey resultType="int" keyProperty="id" order="AFTER">
       select @@identity
    </selectKey>
       
 </insert>
 
</mapper>



log4j.properties 

#
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.Target=System.out 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=[%-5p][%d{yyyy-MM-dd HH:mm:ss}] %c %L %m%n  
  

log4j.rootLogger=debug,stdout

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test
jdbc.username=root
jdbc.password=123456




1.问题一发现IstudentImpl没有对inputstream输入流进行关闭

最终源码发现

//创建sqlSessionFactory对象  这里的build方法已经把inputStream关闭了，所以后面不需要再关闭一次
SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);


2.当我们去掉sqlSession.commit();会出现

 [DEBUG][2017-10-24 14:23:41] com.hanwei.pojo.Student.student 49 <==    Updates: 1
  [DEBUG][2017-10-24 14:23:41] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Rolling back JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:23:41] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:23:41] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:23:41] org.apache.ibatis.datasource.pooled.PooledDataSource 49 Returned connection 120694604 to pool.
  
  不难发现jdbc.JdbcTransaction 49 Rolling back JDBC Connection 事务回滚，再回到数据库查看发现没有数据插入？？？？/

这是为什么呢？


追踪方法源码

sqlSession=sqlSessionFactory.openSession();


public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

//autoCommit=false

 private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType, autoCommit);
      return new DefaultSqlSession(configuration, executor);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

//dirty=false

 public DefaultSqlSession(Configuration configuration, Executor executor) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
  }



sqlSession.insert("student", stu);


public int insert(String statement, Object parameter) {
    return update(statement, parameter);
  }


      

 public int update(String statement, Object parameter) {
    try {
      dirty = true;
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }



 dirty = true;

（1）当我们关闭sqlSession.commit();


追踪方法close()

isCommitOrRollbackRequired(false)//返回true


 public void close() {
    try {
      executor.close(isCommitOrRollbackRequired(false));
      dirty = false;
    } finally {
      ErrorContext.instance().reset();
    }
  }

 private boolean isCommitOrRollbackRequired(boolean force) {
    return dirty || force;
  }

 forceRollback=true

 public void close(boolean forceRollback) {
    try {
      try {
        rollback(forceRollback);
      } finally {
        if (transaction != null) transaction.close();
      }
    } catch (SQLException e) {
      // Ignore.  There's nothing that can be done at this point.
      log.debug("Unexpected exception on closing transaction.  Cause: " + e);
    } finally {
      transaction = null;
      deferredLoads = null;
      localCache = null;
      localOutputParameterCache = null;
      closed = true;
    }
  }

//required=true

 public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }


 public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }


 public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }


 

（2）当我们打开sqlSession.commit();

//  dirty = true;

 public void commit() {
    commit(false);
  }


 public void commit(boolean force) {
    try {
      executor.commit(isCommitOrRollbackRequired(force));
      dirty = false;
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }


 private boolean isCommitOrRollbackRequired(boolean force) {
    return dirty || force;
  }


 public void commit(boolean required) throws SQLException {
    if (closed) throw new ExecutorException("Cannot commit, transaction is already closed");
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();//事务提交
    }
  }


//dirty = false;

public void close() {
    try {
      executor.close(isCommitOrRollbackRequired(false));
      dirty = false;
    } finally {
      ErrorContext.instance().reset();
    }
  }

 private boolean isCommitOrRollbackRequired(boolean force) {
    return dirty || force;  //false
  }

 forceRollback=true

 public void close(boolean forceRollback) {//false
    try {
      try {
        rollback(forceRollback);//false
      } finally {
        if (transaction != null) transaction.close();
      }
    } catch (SQLException e) {
      // Ignore.  There's nothing that can be done at this point.
      log.debug("Unexpected exception on closing transaction.  Cause: " + e);
    } finally {
      transaction = null;
      deferredLoads = null;
      localCache = null;
      localOutputParameterCache = null;
      closed = true;
    }
  }


 public void rollback(boolean required) throws SQLException {//false
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {//false  不会事务回滚
          transaction.rollback();
        }
      }
    }
  }


 


这就解释了为什么打开屏蔽的提交代码会出现事务提交并且数据库有数据，但是自增长id不是加1变成了加2，并且也会提交事务。

 [DEBUG][2017-10-24 14:41:33] com.hanwei.pojo.Student.student 49 <==    Updates: 1
  [DEBUG][2017-10-24 14:41:33] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Committing JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:41:33] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:41:33] org.apache.ibatis.transaction.jdbc.JdbcTransaction 49 Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@731a74c]
  [DEBUG][2017-10-24 14:41:33] org.apache.ibatis.datasource.pooled.PooledDataSource 49 Returned connection 120694604 to pool.
  




另一个绝影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1.MyBatis源码解读——项目层次结构
零零天
05-14 1259
MyBatis主要包含的核心部件 SqlSession : Mybatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能。这是MyBatis主要的一个类，用来执行SQL，获取映射器，管理事务。通常情况下，在程序中使用的Mybatis的API就是这个接口定义的方法。 Executor: Mybatis执行器，是Mybatis调度的核心，负责SQL语句的生成和查询缓存的维护...
MyBatis源码解析
justimkiss的专栏
11-06 375
MyBatis源码解析1. MyBatis主要核心部件： Configuration 包含MyBatis所有的配置信息，除此之外还负责穿件一些MyBatis内部使用对象；如：Executor等； SqlSession 与数据库交互的会话，MyBatis顶层API，完成增删改查功能；如：selectOne、selectList、update、delete等方法；
【Mybatis】Mybatis源码解读
keeper42的博客
04-22 840
一、Mybatis框架图 牢记上面的图。Mybatis框架大致分三层：基础支持层，数据处理层和接口层。 基础支持层包括连接池管理、事务管理和缓存机制等。 数据处理层则包括：参数映射（ParameterHandler）、SQL解析（SqlSource）、SQL执行（Executor）、结果处理映射（ResultSetHandler）。 这是一个流程。 最后是上层接口层，提供给外部调用的。 二、Mybatis的初始化流程 Mybatis初始化流程包括：构造会话工厂->解析配置->解析mapper
【Mybatis】源码分析-深入源码
最新发布
下半夜的风
07-31 919
问题在开发过程中很多时候我们并不需要总是在加载⽤户信息时就⼀定要加载他的订单信息。此时就是我们所说的延迟加载。在⼀对多中，当我们有⼀个⽤户，它有个100个订单。在查询⽤户的时候，要不要把关联的订单查出来？在查询订单的时候，要不要把关联的⽤户查出来？在查询⽤户时，⽤户下的订单应该是，什么时候⽤，什么时候查询。在查询订单时，订单所属的⽤户信息应该是随着订单⼀起查询出来。就是在需要⽤到数据时才进⾏加载，不需要⽤到数据时就不加载数据。延迟加载也称懒加载。
mybatis源码解读
shrek11的专栏
12-23 804
mybatis基本上都在用，我们来了解它的源码和实现 我看Mybatis源码的经验分享给大家，大家可以参考， 1，我们首先把源码下载，https://github.com/tuguangquan/mybatis 这个是他人做了中文注释的源码，下载到本地。 2，导入mybatis-parent模块，快速入口 3，pom中有个PDF的插件引用去掉，这样，mybatis源码环境就可以了 ...
Mybatis源码解析
qzw2609641245的博客
08-05 185
学习Mybatis源码之前，我们先了解下Mybatis是什么？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 Mybatis框架主要由以下四段代码为主，下来我们来看一下: InputStream
mybatis源码解读：cache包（缓存机制功能）
wdjnb的博客
02-10 871
mybatis源码解读：cache包（缓存机制功能） 1.缓存机制 在进行源码阅读时，通常可以以包为单位进行，因为包本身就是具有一定结构、功能的类的集合，但是，也总会有一些功能相对复杂，会横跨多个包。因此以功能为主线一次阅读多个包中的源码是必要的，能帮助我们理清功能实现。 mybatis基于cache包中提供的缓存实现了两级缓存机制。 1.一级缓存 mybatis的一级缓存又叫本地缓存，与它相关的配置项有2个。 1.在配置文件XML的setting节点,可选项有session与statement
mybatis源码解读：cursor包
灰太狼
12-20 3153
欢迎关注本人公众号： 1.游标的使用 ​ 在使用mybatis进行数据库查询时，经常会查询到大量的结果。游标可以解决处理大量数据时不是一次读入整个结果集，而是逐一读入和处理结果，这样可以减少对内存的占用。 在mybatis中使用游标进行查询非常简单，映射文件不需要任何的变动，只需要在映射接口中标明返回值类型是Cursor。 Cursor<User> selectAll(); 2.游标接口 cursor包中源码非常简单，只有一个cursor接口和默认的实现类Defa..
MyBatis源码解读：解剖MyBatis的会话管理
MyBatis概述和会话管理的重要性 ## 1.1 MyBatis框架简介 MyBatis是一种开源的持久层框架，它将数据库操作与Java对象之间的映射关系进行了完美的解耦，提供了简单易用的方式来管理和执行SQL语句。MyBatis支持各种...
Mybatis之源码剖析
qq_37589292的博客
04-15 181
Mybatis源码剖析 1、传统方式源码剖析 源码剖析-初始化 InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); // 初始化工作的开始 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream); 进入源码剖析： // 1. 最初调用的build public SqlSessionFactory bui
mybatis源码解析
weixin_43189971的博客
06-22 3573
mybatis底层代码分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值