MyBatis框架及原理分析

量子磁场测量技术在生物磁场成像领域的应用现状与产业趋势 首先对量子磁场测量技术的发展进行了简述,然后介绍了量子磁场测量技术在生物磁场成像领域的应用,最后分析了量子磁场测量技术的两大重要应用方向(心磁图仪和脑磁图仪)及其产业现状和未来发展趋势。美国普林斯顿大学在《自然》上公布了目前人类磁场测量灵敏度最高的基于量子磁场测量技术的零场原子磁力计。拥有巨大的发展潜力及庞大的市场空间。因此其数千万元的高昂售价及每年数百万元的超导维护成本限制了超导式心磁图仪的发展和临床应用。而基于超导式脑磁图仪的癫痫、阿尔兹海默症、抑郁症等脑疾病患者的临床研究也取得丰富的研究成果。 阅读详情

MyBatis的配置

MyBatis框架和其他绝大部分框架一样,需要一个配置文件,其配置文件大致如下:

<?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">
<configuration>
 <settings>
 <setting name="cacheEnabled" value="true"/>
 <setting name="lazyLoadingEnabled" value="false"/>
 <!--<setting name="logImpl" value="STDOUT_LOGGING"/> <!– 打印日志信息 –>-->
 </settings>
 <typeAliases>
 <typeAlias type="com.luo.dao.UserDao" alias="User"/>
 </typeAliases>
 <environments default="development">
 <environment id="development">
 <transactionManager type="JDBC"/> <!--事务管理类型-->
 <dataSource type="POOLED">
 <property name="username" value="luoxn28"/>
 <property name="password" value="123456"/>
 <property name="driver" value="com.mysql.jdbc.Driver"/>
 <property name="url" value="jdbc:mysql://192.168.1.150/ssh_study"/>
 </dataSource>
 </environment>
 </environments>
 <mappers>
 <mapper resource="userMapper.xml"/>
 </mappers>
</configuration>

以上配置中,最重要的是数据库参数的配置,比如用户名密码等,如果配置了数据表对应的mapper文件,则需要将其加入到<mappers>节点下。


MyBatis的主要成员

Configuration:MyBatis所有的配置信息都保存在Configuration对象之中,配置文件中的大部分配置都会存储到该类中。

SqlSession:作为MyBatis工作的主要顶层API,表示和数据库交互时的会话,完成必要数据库增删改查功能。

Executor:MyBatis执行器,是MyBatis 调度的核心,负责SQL语句的生成和查询缓存的维护。

StatementHandler:封装了JDBC Statement操作,负责对JDBC statement 的操作,如设置参数等。

ParameterHandler:负责对用户传递的参数转换成JDBC Statement所对应的数据类型。

ResultSetHandler:负责将JDBC返回的ResultSet结果集对象转换成List类型的集合。

TypeHandler:负责java数据类型和jdbc数据类型(也可以说是数据表列类型)之间的映射和转换。

MappedStatement:MappedStatement维护一条<select|update|delete|insert>节点的封装。

SqlSource:负责根据用户传递的parameterObject,动态地生成SQL语句,将信息封装到BoundSql对象中,并返回。

BoundSql:表示动态生成的SQL语句以及相应的参数信息。

以上主要成员在一次数据库操作中基本都会涉及,在SQL操作中重点需要关注的是SQL参数什么时候被设置和结果集怎么转换为JavaBean对象的,这两个过程正好对应StatementHandler和ResultSetHandler类中的处理逻辑。

 

MyBatis框架及原理分析

 

 


MyBatis的初始化

MyBatis的初始化的过程其实就是解析配置文件和初始化Configuration的过程,MyBatis的初始化过程可用以下几行代码来表述:

String resource = "mybatis.xml";
// 加载mybatis的配置文件(它也加载关联的映射文件)
InputStream inputStream = null;
try {
 inputStream = Resources.getResourceAsStream(resource);
} catch (IOException e) {
 e.printStackTrace();
}
// 构建sqlSession的工厂
sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

首先会创建SqlSessionFactory建造者对象,然后由它进行创建SqlSessionFactory。这里用到的是建造者模式,建造者模式最简单的理解就是不手动new对象,而是由其他类来进行对象的创建。

// SqlSessionFactoryBuilder类
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.
 }
 }
}

XMLConfigBuilder对象会进行XML配置文件的解析,实际为configuration节点的解析操作。

// XMLConfigBuilder类
public Configuration parse() {
 if (parsed) {
 throw new BuilderException("Each XMLConfigBuilder can only be used once.");
 }
 parsed = true;
 parseConfiguration(parser.evalNode("/configuration"));
 return configuration;
}
private void parseConfiguration(XNode root) {
 try {
 //issue #117 read properties first
 propertiesElement(root.evalNode("properties"));
 Properties settings = settingsAsProperties(root.evalNode("settings"));
 loadCustomVfs(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
 /* 处理environments节点数据 */
 environmentsElement(root.evalNode("environments"));
 databaseIdProviderElement(root.evalNode("databaseIdProvider"));
 typeHandlerElement(root.evalNode("typeHandlers"));
 mapperElement(root.evalNode("mappers"));
 } catch (Exception e) {
 throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
 }
}

在configuration节点下会依次解析properties/settings/.../mappers等节点配置。在解析environments节点时,会根据transactionManager的配置来创建事务管理器,根据dataSource的配置来创建DataSource对象,这里面包含了数据库登录的相关信息。在解析mappers节点时,会读取该节点下所有的mapper文件,然后进行解析,并将解析后的结果存到configuration对象中。

// XMLConfigBuilder类
private void environmentsElement(XNode context) throws Exception {
 if (context != null) {
 if (environment == null) {
 environment = context.getStringAttribute("default");
 }
 for (XNode child : context.getChildren()) {
 String id = child.getStringAttribute("id");
 if (isSpecifiedEnvironment(id)) {
 /* 创建事务管理器 */
 TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
 DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
 DataSource dataSource = dsFactory.getDataSource();
 /* 建造者模式 设计模式 */
 Environment.Builder environmentBuilder = new Environment.Builder(id)
 .transactionFactory(txFactory)
 .dataSource(dataSource);
 configuration.setEnvironment(environmentBuilder.build());
 }
 }
 }
}
// 解析单独的mapper文件
private void mapperElement(XNode parent) throws Exception {
 if (parent != null) {
 for (XNode child : parent.getChildren()) {
 if ("package".equals(child.getName())) {
 String mapperPackage = child.getStringAttribute("name");
 configuration.addMappers(mapperPackage);
 } else {
 String resource = child.getStringAttribute("resource");
 String url = child.getStringAttribute("url");
 String mapperClass = child.getStringAttribute("class");
 if (resource != null && url == null && mapperClass == null) {
 ErrorContext.instance().resource(resource);
 InputStream inputStream = Resources.getResourceAsStream(resource);
 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
 mapperParser.parse(); // 开始解析mapper文件了 :)
 } else if (resource == null && url != null && mapperClass == null) {
 ErrorContext.instance().resource(url);
 InputStream inputStream = Resources.getUrlAsStream(url);
 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
 mapperParser.parse();
 } else if (resource == null && url == null && mapperClass != null) {
 Class<?> mapperInterface = Resources.classForName(mapperClass);
 configuration.addMapper(mapperInterface);
 } else {
 throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
 }
 }
 }
 }
 }

解析完MyBatis配置文件后,configuration就初始化完成了,然后根据configuration对象来创建SqlSession,到这里时,MyBatis的初始化的征程已经走完了。

如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring,MyBatis,Netty源码分析的朋友可以加我的Java高级交流:787707172,群里有阿里大牛直播讲解技术,以及Java大型互联网技术的视频免费分享给大家。

// SqlSessionFactoryBuilder类
public SqlSessionFactory build(Configuration config) {
 return new DefaultSqlSessionFactory(config);
}

MyBatis的SQL查询流程

SQL语句的执行才是MyBatis的重要职责,该过程就是通过封装JDBC进行操作,然后使用Java反射技术完成JavaBean对象到数据库参数之间的相互转换,这种映射关系就是有TypeHandler对象来完成的,在获取数据表对应的元数据时,会保存该表所有列的数据库类型,大致逻辑如下所示:

/* Get resultSet metadata */
ResultSetMetaData metaData = resultSet.getMetaData();
int column = metaData.getColumnCount();
for (int i = 1; i <= column; i++) {
 JdbcType jdbcType = JdbcType.forCode(metaData.getColumnType(i));
 typeHandlers.add(TypeHandlerRegistry.getTypeHandler(jdbcType));
 columnNames.add(metaData.getColumnName(i));
}

使用如下代码进行SQL查询操作:

sqlSession = sessionFactory.openSession();
User user = sqlSession.selectOne("com.luo.dao.UserDao.getUserById", 1);
System.out.println(user);

创建sqlSession的过程其实就是根据configuration中的配置来创建对应的类,然后返回创建的sqlSession对象。调用selectOne方法进行SQL查询,selectOne方法最后调用的是selectList,在selectList中,会查询configuration中存储的MappedStatement对象,mapper文件中一个sql语句的配置对应一个MappedStatement对象,然后调用执行器进行查询操作。

// DefaultSqlSession类
public <T> T selectOne(String statement, Object parameter) {
 // Popular vote was to return null on 0 results and throw exception on too many.
 List<T> list = this.<T>selectList(statement, parameter);
 if (list.size() == 1) {
 return list.get(0);
 } else if (list.size() > 1) {
 throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
 } else {
 return null;
 }
}
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
 try {
 MappedStatement ms = configuration.getMappedStatement(statement);
 return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
 } catch (Exception e) {
 throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
 } finally {
 ErrorContext.instance().reset();
 }
}

执行器在query操作中,优先会查询缓存是否命中,命中则直接返回,否则从数据库中查询。

// CachingExecutor类
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
 /* 获取关联参数的sql,boundSql */
 BoundSql boundSql = ms.getBoundSql(parameterObject);
 /* 创建cache key值 */
 CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
 return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
 throws SQLException {
 /* 获取二级缓存实例 */
 Cache cache = ms.getCache();
 if (cache != null) {
 flushCacheIfRequired(ms);
 if (ms.isUseCache() && resultHandler == null) {
 ensureNoOutParams(ms, parameterObject, boundSql);
 @SuppressWarnings("unchecked")
 List<E> list = (List<E>) tcm.getObject(cache, key);
 if (list == null) {
 list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
 tcm.putObject(cache, key, list); // issue #578 and #116
 }
 return list;
 }
 }
 return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 List<E> list;
 /**
 * 先往localCache中插入一个占位对象,这个地方
 */
 localCache.putObject(key, EXECUTION_PLACEHOLDER);
 try {
 list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
 } finally {
 localCache.removeObject(key);
 }
 /* 往缓存中写入数据,也就是缓存查询结果 */
 localCache.putObject(key, list);
 if (ms.getStatementType() == StatementType.CALLABLE) {
 localOutputParameterCache.putObject(key, parameter);
 }
 return list;
}

真正的doQuery操作是由SimplyExecutor代理来完成的,该方法中有2个子流程,一个是SQL参数的设置,另一个是SQL查询操作和结果集的封装。

// SimpleExecutor类
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
 Statement stmt = null;
 try {
 Configuration configuration = ms.getConfiguration();
 StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
 /* 子流程1: SQL查询参数的设置 */
 stmt = prepareStatement(handler, ms.getStatementLog());
 /* 子流程2: SQL查询操作和结果集封装 */
 return handler.<E>query(stmt, resultHandler);
 } finally {
 closeStatement(stmt);
 }
}

子流程1 SQL查询参数的设置:

首先获取数据库connection连接,然后准备statement,然后就设置SQL查询中的参数值。打开一个connection连接,在使用完后不会close,而是存储下来,当下次需要打开连接时就直接返回。

// SimpleExecutor类
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
 Statement stmt;
 /* 获取Connection连接 */
 Connection connection = getConnection(statementLog);
 /* 准备Statement */
 stmt = handler.prepare(connection, transaction.getTimeout());
 /* 设置SQL查询中的参数值 */
 handler.parameterize(stmt);
 return stmt;
}
// DefaultParameterHandler类
public void setParameters(PreparedStatement ps) {
 /**
 * 设置SQL参数值,从ParameterMapping中读取参数值和类型,然后设置到SQL语句中
 */
 ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 if (parameterMappings != null) {
 for (int i = 0; i < parameterMappings.size(); i++) {
 ParameterMapping parameterMapping = parameterMappings.get(i);
 if (parameterMapping.getMode() != ParameterMode.OUT) {
 Object value;
 String propertyName = parameterMapping.getProperty();
 if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
 value = boundSql.getAdditionalParameter(propertyName);
 } else if (parameterObject == null) {
 value = null;
 } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
 value = parameterObject;
 } else {
 MetaObject metaObject = configuration.newMetaObject(parameterObject);
 value = metaObject.getValue(propertyName);
 }
 TypeHandler typeHandler = parameterMapping.getTypeHandler();
 JdbcType jdbcType = parameterMapping.getJdbcType();
 if (value == null && jdbcType == null) {
 jdbcType = configuration.getJdbcTypeForNull();
 }
 try {
 typeHandler.setParameter(ps, i + 1, value, jdbcType);
 } catch (TypeException e) {
 throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
 } catch (SQLException e) {
 throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
 }
 }
 }
 }
}

子流程2 SQL查询结果集的封装:

// SimpleExecutor类
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
 PreparedStatement ps = (PreparedStatement) statement;
 // 执行查询操作
 ps.execute();
 // 执行结果集封装
 return resultSetHandler.<E> handleResultSets(ps);
}
// DefaultReseltSetHandler类
public List<Object> handleResultSets(Statement stmt) throws SQLException {
 ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
 final List<Object> multipleResults = new ArrayList<Object>();
 int resultSetCount = 0;
 /**
 * 获取第一个ResultSet,同时获取数据库的MetaData数据,包括数据表列名、列的类型、类序号等。
 * 这些信息都存储在了ResultSetWrapper中了
 */
 ResultSetWrapper rsw = getFirstResultSet(stmt);
 List<ResultMap> resultMaps = mappedStatement.getResultMaps();
 int resultMapCount = resultMaps.size();
 validateResultMapsCount(rsw, resultMapCount);
 while (rsw != null && resultMapCount > resultSetCount) {
 ResultMap resultMap = resultMaps.get(resultSetCount);
 handleResultSet(rsw, resultMap, multipleResults, null);
 rsw = getNextResultSet(stmt);
 cleanUpAfterHandlingResultSet();
 resultSetCount++;
 }
 String[] resultSets = mappedStatement.getResultSets();
 if (resultSets != null) {
 while (rsw != null && resultSetCount < resultSets.length) {
 ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
 if (parentMapping != null) {
 String nestedResultMapId = parentMapping.getNestedResultMapId();
 ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
 handleResultSet(rsw, resultMap, null, parentMapping);
 }
 rsw = getNextResultSet(stmt);
 cleanUpAfterHandlingResultSet();
 resultSetCount++;
 }
 }
 return collapseSingleResultList(multipleResults);
 }

ResultSetWrapper是ResultSet的包装类,调用getFirstResultSet方法获取第一个ResultSet,同时获取数据库的MetaData数据,包括数据表列名、列的类型、类序号等,这些信息都存储在ResultSetWrapper类中了。然后调用handleResultSet方法来来进行结果集的封装。

// DefaultResultSetHandler类
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
 try {
 if (parentMapping != null) {
 handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
 } else {
 if (resultHandler == null) {
 DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
 handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
 multipleResults.add(defaultResultHandler.getResultList());
 } else {
 handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
 }
 }
 } finally {
 // issue #228 (close resultsets)
 closeResultSet(rsw.getResultSet());
 }
}

这里调用handleRowValues方法进行结果值的设置。

// DefaultResultSetHandler类
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
 if (resultMap.hasNestedResultMaps()) {
 ensureNoRowBounds();
 checkResultHandler();
 handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
 } else {
 // 封装数据
 handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
 }
}
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
 throws SQLException {
 DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
 skipRows(rsw.getResultSet(), rowBounds);
 while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
 ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
 Object rowValue = getRowValue(rsw, discriminatedResultMap);
 storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
 }
}
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
 final ResultLoaderMap lazyLoader = new ResultLoaderMap();
 // createResultObject为新创建的对象,数据表对应的类
 Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
 if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
 final MetaObject metaObject = configuration.newMetaObject(rowValue);
 boolean foundValues = this.useConstructorMappings;
 if (shouldApplyAutomaticMappings(resultMap, false)) {
 // 这里把数据填充进去,metaObject中包含了resultObject信息
 foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
 }
 foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
 foundValues = lazyLoader.size() > 0 || foundValues;
 rowValue = (foundValues || configuration.isReturnInstanceForEmptyRow()) ? rowValue : null;
 }
 return rowValue;
}
private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
 List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
 boolean foundValues = false;
 if (autoMapping.size() > 0) {
 // 这里进行for循环调用,因为user表中总共有7列,所以也就调用7次
 for (UnMappedColumnAutoMapping mapping : autoMapping) {
 // 这里将esultSet中查询结果转换为对应的实际类型
 final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
 if (value != null) {
 foundValues = true;
 }
 if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
 // gcode issue #377, call setter on nulls (value is not 'found')
 metaObject.setValue(mapping.property, value);
 }
 }
 }
 return foundValues;
}

mapping.typeHandler.getResult会获取查询结果值的实际类型,比如我们user表中id字段为int类型,那么它就对应Java中的Integer类型,然后通过调用statement.getInt("id")来获取其int值,其类型为Integer。metaObject.setValue方法会把获取到的Integer值设置到Java类中的对应字段。

// MetaObject类
public void setValue(String name, Object value) {
 PropertyTokenizer prop = new PropertyTokenizer(name);
 if (prop.hasNext()) {
 MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
 if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
 if (value == null && prop.getChildren() != null) {
 // don't instantiate child path if value is null
 return;
 } else {
 metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
 }
 }
 metaValue.setValue(prop.getChildren(), value);
 } else {
 objectWrapper.set(prop, value);
 }
}

metaValue.setValue方法最后会调用到Java类中对应数据域的set方法,这样也就完成了SQL查询结果集的Java类封装过程。最后贴一张调用栈到达Java类的set方法中的快照:

MyBatis框架及原理分析

 


MyBatis缓存

MyBatis提供查询缓存,用于减轻数据库压力,提高性能。MyBatis提供了一级缓存和二级缓存。

MyBatis框架及原理分析

 

一级缓存是SqlSession级别的缓存,每个SqlSession对象都有一个哈希表用于缓存数据,不同SqlSession对象之间缓存不共享。同一个SqlSession对象对象执行2遍相同的SQL查询,在第一次查询执行完毕后将结果缓存起来,这样第二遍查询就不用向数据库查询了,直接返回缓存结果即可。MyBatis默认是开启一级缓存的。

二级缓存是mapper级别的缓存,二级缓存是跨SqlSession的,多个SqlSession对象可以共享同一个二级缓存。不同的SqlSession对象执行两次相同的SQL语句,第一次会将查询结果进行缓存,第二次查询直接返回二级缓存中的结果即可。MyBatis默认是不开启二级缓存的,可以在配置文件中使用如下配置来开启二级缓存:

<settings>
 <setting name="cacheEnabled" value="true"/>
</settings>

当SQL语句进行更新操作(删除/添加/更新)时,会清空对应的缓存,保证缓存中存储的都是最新的数据。MyBatis的二级缓存对细粒度的数据级别的缓存实现不友好。

比如如下需求:对商品信息进行缓存,由于商品信息查询访问量大,但是要求用户每次都能查询最新的商品信息,此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息,因为mybaits的二级缓存区域以mapper为单位划分,当一个商品信息变化会将所有商品信息的缓存数据全部清空。

解决此类问题需要在业务层根据需求对数据有针对性缓存,具体业务具体实现。

欢迎工作一到八年的Java工程师朋友们加入Java高级交流:787707172

本群提供免费的学习指导 架构资料 以及免费的解答

不懂得问题都可以在本群提出来 之后还会有直播平台和讲师直接交流噢

DAP-Link DIY复刻指南 DAP-Link是ARM开源的一个项目,主要用于代码下载以及调试,支持SWD和JTAG调试接口,对于开发嵌入式的同学相信都或多或少有所耳闻。除了DAP-Link之外还有很多同类型的调试器,如ST-LinkJ-Link,但是这些都是不开源的,无法复刻或进行二次开发。但DAP-Link不同,完全开源,不用担心侵权问题,且随着开源社区大家的共同努力,DAP-Link经过了不断的迭代,先如今已取代ARM之前推出的CMSIS-DAP开源项目。 阅读详情

相关推荐

自动驾驶系统架构解析:从传感器到决策控制的完整链路(附实际案例)

本文深入解析了自动驾驶系统从感知、决策到控制的完整架构链路。通过对比摄像头、毫米波雷达、激光雷达等核心传感器的特性与选型策略,阐述了多传感器融合的必要性。文章结合行为决策、运动规划及控制执行的实际案例,揭示了系统集成、数据闭环与功能安全等工程化落地的关键挑战,为理解自动驾驶技术提供了清晰的蓝图。

weixin_29051811的博客 339

JDBC简介(2)

前篇:JDBC简介(1) 1、Connection角色       Connection表示与特定数据库的连接,可以获取到数据库的一些信息,这些信息包括:其表信息,应该支持的SQL语法,数据库内有什么存储过程,此链接功能的信息等等。 在一般实际使用情况下,我们关注的Connection的功能有以下几点: 1.1 创建可以执行sql语句或者存储过程的对象stateme

爱上在路上 938

基于淘宝商城用户购物行为数据分析系统

本文使用HIve+superset技术对阿里云天池提供的淘宝用户购物数据进行处理分析,得到有价值的信息并对平台提出有建设性意义的意见。

m0_51388399的博客 2822

MyBatis的工作原理

MyBatis 是一个功能强大的持久层框架,通过对 SQL 语句的精确控制和方便的映射配置,提供了一种灵活且高效的数据库访问方式。MyBatis 的工作原理主要围绕SqlSessionMapperExecutor这几个核心组件展开,通过配置文件和映射文件,将 Java 对象和数据库表有效地连接起来。MyBatis 通过动态代理、缓存机制、动态 SQL、插件机制等特性,极大地提升了数据库操作的简洁性和可维护性,同时保留了对 SQL 语句的完全控制权,适合于各种需要精细化控制 SQL 的场景。

Flying_Fish_roe的博客 3207

Python结合海康威视工业相机SDK实现高效图像采集与处理

本文详细介绍了如何使用Python结合海康威视工业相机SDK实现高效的图像采集与处理。内容涵盖从环境搭建、SDK核心模块理解,到完整的图像采集流程拆解,包括设备枚举、参数设置、主动取流以及关键的像素格式转换。同时,文章深入探讨了触发模式、参数控制等高级应用,并提供了性能优化建议和可复用的相机操作类封装,帮助开发者快速构建稳定的机器视觉应用。

weixin_29043895的博客 350

LTspice基础教程-024.参数扫描;step指令用法

step指令用于参数扫描,扫描步骤可以是线性的,对数的或列表。 下面介绍几种常用用法: 绘制一简单电阻分压电路,如下: 线性扫描 语法:.step param <Name> <Start Value> <Stop Value> <Increment> 例:.step param Res 20 100 20 意思是R2的阻值从20变化到100,...

gaoyong_wang的博客 3万+

MyBatis基本工作原理介绍

1、MyBatis基本工作原理介绍 计算机的基本工作就是存储和计算,而MyBatis是存储领域的利器。MyBatis的基本工作原理就是:先封装SQL,接着调用JDBC操作数据库,最后把数据库返回的表结果封装成Java类。 2、MyBatis的核心流程介绍 mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件中构建出SqlSessionFactory,然后,SqlSessionFactory的实例直接开启一个SqlSession,再通过

weixin_44431073的博客 2万+

生成对抗网络——CGAN(代码+理解)

CGAN(Conditional Generative Adversarial Network)模型是一种 深度学习模型,属于生成对抗网络(GAN)的一种 变体。它的 基本思想是通过 训练生成器和判别器两个网络,使生成器能够生成与给定条件 相匹配的 合成数据,而判别器则 负责区分真实数据和 生成数据。相比于GAN它引入了条件信息(y),使得生成器可以生成与给定条件相匹配的合成数据,从而提高了生成数据的可控性和针对性。

CXDNW的博客 1万+

MyBatis的工作原理和应用实例

MyBatis 是一个优秀的持久层框架,它封装了 JDBC 的底层操作,MyBatis 通过其灵活的配置和强大的映射能力,大大简化了数据库操作,同时保留了 SQL 的灵活性和可控性,是 Java 项目中常用的持久层解决方案。

weixin_46455584的博客 1241

筹码峰五句口诀,看懂主力的秘密动作!(附实战图示)

筹码图的价值在于,它不像K线那样容易造假。主力可以骗线,但骗不了筹码分布。主力在不在;是吸筹还是出货;接下来是变盘还是震荡。这五句口诀可以说是“筹码阅读的入门圣经”:单峰坚挺变盘在即,双峰对垒高抛低吸;上峰不移主力在跑,多峰林立行情不止;下峰不移不离不弃,筹码识庄稳中取利!📌市场从来不是靠猜,而是靠看清。筹码,就是主力最真实的痕迹。如果你想学会提前布局、跟庄不被甩,学会看筹码峰——这一步必须打牢!

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 1169

【自然语言处理】情感分析(一):基于 NLTK 的 Naive Bayes 实现

朴素贝叶斯(Naive Bayes)分类器可以用来确定输入文本属于某一组类别的概率。例如,预测评论是正面的还是负面的。它是 “朴素的”,它假设文本中的单词是独立的(但在现实的自然人类语言中,单词的顺序传达了上下文信息)。尽管有这些假设,但朴素贝叶斯在使用少量训练集预测类别时具有很高的准确性。

Data · Model · Agent · Repeat 2173

Mybatis框架及原理分析

框架主要类层次结构 1、Mybatis主要做的工作: 1、根据JDBC规范建立与数据库的连接 2、通过反射打通Java对象与数据库参数交互之间相互转化关系 2、主要类的层次关系 SqlSessionFactoryBuilder类通过各种构造器方法,将所有的配置信息维持在Configuration类中,返回一个SqlSessionFactory;SqlSessionFactory中的o

Dream__Snow的博客 2490

Vue + ECharts:从零构建智慧农业数据监控大屏(附完整源码)」 「超实用!一步步实现智慧农业大屏,完整代码+讲解」 「前端新手友好:Vue + ECharts 打造炫酷农业数据大屏」 「

Vue + ECharts:从零构建智慧农业数据监控大屏(附完整源码)」 「超实用!一步步实现智慧农业大屏,完整代码+讲解」 「前端新手友好:Vue + ECharts 打造炫酷农业数据大屏」 「前端可视化项目实战:智慧农业监控大屏开发详解」 「农作物可视化监控:用 Vue 和 ECharts 构建大屏应用」 「从零开始开发一个智慧农业数据大屏(代码+图表展示)」 「前端新手也能实现!智慧农业监控大屏开发教程」 「用 Vue 和 ECharts 搭建动态数据大屏:详细图文教程」 「学习前端大屏开发:

sky10100100的博客 1535

SpringBoot中的MyBatis框架整合实现及原理分析

整合MyBatis的初步分析 概述 Mybatis是一个优秀的持久层框架,底层基于JDBC实现与数据库的交互。并在JDBC操作的基础上做了封装和优化,它借助灵活的SQL定制,参数及结果集的映射方式,更好的适应了当前互联网技术的发展。Mybatis框架的简单应用架构如图所示: 在当今的互联网应用中项目,mybatis框架通常会由spring框架进行资源整合,作为数据层技术实现数据交互操作。 准备工作 第一步:创建项目module,例如: 第二步:添加依赖 mysql 驱动依赖 <dependency

doubututou的博客 1069

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

MyBatis 框架及原理分析

目录 MyBatis 的配置 MyBatis 的主要成员 MyBatis 的初始化 MyBatis 的SQL查询流程 MyBatis 的缓存 MyBatis 是支持定制化SQL,存储过程,以及高级映射的优秀的持久层框架,其主要完成2件事情: 1.封装JDBC操作; 2.利用反射打通Java 类与SQL语句之间的相互转换。 MyBatis 的主要设计目的就是让我们在执行SQL语...

时光钟摆 260

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

05-SpringBoot中的MyBatis框架的整合实现及原理分析

整合MyBatis的初步分析 概述 Mybatis是一个优秀的持久层框架,底层基于JDBC实现与数据库的交互。并在JDBC操作的基础上做了封装和优化,它借助灵活的SQL定制,参数及结果集的映射方式,更好的适应了当前互联网技术的发展。Mybatis框架的简单应用架构如图所示: 在当今的互联网应用中项目,mybatis框架通常会由spring框架进行资源整合,作为数据层技术实现数据交互操作。 准备工作 第一步:创建项目module,例如: 第二步:添加依赖 mysql 驱动依赖 (在pom.xml文件中查

weixin_50554271的博客 297

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

上一篇: 什么是Java内存模型
下一篇: 如何提高缓存命中率
javaQQ群 866865133
博客等级 码龄8年 59粉丝 309原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值