mybatis源码手写_Mybatis源码

文章目录：

• 1、Java架构的路上必学知识点，你又知道多少
• 2、实际开发mybatis都是使用自动生成的sql么
• 3、什么是mybatis？
• 4、springmvc spring mybatis 框架搭建的MAVEN项目，怎么加密解密啊，有源码吗？
• 5、怎么没有mybatis源码解析相关的文档
• 6、初看Mybatis 源码 SQL是怎么执行的

Java架构的路上必学知识点，你又知道多少

Jenkins多套环境（test/pre/production）系统自动化发布

Jenkins自动发布到远程主机

MavenMaven私服搭建setting.xml文件剖析pom.xml详解Maven实用插件教学（静态代码检查、生成可执行jar包）profile使用

源码分析

源码分析 Spring源码分析

Spring IOC的实现原理Spring BeanFactory源码分析Spring AOP的实现原理及配置文件详解Spring AOP的各种应用场景分析Spring MVC与Struts对比Spring HandlerMapping详解手写实现SpringMVC框架Spring与各种框架集成原理Spring JDBC操作原理基于Spring JDBC手写ORM框架

MyBatis源码分析

MyBatis3简介MyBatis3 SqlMap那些事儿数据库连接池到底是什么MyBatis3 SessionFactory实现原理MyBatis3 配置文件详解MyBatis3 事务管理与集成浅谈HibernateMyBatis3与Hibernate框架对比Netty源码分析

NIO通信原理剖析深入了解NIO缓冲区Buffer

NIO Selector原理AIO编程Netty产生的背景以及基础入门

Netty高性能之道Netty的HTTP与Socket通信原理利用Netty搭建高性能的

WebSocket聊天室

Netty聊天室客户端架构实现Netty的编码解码

Netty的拆包粘包操作MsgPack原理讲解及各种序列化框架对比MsgPack与Netty整合

Netty HTTP通信与Spring整合Netty RPC架构Netty与各种架构整合以及Netty源码分析

性能调优

性能调优 JVMJVM内存模型JVM运行时数据区垃圾回收机制GC日志详解

根据GC日志调优系统，调优不靠碰运气！Mysql数据库优化

数据库底层数据结构索引数据存储结构 innodb详解SQL调优及原理分库、分表实现Nginx调优动静资源分离

nginx参数详解nginx + lua使用应用：ip过滤，扛DDOSTomcat调优

Tomcat源码、架构分析Tomcat具体调优参数设置Tomcat压力基准测试Tomcat NIO配置

实际开发mybatis都是使用自动生成的sql么

以前没怎么用过mybatis，只知道与hibernate一样是个orm数据库框架。随着使用熟练度的增加，发现它与hibernate区别是非常大的，结合至今为止的经验，总结出以下几点：

1. hibernate是全自动，而mybatis是半自动。

hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。

2. hibernate数据库移植性远大于mybatis。

hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（oracle、MySQL等）的耦合性，而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。

3. hibernate拥有完整的日志系统，mybatis则欠缺一些。

hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；而mybatis则除了基本记录功能外，功能薄弱很多。

4. mybatis相比hibernate需要关心很多细节

hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。

什么是mybatis？

MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。MyBatis 摒除了大部分的JDBC代码、手工设置参数和结果集重获。MyBatis 只使用简单的XML 和注解来配置和映射基本数据类型、Map 接口和POJO 到数据库记录。相对Hibernate和Apache OJB等“一站式”ORM解决方案而言，Mybatis 是一种“半自动化”的ORM实现。

需要使用的Jar包：mybatis-3.0.2.jar（mybatis核心包）。mybatis-spring-1.0.0.jar(与Spring结合包)。

MyBatis的前身是ibatis，但是在配置sql的语法上有明显的区别，并且spring目前的版本封装mybatis，至于mybatis-spring.jar文件也是mybatis团队复杂开发的jar包，用于和spring整合。之前ibatis的源码托管方是apache，而mybatis是google。

springmvc spring mybatis 框架搭建的MAVEN项目，怎么加密解密啊，有源码吗？

不知道你说的加密解密是指项目中对某个字段加密解密，还是 要多源码进行加密解密，如果是对某个字段加密解密，比如密码，可以自己手写一个工具类（网上也可以找到），将传过去的字符串用MD5或者sha1加密后返回的方式，需要加密就调用这个方法，如果你要对整个项目的源码加密，那应该是没办法，因为不管怎么加密运行的时候都需要转化为字节码。字节码.class都是可以反编译过来的

怎么没有mybatis源码解析相关的文档

我们还记得是这样配置sqlSessionFactory的：

[java] view plain copy

bean id="sqlSessionFactory" class="fbcc-5c86-b63e-dafc org.mybatis.spring.SqlSessionFactoryBean"

property name="dataSource" ref="dataSource" /

property name="configLocation" value="classpath:configuration.xml"/property

property name="mapperLocations" value="classpath:com/xxx/mybatis/mapper/*.xml"/

property name="typeAliasesPackage" value="com.tiantian.mybatis.model" /

/bean

这里配置了一个mapperLocations属性，它是一个表达式，sqlSessionFactory会根据这个表达式读取包com.xxx.mybaits.mapper下面的所有xml格式文件，那么具体是怎么根据这个属性来读取配置文件的呢？

答案就在SqlSessionFactoryBean类中的buildSqlSessionFactory方法中：

[java] view plain copy

if (!isEmpty(this.mapperLocations)) {

for (Resource mapperLocation : this.mapperLocations) {

if (mapperLocation == null) {

continue;

}

try {

XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),

configuration, mapperLocation.toString(), configuration.getSqlFragments());

xmlMapperBuilder.parse();

} catch (Exception e) {

throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);

} finally {

ErrorContext.instance().reset();

}

if (logger.isDebugEnabled()) {

logger.debug("Parsed mapper file: '" + mapperLocation + "'");

}

}

}

mybatis使用XMLMapperBuilder类的实例来解析mapper配置文件。

[java] view plain copy

public XMLMapperBuilder(Reader reader, Configuration configuration, String resource, MapString, XNode sqlFragments) {

this(new XPathParser(reader, true, configuration.getVariables(), new XMLMapperEntityResolver()),

configuration, resource, sqlFragments);

}

[java] view plain copy

private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, MapString, XNode sqlFragments) {

super(configuration);

this.builderAssistant = new MapperBuilderAssistant(configuration, resource);

this.parser = parser;

this.sqlFragments = sqlFragments;

this.resource = resource;

}

接着系统调用xmlMapperBuilder的parse方法解析mapper。

[java] view plain copy

public void parse() {

//如果configuration对象还没加载xml配置文件（避免重复加载，实际上是确认是否解析了mapper节点的属性及内容，

//为解析它的子节点如cache、sql、select、resultMap、parameterMap等做准备），

//则从输入流中解析mapper节点，然后再将resource的状态置为已加载

if (!configuration.isResourceLoaded(resource)) {

configurationElement(parser.evalNode("/mapper"));

configuration.addLoadedResource(resource);

bindMapperForNamespace();

}

//解析在configurationElement函数中处理resultMap时其extends属性指向的父对象还没被处理的resultMap节点

parsePendingResultMaps();

//解析在configurationElement函数中处理cache-ref时其指向的对象不存在的cache节点(如果cache-ref先于其指向的cache节点加载就会出现这种情况)

parsePendingChacheRefs();

//同上，如果cache没加载的话处理statement时也会抛出异常

parsePendingStatements();

}

mybatis解析mapper的xml文件的过程已经很明显了，接下来我们看看它是怎么解析mapper的：

[java] view plain copy

private void configurationElement(XNode context) {

try {

//获取mapper节点的namespace属性

String namespace = context.getStringAttribute("namespace");

if (namespace.equals("")) {

throw new BuilderException("Mapper's namespace cannot be empty");

}

//设置当前namespace

builderAssistant.setCurrentNamespace(namespace);

//解析mapper的cache-ref节点

cacheRefElement(context.evalNode("cache-ref"));

//解析mapper的cache节点

cacheElement(context.evalNode("cache"));

//解析mapper的parameterMap节点

parameterMapElement(context.evalNodes("/mapper/parameterMap"));

//解析mapper的resultMap节点

resultMapElements(context.evalNodes("/mapper/resultMap"));

//解析mapper的sql节点

sqlElement(context.evalNodes("/mapper/sql"));

//使用XMLStatementBuilder的对象解析mapper的select、insert、update、delete节点,

//mybaits会使用MappedStatement.Builder类build一个MappedStatement对象,

//所以mybaits中一个sql对应一个MappedStatement

buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

} catch (Exception e) {

throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);

}

}

configurationElement函数几乎解析了mapper节点下所有子节点，至此mybaits解析了mapper中的所有节点，并将其加入到了Configuration对象中提供给sqlSessionFactory对象随时使用。这里我们需要补充讲一下mybaits是怎么使用XMLStatementBuilder类的对象的parseStatementNode函数借用MapperBuilderAssistant类对象builderAssistant的addMappedStatement解析MappedStatement并将其关联到Configuration类对象的：

[java] view plain copy

public void parseStatementNode() {

//ID属性

String id = context.getStringAttribute("id");

//databaseId属性

String databaseId = context.getStringAttribute("databaseId");

if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {

return;

}

//fetchSize属性

Integer fetchSize = context.getIntAttribute("fetchSize");

//timeout属性

Integer timeout = context.getIntAttribute("timeout");

//parameterMap属性

String parameterMap = context.getStringAttribute("parameterMap");

//parameterType属性

String parameterType = context.getStringAttribute("parameterType");

Class? parameterTypeClass = resolveClass(parameterType);

//resultMap属性

String resultMap = context.getStringAttribute("resultMap");

//resultType属性

String resultType = context.getStringAttribute("resultType");

//lang属性

String lang = context.getStringAttribute("lang");

LanguageDriver langDriver = getLanguageDriver(lang);

Class? resultTypeClass = resolveClass(resultType);

//resultSetType属性

String resultSetType = context.getStringAttribute("resultSetType");

StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));

ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);

String nodeName = context.getNode().getNodeName();

SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));

//是否是select节点

boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

//flushCache属性

boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);

//useCache属性

boolean useCache = context.getBooleanAttribute("useCache", isSelect);

//resultOrdered属性

boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

// Include Fragments before parsing

XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);

includeParser.applyIncludes(context.getNode());

// Parse selectKey after includes and remove them.

processSelectKeyNodes(id, parameterTypeClass, langDriver);

// Parse the SQL (pre: selectKey and include were parsed and removed)

SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

//resultSets属性

String resultSets = context.getStringAttribute("resultSets");

//keyProperty属性

String keyProperty = context.getStringAttribute("keyProperty");

//keyColumn属性

String keyColumn = context.getStringAttribute("keyColumn");

KeyGenerator keyGenerator;

String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;

keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);

if (configuration.hasKeyGenerator(keyStatementId)) {

keyGenerator = configuration.getKeyGenerator(keyStatementId);

} else {

//useGeneratedKeys属性

keyGenerator = context.getBooleanAttribute("useGeneratedKeys",

configuration.isUseGeneratedKeys() SqlCommandType.INSERT.equals(sqlCommandType))

? new Jdbc3KeyGenerator() : new NoKeyGenerator();

}

builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,

fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,

resultSetTypeEnum, flushCache, useCache, resultOrdered,

keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);

}

由以上代码可以看出mybaits使用XPath解析mapper的配置文件后将其中的resultMap、parameterMap、cache、statement等节点使用关联的builder创建并将得到的对象关联到configuration对象中，而这个configuration对象可以从sqlSession中获取的，这就解释了我们在使用sqlSession对数据库进行操作时mybaits怎么获取到mapper并执行其中的sql语句的问题。

初看Mybatis 源码 SQL是怎么执行的

一条sql语句到底是怎么执行的？我们知道Mybatis其实是对JDBC的一个封装。假如我执行

session.update("com.mybatis.dao.AuthUserDao.updateAuthUserEmailByName", test@email.com);

语句，追踪下来，Executor、 BaseStatementHandler等等。在 SimpleExecutor 中有如下代码：

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

}

}

1. 首先获取相关配置信息，这个在初始化时，从配置文件中解析而来

2. 新建了一个handler

3. 做了执行statement之前的准备工作。看看准备了些什么，跟踪代码，最后进入了DataSource类的doGetConnection方法，该方法做如下操作：

private Connection doGetConnection(Properties properties) throws SQLException {

initializeDriver();

Connection connection = DriverManager.getConnection(url, properties);

configureConnection(connection);

return connection;

}

private synchronized void initializeDriver() throws SQLException {

if (!registeredDrivers.containsKey(driver)) {

Class? driverType;

try {

if (driverClassLoader != null) {

driverType = Class.forName(driver, true, driverClassLoader);

} else {

driverType = Resources.classForName(driver);

}

// DriverManager requires the driver to be loaded via the system ClassLoader.

//

Driver driverInstance = (Driver)driverType.newInstance();

DriverManager.registerDriver(new DriverProxy(driverInstance));

registeredDrivers.put(driver, driverInstance);

} catch (Exception e) {

throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e);

}

}

}

原来是通过prepareStatement 来执行了 我们初始化jdbc的操作。Class.forName DriverManager.getConnection. 这两步是在这里面完成的。

4. 将执行sql的部分交给handler

继续跟踪handler 可以看到SimpleStatementHandler 中。如下执行这个update语句

public int update(Statement statement)

throws SQLException {

String sql = boundSql.getSql();

Object parameterObject = boundSql.getParameterObject();

KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();

int rows;

if (keyGenerator instanceof Jdbc3KeyGenerator) {

statement.execute(sql, Statement.RETURN_GENERATED_KEYS);

rows = statement.getUpdateCount();

keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);

} else if (keyGenerator instanceof SelectKeyGenerator) {

statement.execute(sql);

rows = statement.getUpdateCount();

keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);

} else {

statement.execute(sql);

rows = statement.getUpdateCount();

}

return rows;

}

这边就完成了statement的操作，整个过程就是我们Jdbc的过程。原来真的就是对JDBC的简单封装。

其实Mybatis的整个执行过程，理解起来分为如下几个过程：

1. 加载配置文件

2. 解析配置文件，从配置文件中解析出来 datasource、mapper文件、事务配置等等。将配置信息保存在对象内

3. 调用相关语句，执行sql。在执行的方法中分别完成JDBC的一系列操作。