在test里面比较数字, 用 ==

1
2
3

<if test="mustCityQueryStatus == 1 and city != null and city != ''">
    AND city = #{city}
</if>

mybatis的一级缓存的生命周期是一个sqlSession

spring 结合mybatis 可以使用mybatis的一级缓存吗

spring 中执行 mybatis的sql执行上的执行对象是 SqlSessionTemplate, 下面看看它的创建策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
  notNull(executorType, "Property 'executorType' is required");

  this.sqlSessionFactory = sqlSessionFactory;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
  this.sqlSessionProxy = (SqlSession) newProxyInstance(
      SqlSessionFactory.class.getClassLoader(),
      new Class[] { SqlSession.class },
      new SqlSessionInterceptor());
}

使用了jdk的动态代理实现了切面的效果， 在 SqlSessionInterceptor, 下面看下 SqlSessionInterceptor 做了什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     final SqlSession sqlSession = getSqlSession(
         SqlSessionTemplate.this.sqlSessionFactory,
         SqlSessionTemplate.this.executorType,
         SqlSessionTemplate.this.exceptionTranslator);
     try {
       Object result = method.invoke(sqlSession, args);
       if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
         // force commit even on non-dirty sessions because some databases require
         // a commit/rollback before calling close()
         sqlSession.commit(true);
       }
       return result;
     } catch (Throwable t) {
       Throwable unwrapped = unwrapThrowable(t);
       if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
         Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
         if (translated != null) {
           unwrapped = translated;
         }
       }
       throw unwrapped;
     } finally {
       closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
     }
   }

它会为每个sql创建SqlSession，销毁SqlSession，也就说通过spring 使用Mybatis， mybatis的一级缓存并不会被使用到, 因为一个sql一个session.

所以, spring 继承mybatis 可以使用mybatis的一级缓存吗. 答案是不能

spring 结合mybatis使用二级缓存

在分布式环境下, 建议使用 ehcache 和redis , memacache 做二级缓存

key 怎么生成的呢

org.apache.ibatis.executor.BaseExecutor中生成的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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(rowBounds.getOffset());
   cacheKey.update(rowBounds.getLimit());
   cacheKey.update(boundSql.getSql());
   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
   if (parameterMappings.size() > 0 && parameterObject != null) {
     TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
     if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
       cacheKey.update(parameterObject);
     } else {
       MetaObject metaObject = configuration.newMetaObject(parameterObject);
       for (ParameterMapping parameterMapping : parameterMappings) {
         String propertyName = parameterMapping.getProperty();
         if (metaObject.hasGetter(propertyName)) {
           cacheKey.update(metaObject.getValue(propertyName));
         } else if (boundSql.hasAdditionalParameter(propertyName)) {
           cacheKey.update(boundSql.getAdditionalParameter(propertyName));
         }
       }
     }
   }
   return cacheKey;
 }

从上面看 namesapce + sql参数 + 分页参数 + sql + TypeHanlder.class 的hashCode一致, 就认为是同样的查询.

如何保证cache命中

在分布式环境中, 如果只有一个应用走cache, namesapce，TypeHanlder, parameterObject,必定是一致的, 其他的参数自然地传入即可。 这样是可以自然命中的。

如果是多个应用, 需要保证namesapce, TypeHanlder, parameterObject的hashCode一致, 需要在代码规范上下工夫， 团队内强制保证一致， 不然很容易保证不一致的情况. 比较理想的办法， 统一多个项目的数据库访问层, 对外提供service输出， 应用不直接访问数据库。 这种情况属于垂直拆分。 一般只有在业务中后期才这样做。

cache策略怎么设置

同时, 在使用时, 同样的sql针对不同的服务， 时效性是不一样的. 所以建议cache 默认不生效, 在单个sql上去开启cache. 同样的数据sql如果有cache场景不应可以定义两个id, 对应不同的cache策略

全局开启, 在指定namesapce开启. 这样就可以开启对应namesapce的缓存了. 但是这样会默认所有的sql都走cache， 所以可以在具体的需要强一致性的sql关闭缓存

todo

spring的缓存接口, 和mybatis的缓存区别, 如何使用

jpa的二级缓存

正确的web应用打开方式. entityService + cache. 禁止使用关联查询

关联查询和entityService哪个对数据库的压力大， 各自有什么好处和坏处(好处是entityService可以更准确地cache)

jpa的会话与事务

jpa的缓存原理与使用, 一级缓存， 二级缓存. 如何自定义缓存? 如何默认不开启缓存

dao层的缓存方案 VS 使用spring cahche 实现一致性的缓存 VS 通过编码的方式自定义缓存生成 + 缓存失效. 现在一般使用第二种 和 第三种, 第一种太重。 这三种方案， 如何做最佳实践呢

参考

mybatis 一级缓存, 二级缓存原理

spring的二级缓存分析

二级缓存的配置

logger 默认继承上级的lever, 子logger重载需要指明

additivity=”false” 不在父logger里面输出

todo logger最佳实践

todo logger收集最佳实践

https://cloud.tencent.com/developer/article/1058172

http://tech.lede.com/2017/06/30/rd/server/loggingHabit/

http://www.mybatis.org/mybatis-3/zh/logging.html

https://github.com/alibaba/druid/wiki/Druid%E4%B8%AD%E4%BD%BF%E7%94%A8log4j2%E8%BF%9B%E8%A1%8C%E6%97%A5%E5%BF%97%E8%BE%93%E5%87%BA

in 的数量过大， 会有栈溢出的bug, 见下面的链接

https://stackoverflow.com/questions/25310030/stackoverflow-with-hibernate-using-sql-in-id-id-id-id-id?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa

cache 解决方案 v1

id 查询

spring cache. Cacheable Cacheput + 遇到批量更新， 手动扩展spring cache 去异步更新 对应的cache

redis 作为 spring cache的分布式.

cache 进阶 v2

对于部分静态数据 + 不需要实时性的数据. 在redis cache的基础上使用jvm进程内cache.

注意点

务必在根据业务条件设计表的基础上, 做数据剥离. 分为频繁变更数据 + 偶尔变更数据 + 静态数据

类内部方法之间的调用不走cache

ehcache cache的对象必须实现了序列化接口

guavaCache CaffeineCache 默认支持每个cahce 细粒度的参数配置， 不同的cache 不同的配置

spring 的 GuavaCacheManager 和 CaffeineCachaManager 是不支持每个cache不同的细粒度参数配置的, 需要重写CacheManager

增加 cacheSpec 和 defaultSpec. cacheSpec是每个cache的配置， defaultSpec是默认的cache配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private Map<String, CacheBuilderSpec> cacheSpec = Maps.newHashMap();

private CacheBuilderSpec defaultSpec = CacheBuilderSpec.parse("expireAfterWrite=1d");

 public void setCacheSpec(Map<String, String> cacheSpecString) {
     if (MapUtils.isNotEmpty(cacheSpecString)) {
         HashMap<String, CacheBuilderSpec> cacheSpecification = Maps.newHashMap();
         for (Map.Entry<String, String> en : cacheSpecString.entrySet()) {
             cacheSpecification.put(en.getKey(), CacheBuilderSpec.parse(en.getValue()));
         }
         this.cacheSpec = cacheSpecification;
     }
 }

重写 createNativeGuavaCache, 以guavaCache 为例, 如果该cache存在配置, 取该cache的配置, 如果没有就取默认配置

1
2
3
4
5
6
7
8
9
10
11
12

/**
 * Create a native Guava Cache instance for the specified cache name.
 *
 * @param name the name of the cache
 * @return the native Guava Cache instance
 */
protected com.google.common.cache.Cache<Object, Object> createNativeGuavaCache(final String name) {
    CacheBuilderSpec spec = cacheSpec.get(name);
    final com.google.common.cache.Cache<Object, Object> cache = CacheBuilder.from(spec == null ? defaultSpec : spec).recordStats().build();
    return cache;
}

然后使用以下配置就可以了, 包名这里涉及到公司信息, 省略不计

1
2
3
4
5
6
7
8
9
10
11
12

<cache:annotation-driven cache-manager="cacheManager"/>

<bean id="cacheManager" class="com.*.*.*.*.cache.GuavaCacheManager">
    <property name="cacheSpec">
        <map>
            <entry key="KEY1" value="expireAfterWrite=10m"/>
            <entry key="KEY2" value="expireAfterWrite=10m"/>
            <entry key="KEY3" value="expireAfterWrite=10m"/>
        </map>
    </property>
</bean>

也可以使用java bean的配置, 这里不赘述

如何让类内部调用增强类注解生效

自动注入self 生效的场景, 直接autowired self; beanFactory 亦可

cache

transaction

自定义注解

…

self不能生效的, 包括autowired 和 beanFactory

async 会导致注入self失效, 而且有时候导致内部循环依赖,启动失败

http://start.spring.io/