当前位置：首页 > news >正文

贵阳网站设计阳光创信好吗如何做好关键词的优化

news 2025/7/22 4:51:25

贵阳网站设计阳光创信好吗,如何做好关键词的优化,做网站用html好还是vue好,有什么国企是做网站的SqlSession是Mybatis最重要的构建之一，可以认为Mybatis一系列的配置目的是生成类似JDBC生成的Connection对象的statement对象，这样才能与数据库开启“沟通”，通过SqlSession可以实现增删改查（当然现在更加推荐是使用Mapper接口形式…

SqlSession是Mybatis最重要的构建之一，可以认为Mybatis一系列的配置目的是生成类似JDBC生成的Connection对象的statement对象，这样才能与数据库开启“沟通”，通过SqlSession可以实现增删改查（当然现在更加推荐是使用Mapper接口形式）

1 .sqlsession的创建：

SqlSessionFactoryBuilder创建SqlSessionFactory openSession,sqlSession 执行增删改查
用了注解是通过org.mybatis.spring.SqlSessionFactoryBean该类创建sqlsession的，而mapper里面的每一个方法称为statement。

public void deleteUserTest() throws IOException {// mybatis配置文件String resource = "SqlMapConfig.xml";// 得到配置文件流InputStream inputStream = Resources.getResourceAsStream(resource);// 创建会话工厂，传入mybatis的配置文件信息SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);// 通过工厂得到SqlSessionSqlSession sqlSession = sqlSessionFactory.openSession();// 传入id删除 用户sqlSession.delete("test.deleteUser", 39);        //更新        sqlSession.update("test.updateUser", user);        //插入        sqlSession.insert("test.insertUser", user);        //查询        List<User> list = sqlSession.selectOne("test.findUserByName", "小明");// 提交事务 增删改 需要commit，查询无需commitsqlSession.commit();// 关闭会话sqlSession.close();}

2.SqlSession原理

SqlSession提供select/insert/update/delete方法，在旧版本中使用使用SqlSession接口的这些方法，但是新版的Mybatis中就会建议使用Mapper接口的方法。

映射器其实就是一个动态代理对象，进入到MapperMethod的execute方法就能简单找到SqlSession的删除、更新、查询、选择方法，从底层实现来说：通过动态代理技术，让接口跑起来，之后采用命令模式，最后还是采用了SqlSession的接口方法（getMapper()方法等到Mapper）执行SQL查询（也就是说Mapper接口方法的实现底层还是采用SqlSession接口方法实现的）。

3.SqlSession重要的四个对象

1）Execute：调度执行StatementHandler、ParmmeterHandler、ResultHandler执行相应的SQL语句；2）StatementHandler：使用数据库中Statement（PrepareStatement）执行操作，即底层是封装好了的prepareStatement；3）ParammeterHandler：处理SQL参数；4）ResultHandler：结果集ResultSet封装处理返回。

Execute执行器
execute接口有以下方法

public interface Executor {ResultHandler NO_RESULT_HANDLER = null;int update(MappedStatement var1, Object var2) throws SQLException;<E> List<E> query(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4, CacheKey var5, BoundSql var6) throws SQLException;<E> List<E> query(MappedStatement var1, Object var2, RowBounds var3, ResultHandler var4) throws SQLException;<E> Cursor<E> queryCursor(MappedStatement var1, Object var2, RowBounds var3) throws SQLException;List<BatchResult> flushStatements() throws SQLException;void commit(boolean var1) throws SQLException;void rollback(boolean var1) throws SQLException;CacheKey createCacheKey(MappedStatement var1, Object var2, RowBounds var3, BoundSql var4);boolean isCached(MappedStatement var1, CacheKey var2);void clearLocalCache();void deferLoad(MappedStatement var1, MetaObject var2, String var3, CacheKey var4, Class<?> var5);Transaction getTransaction();void close(boolean var1);boolean isClosed();void setExecutorWrapper(Executor var1);
}

执行器起到至关重要的作用，它是真正执行Java与数据库交互的东西，参与了整个SQL查询执行过程中。

1）主要有三种执行器：简易执行器SIMPLE（不配置就是默认执行器）、REUSE是一种重用预处理语句、BATCH批量更新、批量专用处理器

2）执行器作用：Executor会先调用StatementHandler的prepare()方法预编译SQL语句，同时设置一些基本的运行参数，然后调用StatementHandler的parameterize()方法（实际上是启用了ParameterHandler设置参数）设置参数，resultHandler再组装查询结果返回调用者完成一次查询完成预编译，简单总结起来就是即先预编译SQL语句，之后设置参数（跟JDBC的prepareStatement过程类似）最后如果有查询结果就会组装返回。

4.Mapper
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等关联起来的呢？下面为你一一解答。

1、创建

表面上看mapper是在sqlsession里创建的，但实际创建它的地方是MapperRegistry：

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {if (!knownMappers.contains(type))throw new BindingException("Type " + type + " isnot known to the MapperRegistry.");try {return MapperProxy.newMapperProxy(type, sqlSession);} catch (Exceptione) {throw new BindingException("Error getting mapper instance. Cause: " + e, e);}
}

可以看到，mapper是一个代理对象，它实现的接口就是传入的type，这就是为什么mapper对象可以通过接口直接访问。同时还可以看到，创建mapper代理对象时传入了sqlsession对象，这样就把sqlsession也关联起来了。我们进一步看看MapperProxy.newMapperProxy(type,sqlSession); 背后发生了什么事情：

public static <T> T newMapperProxy(Class<T> mapperInterface, SqlSession sqlSession) {ClassLoader classLoader = mapperInterface.getClassLoader();Class<?>[] interfaces = new Class[]{mapperInterface};MapperProxy proxy = new MapperProxy(sqlSession);return (T) Proxy.newProxyInstance(classLoader,interfaces, proxy);
}

看起来没什么特别的，和其他代理类的创建一样，我们重点关注一下MapperProxy的invoke方法：
2、MapperProxy 的 invoke

我们知道对被代理对象的方法的访问都会落实到代理者的invoke上来，MapperProxy的invoke如下：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{if (method.getDeclaringClass()== Object.class) {return method.invoke(this, args);}final Class<?> declaringInterface = findDeclaringInterface(proxy, method);final MapperMethod mapperMethod = new MapperMethod(declaringInterface, method, sqlSession);final Object result = mapperMethod.execute(args);if (result ==null && method.getReturnType().isPrimitive()&& !method.getReturnType().equals(Void.TYPE)) {throw new BindingException("Mapper method '" + method.getName() + "'(" + method.getDeclaringClass()+ ") attempted toreturn null from a method with a primitive return type ("+ method.getReturnType() + ").");}return result;
}

可以看到invoke把执行权转交给了MapperMethod，我们来看看MapperMethod里又是怎么运作的：

public Object execute(Object[] args) {Object result = null;if(SqlCommandType.INSERT == type) {Object param = getParam(args);result = sqlSession.insert(commandName, param);} else if(SqlCommandType.UPDATE == type) {Object param = getParam(args);result = sqlSession.update(commandName, param);} else if(SqlCommandType.DELETE == type) {Object param = getParam(args);result = sqlSession.delete(commandName, param);} else if(SqlCommandType.SELECT == type) {if (returnsVoid && resultHandlerIndex != null) {executeWithResultHandler(args);} else if (returnsList) {result = executeForList(args);} else if (returnsMap) {result = executeForMap(args);} else {Object param = getParam(args);result = sqlSession.selectOne(commandName, param);}} else {throw new BindingException("Unknown execution method for: " + commandName);}return result;}

可以看到，MapperMethod就像是一个分发者，他根据参数和返回值类型选择不同的sqlsession方法来执行。这样mapper对象与sqlsession就真正的关联起来了。

5.Executor
前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问最终都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经介绍了，下面介绍下他们的功能：

CacheExecutor

CacheExecutor有一个重要属性delegate，它保存的是某类普通的Executor，值在构照时传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先尝试从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。代码如下：

public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {if (ms != null) {Cache cache = ms.getCache();if (cache != null) {flushCacheIfRequired(ms);cache.getReadWriteLock().readLock().lock();try {if (ms.isUseCache() && resultHandler ==null) {CacheKey key = createCacheKey(ms, parameterObject, rowBounds);final List cachedList = (List)cache.getObject(key);if (cachedList != null) {return cachedList;} else {List list = delegate.query(ms,parameterObject, rowBounds, resultHandler);tcm.putObject(cache,key, list);return list;}} else {return delegate.query(ms,parameterObject, rowBounds, resultHandler);}} finally {cache.getReadWriteLock().readLock().unlock();}}}return delegate.query(ms,parameterObject, rowBounds, resultHandler);
}

普通 Executor

普通Executor有3类，他们都继承于BaseExecutor，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。下面以SimpleExecutor为例：

public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {Statementstmt = null;try {Configuration configuration = ms.getConfiguration();StatementHandler handler = configuration.newStatementHandler(this, ms,parameter, rowBounds,resultHandler);stmt = prepareStatement(handler);return handler.query(stmt, resultHandler);} finally {closeStatement(stmt);}
}

可以看出，Executor本质上也是个甩手掌柜，具体的事情原来是StatementHandler来完成的。

6.StatementHandler
当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的。

创建

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) {StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler);statementHandler= (StatementHandler) interceptorChain.pluginAll(statementHandler);return statementHandler;
}

可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper配置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要注意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。由于mybatis没有实现数据库的物理分页，众多物理分页的实现都是在这个地方使用拦截器实现的，本文作者也实现了一个分页拦截器，在后续的章节会分享给大家，敬请期待。

初始化

StatementHandler创建后需要执行一些初始操作，比如statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：

private Statement prepareStatement(StatementHandler handler) throwsSQLException {Statement stmt;Connection connection = transaction.getConnection();stmt =handler.prepare(connection);handler.parameterize(stmt);return stmt;
}
statement的开启和参数设置没什么特别的地方，handler.parameterize倒是可以看看是怎么回事。handler.parameterize通过调用ParameterHandler的setParameters完成参数的设置，ParameterHandler随着StatementHandler的创建而创建，默认的实现是DefaultParameterHandler：public ParameterHandler newParameterHandler(MappedStatement mappedStatement, ObjectparameterObject, BoundSql boundSql) {ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement,parameterObject,boundSql);parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);return parameterHandler;
}

同Executor和StatementHandler一样，ParameterHandler也是可以被拦截的。

参数设置

DefaultParameterHandler里设置参数的代码如下：

public void setParameters(PreparedStatement ps) throws SQLException {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) {Object value;String propertyName = parameterMapping.getProperty();PropertyTokenizer prop = new PropertyTokenizer(propertyName);if (parameterObject == null) {value = null;} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){value = parameterObject;} else if (boundSql.hasAdditionalParameter(propertyName)){value = boundSql.getAdditionalParameter(propertyName);} else if(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()));}} else {value = metaObject == null ? null :metaObject.getValue(propertyName);}TypeHandler typeHandler = parameterMapping.getTypeHandler();if (typeHandler == null) {throw new 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最后还有个查询结果的处理过程。

7.ResultSetHandler

结果处理

结果处理使用ResultSetHandler来完成，默认的ResultSetHandler是FastResultSetHandler，它在创建StatementHandler时一起创建，代码如下：

public ResultSetHandler 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);return resultSetHandler;
}

可以看出ResultSetHandler也是可以被拦截的，可以编写自己的拦截器改变ResultSetHandler的默认行为。

// ResultSetHandler内部一条记录一条记录的处理，在处理每条记录的每一列时会调用TypeHandler转换结果，如下：

protected boolean applyAutomaticMappings(ResultSet rs, List<String> unmappedColumnNames,MetaObject metaObject) throws SQLException {boolean foundValues = false;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 = true;}}}}return foundValues;
}