15792人阅读
前面的章节主要讲mybatis如何解析配置文件，这些都是一次性的过程。从本章开始讲解动态的过程，它们跟应用程序对mybatis的调用密切相关。本章先从sqlsession开始。
正如其名，Sqlsession对应着一次数据库会话。由于数据库回话不是永久的，因此Sqlsession的生命周期也不应该是永久的，相反，在你每次访问数据库时都需要创建它（当然并不是说在Sqlsession里只能执行一次sql，你可以执行多次，当一旦关闭了Sqlsession就需要重新创建它）。创建Sqlsession的地方只有一个，那就是SqlsessionFactory的openSession方法：
public SqlSessionopenSession() {
returnopenSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);
我们可以看到实际创建SqlSession的地方是openSessionFromDataSource，如下：
private SqlSessionopenSessionFromDataSource(ExecutorType execType, TransactionIsolationLevellevel, boolean autoCommit) {
Connectionconnection =
finalEnvironment environment = configuration.getEnvironment();
final DataSourcedataSource = getDataSourceFromEnvironment(environment);
TransactionFactory transactionFactory =getTransactionFactoryFromEnvironment(environment);
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
connection = wrapConnection(connection);
Transaction tx = transactionFactory.newTransaction(connection,autoCommit);
Executorexecutor = configuration.newExecutor(tx, execType);
returnnewDefaultSqlSession(configuration, executor, autoCommit);
} catch (Exceptione) {
closeConnection(connection);
throwExceptionFactory.wrapException(&Error opening session.
Cause: & + e, e);
} finally {
ErrorContext.instance().reset();
可以看出，创建sqlsession经过了以下几个主要步骤：
1)&&&&&&&从配置中获取Environment；
2)&&&&&&&从Environment中取得DataSource；
3)&&&&&&&从Environment中取得TransactionFactory；
4)&&&&&&&从DataSource里获取数据库连接对象Connection；
5)&&&&&&&在取得的数据库连接上创建事务对象Transaction；
6)&&&&&&&创建Executor对象（该对象非常重要，事实上sqlsession的所有操作都是通过它完成的）；
7)&&&&&&&创建sqlsession对象。
Executor的创建
Executor与Sqlsession的关系就像市长与书记，Sqlsession只是个门面，真正干事的是Executor，Sqlsession对数据库的操作都是通过Executor来完成的。与Sqlsession一样，Executor也是动态创建的：
public ExecutornewExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType :executorT
executorType = executorType == null ?ExecutorType.SIMPLE : executorT
if(ExecutorType.BATCH == executorType) {
executor = new BatchExecutor(this,transaction);
} elseif(ExecutorType.REUSE == executorType) {
executor = new ReuseExecutor(this,transaction);
executor = newSimpleExecutor(this, transaction);
if (cacheEnabled) {
executor = new CachingExecutor(executor);
executor =(Executor) interceptorChain.pluginAll(executor);
可以看出，如果不开启cache的话，创建的Executor只是3中基础类型之一，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。开启cache的话（默认是开启的并且没有任何理由去关闭它），就会创建CachingExecutor，它以前面创建的Executor作为唯一参数。CachingExecutor在查询数据库前先查找缓存，若没找到的话调用delegate（就是构造时传入的Executor对象）从数据库查询，并将查询结果存入缓存中。
Executor对象是可以被插件拦截的，如果定义了针对Executor类型的插件，最终生成的Executor对象是被各个插件插入后的代理对象（关于插件会有后续章节专门介绍，敬请期待）。
Mybatis官方手册建议通过mapper对象访问mybatis，因为使用mapper看起来更优雅，就像下面这样：
session = sqlSessionFactory.openSession();
UserDao userDao= session.getMapper(UserDao.class);
UserDto user =new UserDto();
user.setUsername(&iMbatis&);
user.setPassword(&iMbatis&);
userDao.insertUser(user);
那么这个mapper到底是什么呢，它是如何创建的呢，它又是怎么与sqlsession等关联起来的呢？下面为你一一解答。
表面上看mapper是在sqlsession里创建的，但实际创建它的地方是MapperRegistry：
public &T&T getMapper(Class&T& type, SqlSession sqlSession) {
if (!knownMappers.contains(type))
thrownewBindingException(&Type & + type + & isnot known to the MapperRegistry.&);
returnMapperProxy.newMapperProxy(type, sqlSession);
} catch (Exceptione) {
thrownewBindingException(&Error getting mapper instance. Cause: & + e, e);
可以看到，mapper是一个代理对象，它实现的接口就是传入的type，这就是为什么mapper对象可以通过接口直接访问。同时还可以看到，创建mapper代理对象时传入了sqlsession对象，这样就把sqlsession也关联起来了。我们进一步看看MapperProxy.newMapperProxy(type,sqlSession);背后发生了什么事情：
publicstatic &T&T newMapperProxy(Class&T& mapperInterface, SqlSession sqlSession) {
ClassLoaderclassLoader = mapperInterface.getClassLoader();
Class&?&[] interfaces = new Class[]{mapperInterface};
MapperProxyproxy = new MapperProxy(sqlSession);
return (T) Proxy.newProxyInstance(classLoader,interfaces, proxy);
看起来没什么特别的，和其他代理类的创建一样，我们重点关注一下MapperProxy的invoke方法
MapperProxy的invoke
我们知道对被代理对象的方法的访问都会落实到代理者的invoke上来，MapperProxy的invoke如下：
public Objectinvoke(Object proxy, Method method, Object[] args) throws Throwable{
if (method.getDeclaringClass()== Object.class) {
return method.invoke(this, args);
finalClass&?& declaringInterface = findDeclaringInterface(proxy, method);
finalMapperMethod mapperMethod = newMapperMethod(declaringInterface, method, sqlSession);
final Objectresult = mapperMethod.execute(args);
if (result ==null && method.getReturnType().isPrimitive()&& !method.getReturnType().equals(Void.TYPE)) {
thrownewBindingException(&Mapper method '& + method.getName() + &'(& + method.getDeclaringClass()
+ &) attempted toreturn null from a method with a primitive return type (&
+ method.getReturnType() + &).&);
可以看到invoke把执行权转交给了MapperMethod，我们来看看MapperMethod里又是怎么运作的：
public Objectexecute(Object[] args) {
Objectresult =
if(SqlCommandType.INSERT == type) {
Objectparam = getParam(args);
result= sqlSession.insert(commandName, param);
} elseif(SqlCommandType.UPDATE == type) {
Object param = getParam(args);
result= sqlSession.update(commandName, param);
} elseif(SqlCommandType.DELETE == type) {
Objectparam = getParam(args);
result= sqlSession.delete(commandName, param);
} elseif(SqlCommandType.SELECT == type) {
if (returnsVoid &&resultHandlerIndex != null) {
executeWithResultHandler(args);
} elseif (returnsList) {
result = executeForList(args);
} elseif (returnsMap) {
result = executeForMap(args);
Object param = getParam(args);
result = sqlSession.selectOne(commandName, param);
thrownewBindingException(&Unknown execution method for: & + commandName);
可以看到，MapperMethod就像是一个分发者，他根据参数和返回值类型选择不同的sqlsession方法来执行。这样mapper对象与sqlsession就真正的关联起来了。
前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问最终都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经介绍了，下面介绍下他们的功能：
CacheExecutor
CacheExecutor有一个重要属性delegate，它保存的是某类普通的Executor，值在构照时传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先尝试从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。代码如下：
public Listquery(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {
if (ms != null) {
Cachecache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
cache.getReadWriteLock().readLock().lock();
if (ms.isUseCache() && resultHandler ==null) {
CacheKey key = createCacheKey(ms, parameterObject, rowBounds);
final List cachedList = (List)cache.getObject(key);
if (cachedList != null) {
returncachedL
List list = delegate.query(ms,parameterObject, rowBounds, resultHandler);
tcm.putObject(cache,key, list);
returndelegate.query(ms,parameterObject, rowBounds, resultHandler);
} finally {
cache.getReadWriteLock().readLock().unlock();
returndelegate.query(ms,parameterObject, rowBounds, resultHandler);
普通Executor
普通Executor有3类，他们都继承于BaseExecutor，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。下面以SimpleExecutor为例：
public ListdoQuery(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {
Statementstmt =
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms,parameter, rowBounds,resultHandler);
stmt =prepareStatement(handler);
returnhandler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
可以看出，Executor本质上也是个甩手掌柜，具体的事情原来是StatementHandler来完成的。
StatementHandler
当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的。
publicStatementHandler newStatementHandler(Executor executor, MappedStatementmappedStatement,
ObjectparameterObject, RowBounds rowBounds, ResultHandler resultHandler) {
StatementHandler statementHandler = newRoutingStatementHandler(executor, mappedStatement,parameterObject,rowBounds, resultHandler);
statementHandler= (StatementHandler) interceptorChain.pluginAll(statementHandler);
returnstatementH
可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper配置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要注意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。由于mybatis没有实现数据库的物理分页，众多物理分页的实现都是在这个地方使用拦截器实现的，本文作者也实现了一个分页拦截器，在后续的章节会分享给大家，敬请期待。
StatementHandler创建后需要执行一些初始操作，比如statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：
private StatementprepareStatement(StatementHandler handler) throwsSQLException {
Connectionconnection = transaction.getConnection();
stmt =handler.prepare(connection);
handler.parameterize(stmt);
statement的开启和参数设置没什么特别的地方，handler.parameterize倒是可以看看是怎么回事。handler.parameterize通过调用ParameterHandler的setParameters完成参数的设置，ParameterHandler随着StatementHandler的创建而创建，默认的实现是DefaultParameterHandler：
publicParameterHandler newParameterHandler(MappedStatement mappedStatement, ObjectparameterObject, BoundSql boundSql) {
ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement,parameterObject,boundSql);
parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
returnparameterH
同Executor和StatementHandler一样，ParameterHandler也是可以被拦截的。
DefaultParameterHandler里设置参数的代码如下：
publicvoidsetParameters(PreparedStatement ps) throwsSQLException {
ErrorContext.instance().activity(&settingparameters&).object(mappedStatement.getParameterMap().getId());
List&ParameterMapping& parameterMappings = boundSql.getParameterMappings();
if(parameterMappings != null) {
MetaObject metaObject = parameterObject == null ? null :configuration.newMetaObject(parameterObject);
for (int i = 0; i& parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if(parameterMapping.getMode() != ParameterMode.OUT) {
String propertyName = parameterMapping.getProperty();
PropertyTokenizer prop = newPropertyTokenizer(propertyName);
if (parameterObject == null) {
} elseif (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){
value = parameterO
} elseif (boundSql.hasAdditionalParameter(propertyName)){
value = boundSql.getAdditionalParameter(propertyName);
} elseif(propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)
&& boundSql.hasAdditionalParameter(prop.getName())){
value = boundSql.getAdditionalParameter(prop.getName());
if (value != null) {
value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));
value = metaObject == null ? null :metaObject.getValue(propertyName);
TypeHandler typeHandler = parameterMapping.getTypeHandler();
if (typeHandler == null) {
thrownew ExecutorException(&Therewas no TypeHandler found for parameter & + propertyName
+ & of statement & + mappedStatement.getId());
typeHandler.setParameter(ps, i + 1, value,parameterMapping.getJdbcType());
这里面最重要的一句其实就是最后一句代码，它的作用是用合适的TypeHandler完成参数的设置。那么什么是合适的TypeHandler呢，它又是如何决断出来的呢？BaseStatementHandler的构造方法里有这么一句：
this.boundSql= mappedStatement.getBoundSql(parameterObject);
它触发了sql 的解析，在解析sql的过程中，TypeHandler也被决断出来了，决断的原则就是根据参数的类型和参数对应的JDBC类型决定使用哪个TypeHandler。比如：参数类型是String的话就用StringTypeHandler，参数类型是整数的话就用IntegerTypeHandler等。
参数设置完毕后，执行数据库操作（update或query）。如果是query最后还有个查询结果的处理过程。
结果处理使用ResultSetHandler来完成，默认的ResultSetHandler是FastResultSetHandler，它在创建StatementHandler时一起创建，代码如下：
publicResultSetHandler newResultSetHandler(Executor executor, MappedStatementmappedStatement,
RowBoundsrowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSqlboundSql) {
ResultSetHandler resultSetHandler =mappedStatement.hasNestedResultMaps() ? newNestedResultSetHandler(executor, mappedStatement, parameterHandler,resultHandler, boundSql, rowBounds): new FastResultSetHandler(executor,mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
returnresultSetH
可以看出ResultSetHandler也是可以被拦截的，可以编写自己的拦截器改变ResultSetHandler的默认行为。
ResultSetHandler内部一条记录一条记录的处理，在处理每条记录的每一列时会调用TypeHandler转换结果，如下：
protectedbooleanapplyAutomaticMappings(ResultSet rs, List&String& unmappedColumnNames,MetaObject metaObject) throws SQLException {
booleanfoundValues =
for (StringcolumnName : unmappedColumnNames) {
final Stringproperty = metaObject.findProperty(columnName);
if (property!= null) {
final ClasspropertyType =metaObject.getSetterType(property);
if (typeHandlerRegistry.hasTypeHandler(propertyType)) {
final TypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(propertyType);
final Object value = typeHandler.getResult(rs,columnName);
if (value != null) {
metaObject.setValue(property, value);
foundValues =
returnfoundV
从代码里可以看到，决断TypeHandler使用的是结果参数的属性类型。因此我们在定义作为结果的对象的属性时一定要考虑与数据库字段类型的兼容性。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：112514次
积分：1244
积分：1244
排名：第15596名
原创：11篇
评论：81条
(1)(1)(4)(4)(1)(1)&&&&& 钢铁侠里面的那个机械臂和人工智能辅助系统肯定是基本配置
&&&& 3D打印系统(快速制造系统)
&&&&& 数字信息检索系统(数据库中包含海量的数字图书和期刊资料,保证可以随时查询出需要的知识和参数)
& & & 可以连接卫星系统的网络设备
& & & 太阳能发电装置和不依赖外界供给的能源储备系统 &&
&&&&& 高性能服务器和工作计算机，大容量存储系统
&&&&& 两三个人在工作室里面工作，其中一个人负责软件和模型设计工程，一个人复杂硬件和能源模块，其它事情交给机械臂和3D打印系统，最多再有一个负责采购和销售的人，这样的小工作室可以成为一个小型的带设计能力的设备生产企业或者可以说一种新型的小作坊。。。只不过这个作坊生产的是某些技术含量比较高的玩意。。比如说机器人和无人机。。。。这样的工作室甚至可以成为大型生产企业的合作伙伴。。。通过基于互联网的流程来进行大规模的生产协作。。。其经营和维护成本会相当的低廉。。。。
&&&&& 可以保证，这种工作室现在已经出现了，只不过在10年左右的时间内，会在很多地区普及开。。。。小型化，智能化，低成本的生产单元成为未来社会生产系统的重要组成部分
&&&& 实际上，3D打印机就是一台3维数控机床，一个私人工作室装备若干台这种打印机，完全可以形成一个微型的生产线。。。看3D打印的塑料瓶
&&&& .cn/slide/375/.html
&&&& 中关村在线的视频 3D打印的龙头
&&&& .cn/327/3273090.html
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：70046次
积分：1789
积分：1789
排名：第9825名
原创：82篇
评论：53条
comsci是我的网名，这个名字来源于computer scientist(计算机科学家)这两个单词的前三个字母的组合444 - 博客频道 - CSDN.NET
http://blog.csdn.net/levery/article/details/6469089
该博客违反了网站规则被关闭，请与管理员联系 Email：}