Mybatis学习笔记：二、Mybatis工作原理与工作流程
上一节介绍了Mybatis的开发流程，这节分析下Mybatis工作原理与工作流程
最原始的sql执行是这样的：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class TestMain {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
/*<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&autoReconnect=true"/>
<property name="username" value="root"/>
<property name="password" value="root"/>*/
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&autoReconnect=true";
Connection connection = DriverManager.getConnection(url, "root", "root");
connection.setAutoCommit(false);
PreparedStatement ps = connection.prepareStatement("insert into t_dept values(?, ?, ?)");
ps.setInt(1, 100);
ps.setString(2, "北京");
ps.setString(3, "北京");
try {
ps.executeUpdate();
connection.commit();
}
catch (Exception e) {
connection.rollback();
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
}
}
而上一节中下段代码是怎样执行的，下面分析一下
public static void main(String[] args) throws IOException {
Dept dept = new Dept();
dept.setDeptName("部门1");
dept.setLocation("北京市");
InputStream is = Resources.getResourceAsStream("Mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
SqlSession session = factory.openSession();
session.insert("insertDept", dept);
session.commit();
session.close();
}上面代码中：
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);SqlSessionFactoryBuilder对象的build方法如下：
public SqlSessionFactory build(InputStream inputStream) {
return build(inputStream, null, null);
}构造方法调用了build的重载方法，此方法如下：
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
try {
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error building SqlSession.", e);
} finally {
ErrorContext.instance().reset();
try {
inputStream.close();
} catch (IOException e) {
// Intentionally ignore. Prefer previous error.
}
}
}读取流作为参数，进入到构造方法里面，剩下两个参数是null，而XMLConfigBuilder这个类，里面包含了一个XPathParser的解析器，专门读取xml文档
public class XMLConfigBuilder extends BaseBuilder {
private boolean parsed;
private final XPathParser parser;
private String environment;
private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
public XMLConfigBuilder(Reader reader) {
this(reader, null, null);
}
...
}而build这个方法如下：
下面parsed这个值在XMLConfigBuilder构造时默认的值就为false，而parse()后把其值变为true,意思是让每个xmlconfigbuilder只使用一次，否则抛出异常。
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}而上面中，执行parseConfiguration()这个方法，对xml文件进行解析，解析结果交给configuration这个对象。这个对象存放了当前配置文件的相关信息。
而此时configuration对角获取到了，需要build方法执行这个对象：（刚才提到的build重载的方法）
return build(parser.parse());这个方法如下：
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}这个构造方法如下：
/**
* @author Clinton Begin
*/
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private final Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration = configuration;
}
...
}可以看到，这个DefaultSqlSessionFactory是SqlSessionFactory的实现类，它有这个configuration这个属性。
因此，执行完SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);后，就获得了SqlSessionFactory 这个对象。
-------------------
下面看SqlSession session = factory.openSession();是怎样创建SqlSession这个对象
@Override
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}上面的DefaultSqlSessionFactory的openSession方法如上，它执行了openSessionFromDataSource()这个方法，这个方法如下：
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);
return new DefaultSqlSession(configuration, executor, autoCommit);
} 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();
}
}configuration.getEnvironment()获取开发环境（Environment标签中的配置）
getTransactionFactoryFromEnvironment(environment);获取到了事物工厂，并创建了一个新事物，通过tx和执行器类型（execType:simple）创建了一个执行器对象，最后构造了一个默认的sqlSession,返回它（DefaultSqlSession）
public class DefaultSqlSession implements SqlSession {
private final Configuration configuration;
private final Executor executor;
private final boolean autoCommit;
private boolean dirty;
private List<Cursor<?>> cursorList;
public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
this.configuration = configuration;
this.executor = executor;
this.dirty = false;
this.autoCommit = autoCommit;
}
...
}其中dirty默认为false,autoCommit也是false.
factory.openSession();获取到的就是DefaultSqlSession对象。
此时这个对象属性如下：
---------------------------
执行sql语句session.insert("insertDept", dept);
此方法如下：
@Override
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();
}
}ms属性如下：
sqlSource中的sql存放了这个id要执行的sql语句
@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.update(stmt);
} finally {
closeStatement(stmt);
}
}stmt执行后获得：
包含了要执行的sql语句。
而handler.update如下
@Override
public int update(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
int rows = ps.getUpdateCount();
Object parameterObject = boundSql.getParameterObject();
KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
return rows;
}返回了要执行后受影响的行数rows。
------------------------------
session.commit();的调用过程如下：
@Override
public void commit() {
commit(false);
}
@Override
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 (!autoCommit && dirty) || force;
}因为force=false,autoCommit=false。这就决定了dirty如果是true则提交，为false则回滚。
提交后，又重新将dirty置为false。
这样事物提交并关闭session后，整个流程结束。
