问题描述:同一事物下,主方法通过主键查询得到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使用相同方式查询数据时还是会取到未调整的数据(不过此时两个结果的物理地址不同)。