mysql多次查询得到的java对象物理地址相同（源码探究）

问题描述：同一事物下，主方法通过主键查询得到java对象，主键作为参数，传入新的方法，重新查询得到java对象，对java对象的成员变量进行了调整。（因为得到的是同一对象，指针内存物理地址相同）导致主方法的java对象同步调整，引发后面对此成员变量的判断失误，导致问题。

先说结果，同一session下相同查询，如果未涉及到数据库数据调整的操作，mysql得到的java对象物理地址可能相同。
原因，mysql的一级缓存默认开启。

下面是源码探究
这里我使用的是通过主键查询对应一条数据

mysql源码的类BaseExecutor
@Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    //下面方法会把这次查询的相关参数组织成一个key，同一session下，下次查询可以直接从一级缓存拿到数据。
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

这里贴一下createCacheKey的源码，不感兴趣的可以直接跳过

@Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(Integer.valueOf(rowBounds.getOffset()));
    cacheKey.update(Integer.valueOf(rowBounds.getLimit()));
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    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)) {
          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);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }    
  public void update(Object object) {
    if (object != null && object.getClass().isArray()) {
      int length = Array.getLength(object);
      for (int i = 0; i < length; i++) {
        Object element = Array.get(object, i);
        doUpdate(element);
      }
    } else {
      doUpdate(object);
    }
  }

  private void doUpdate(Object object) {
    int baseHashCode = object == null ? 1 : object.hashCode();

    count++;
    checksum += baseHashCode;
    baseHashCode *= count;

    hashcode = multiplier * hashcode + baseHashCode;

    updateList.add(object);
  }

下面是query方法的源码，这里可以重点看一下

@SuppressWarnings("unchecked")
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //这里如果发现一级缓存有数据，那么就不在查询数据库，直接拿到缓存的数据。缓存的底层是一个hashMap。
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
      //当缓存中没有此key时，就进行查询
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

没有缓存时执行查询方法（这里会往一级缓存赋值）

  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) {
      localOutputParameterCache.putObject(key, parameter);
    }
    //返回的结果是在这个list取值，如果是单独查询一条，外层会调用list.get(0)
    return list;
  }

到此弄清了为什么多次查询得到的java对象是同一个了，因为后续的查询取的是从mysql的一级缓存中取的数据。
同一session下对数据的赠删改都会清理一级缓存的数据。
mysql的一级缓存默认是开启的。
如果你查询之后对数据进行了调整，但是第二次查询出来的数据还是未调整的。
那么你可以从这方面排查一下。
这种问题可能发生在项目刚搭建阶段。mysql的数据库默认隔离级别是Repeatable Read。
为什么是这个隔离级别是因为历史原因导致的。历史主从复制时使用Read Commited时设置不当会导致主从数据不一致。现在的互联网项目基本都是用Read Commited隔离级别。可使用下面命令查看你当前数据库的隔离级别
select @@global.transaction_isolation,@@transaction_isolation;
当隔离级别是Repeatable Read时，如果你的数据更新操作失败，即update的返回结果是0时（一般是并发导致的），那么你当前的session使用相同方式查询数据时还是会取到未调整的数据（不过此时两个结果的物理地址不同）。