MyBatis中localOutputParameterCache的作用

首先，既然你想知道localOutputParameterCache的作用，我就当你知道localCache（MyBatis的一级缓存）。然后，我告诉你localOutputParameterCache也是一级缓存，只不过它作用的不是我们理论上的返回结果，而是我们请求的参数（可以是DO），更进一步说他是对存储过程的一种缓存，下面我为大家11介绍。

1、localOutputParameterCache的创建时机

// class BaseExecutor
protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<>();
    this.localCache = new PerpetualCache("LocalCache");
    // 创建时机在Executor创建的时候，和localCache一起被创建
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
2、设置Object parameter（请求参数）值
  // class DefaultResultSetHandler
  @Override
  public void handleOutputParameters(CallableStatement cs) throws SQLException {
    final Object parameterObject = parameterHandler.getParameterObject();
    final MetaObject metaParam = configuration.newMetaObject(parameterObject);
    final List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    for (int i = 0; i < parameterMappings.size(); i++) {
      final ParameterMapping parameterMapping = parameterMappings.get(i);
      // 只有mode值为：OUT或INOUT时，才进行存储过程返回结果的设置
      if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
        if (ResultSet.class.equals(parameterMapping.getJavaType())) {
          handleRefCursorOutputParameter((ResultSet) cs.getObject(i + 1), parameterMapping, metaParam);
        } else {
          final TypeHandler<?> typeHandler = parameterMapping.getTypeHandler();
          // 从存储过程中获取到的值，设置到请求参数的映射中
          metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
这样设置的结果：是将存储过程中的返回结果设置到Object parameter中，可以打断点进行查看验证。
3、使用的时机-设置值
// class BaseExecutor
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    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) {
      // 注意：只有在statementType="CALLABLE"的时候，设置值
      localOutputParameterCache.putObject(key, parameter);
    return list;
这样设置的结果：是将封装好的Object parameter的结果设置到localOutputParameterCache中。
4、使用的时机-获取设置的值
// class BaseExecutor
private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      // 从localOutputParameterCache获取缓存的值
      final Object cachedParameter = localOutputParameterCache.getObject(key);
      if (cachedParameter != null && parameter != null) {
        final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
        final MetaObject metaParameter = configuration.newMetaObject(parameter);
        for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
          if (parameterMapping.getMode() != ParameterMode.IN) {
            final String parameterName = parameterMapping.getProperty();
            final Object cachedValue = metaCachedParameter.getValue(parameterName);
            // 将缓存中的值设置到Object parameter请求参数中
            metaParameter.setValue(parameterName, cachedValue);
这样做的结果：就是从localOutputParameterCache中查存储过程的结果，而不是去调数据库。
总结：localOutputParameterCache也是一级缓存，只不过是用来缓存存储过程的返回结果。
补充：分享一个不完整的小demo（我理解的看到这最起码你的应用也有了），大家可以进行调试时使用：
1、表SQL
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for tbl_employee
-- ----------------------------
DROP TABLE IF EXISTS `tbl_employee`;
CREATE TABLE `tbl_employee`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `last_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `gender` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `email` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime(0) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Compact;
SET FOREIGN_KEY_CHECKS = 1;
2、简单的存储过程
CREATE DEFINER=`root`@`localhost` PROCEDURE `get_employee_by_procedure`(
    IN inputId INT,
    OUT lastName VARCHAR(256),
    OUT gender CHAR,
    OUT email VARCHAR(256),
    OUT get_create DATETIME
BEGIN
SELECT
e.last_name, e.gender, e.email, e.gmt_create
INTO lastName, gender, email, get_create
FROM tbl_employee e WHERE e.id = inputId;
简单说明，在Navicat中对应数据库下的函数下进行保存即可：
    useCache="false"是避免二级缓存对其影响，查看源码自行了解；
    statementType="CALLABLE"是开启使用该localOutputParameterCache缓存，具体含义查看官方文档即可
<select id="getEmpByProcedure" useCache="false" statementType="CALLABLE">
    {CALL get_employee_by_procedure(
        #{id, mode=IN, jdbcType=INTEGER},
        #{lastName, mode=OUT, jdbcType=VARCHAR, javaType=java.lang.String},
        #{email, mode=OUT, jdbcType=CHAR, javaType=java.lang.String},
        #{gender, mode=OUT, jdbcType=VARCHAR, javaType=java.lang.String},
        #{gmtCreate, mode=OUT, jdbcType=DATE, javaType=java.util.Date}
</select>
4、编写Mapper接口方法
public interface EmployeeMapper {
     * 通过存储过程查询员工信息（无返回结果）
     * @param employee 员工对象
    void getEmpByProcedure(Employee employee);
注意：存储过程的返回结果会封装在请求参数中，所以请求参数中要包含返回的参数。
5、编写DO
@Data
public class Employee implements Serializable {
    private static final long serialVersionUID = -6843908059513315549L;
    private Integer id;
    private String lastName;
    /** 0：女；1：男 */
    private String gender;
    private String email;
    private Date gmtCreate;
6、编写测试方法
@Slf4j
public class ProcedureTest {
    private SqlSessionFactory getSqlSessionFactory() throws IOException {
        try (InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml")) {
            return new SqlSessionFactoryBuilder().build(inputStream);
    @Test
    public void procedureTest() throws IOException {
        // 1、获取sqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        // 2、获取sqlSession对象
        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
            // 3、获取接口实现类对象
            EmployeeMapper mapper1 = sqlSession.getMapper(EmployeeMapper.class);
            EmployeeMapper mapper2 = sqlSession.getMapper(EmployeeMapper.class);
            // mapper1查询
            Employee employee1 = new Employee();
            employee1.setId(1);
            mapper1.getEmpByProcedure(employee1);
            // mapper2查询
            Employee employee2 = new Employee();
            employee2.setId(1);
            mapper2.getEmpByProcedure(employee2);
            System.out.println(employee1);
            System.out.println(employee2);
            // mapper1和mapper2的查询结果中引用对象比较：
            // 比较地址值是否相等，从而说明是否使用了一级缓存
            System.out.println(employee1.getGmtCreate() == employee2.getGmtCreate());
        } catch (Exception e) {
            log.error("error: {}", e, e.getMessage());
说明：大家可以通过使用关闭一级缓存的方法将一级缓存关闭后，查看运行结果，从而进一步论证localOutputParameterCache就是“一级缓存”。
你会发现：

在不关闭一级缓存的情况下，对象中的引用属性的值比较是：true

而在关闭一级缓存的情况下，对象中的引用属性的值比较是：false
关闭一级缓存的方式可以是：
<select id="getEmpByProcedure" useCache="false" statementType="CALLABLE" flushCache="true">
    {CALL get_employee_by_procedure(
        #{id, mode=IN, jdbcType=INTEGER},
        #{lastName, mode=OUT, jdbcType=VARCHAR, javaType=java.lang.String},
        #{email, mode=OUT, jdbcType=CHAR, javaType=java.lang.String},
        #{gender, mode=OUT, jdbcType=VARCHAR, javaType=java.lang.String},
        #{gmtCreate, mode=OUT, jdbcType=DATE, javaType=java.util.Date}
</select>
没错，就是在标签中添加 flushCache="true"即可。
希望这篇文章能解决你的困惑，帮忙点个赞不过分吧。