目前项目中用到Spring的地方很多,很多功能都能在sping中找到解决方案,正如我现在想要说的缓存实现,Spring Cache已经为我们提供了很好的解决方案,并且提供了默认实现,增加几个注解立刻就能使用,确实挺好,但是在实际使用过程中还是觉得不太方便,主要就是因为要保持缓存注解方法间的名称保持一致,在@CacheEvict中需要指定所有需要清除的缓存信息(通过name,key等属性),方法比较多、比较分散的时候维护难度就会随之提高,稍有不慎就会导致数据的不一致;故此引出今天分享讨论的一种缓存实现:“通过Mybatis的拦截机制实现自动缓存”。
该实现的逻辑就是参考mybatis的二级缓存,针对使用sql语句查询的dao层,思路就是拦截所有的DAO层方法,解析方法对应的sql语句,对sql语句进行分类处理,分类很简单就两类,query类和update类,query主要是指select语句,update值得就是insert、delete喝update语句了;
对于query类,方法第一次执行的时候查询数据库,将查询结果缓存到cache中,之后在此调用该方法的时候直接从cache中查询;对于update类方法,就是解析sql中的表名,当方法执行成功后,根据表名将cache中所有涉及到该表的所有存储都清除,这样当有query类的方法sql中包含该表的缓存就不存在了,需要重新从数据库查询,然后再缓存,这样也就保证了数据的一致性。
逻辑很简单,下面就说一下实现:
下面是通过xml方式配置sqlSessionFactory的xml片段,注释部分是常规的方式,我们不用,改为指向我们自定义的Factory类:MyBatisCacheSqlSessionFactory,指定工厂方法为:getSqlSessionFactory,这个方法需要两个参数,一个就是常规方法定义的DataSource,再有一个就是cacheService,也就是一个单独的缓存服务,我这里用的redis。
<!-- 工厂类 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations"> <array> <value>classpath*:mapper/*.xml</value> </array> </property> <property name="typeAliasesPackage" value="com.xbniao.uc.dao.po"/> <property name="plugins"> <array> <bean class="com.github.pagehelper.PageHelper"> <property name="properties"> <value> dialect=mysql reasonable=true </value> </property> </bean> </array> </property> </bean> --> <bean id="sqlSessionFactory" class="com.mingjia.dao.mybatisCache.MyBatisCacheSqlSessionFactory" factory-method="getSqlSessionFactory"> <constructor-arg name="datasource" ref="dataSource"></constructor-arg> <constructor-arg name="cacheService" ref="mybatisCacheService"></constructor-arg> </bean> <bean id="mybatisCacheService" class="com.mingjia.dao.mybatisCache.MybatisCacheService" init-method="init" > <property name="cacheOpen" value="${cache.isOpen}"></property> <property name="sentinelIp" value="${cache.redis.sentinelIp}"></property> <property name="sentinelMaster" value="${cache.redis.sentinelMaster}"></property> <property name="masterConnectionPoolSize" value="${cache.redis.masterConnectionPoolSize}"></property> <property name="slaveConnectionPoolSize" value="${cache.redis.slaveConnectionPoolSize}"></property> <property name="masterConnectionMinimumIdleSize" value="${cache.redis.masterConnectionMinimumIdleSize}"></property> <property name="slaveConnectionMinimumIdleSize" value="${cache.redis.slaveConnectionMinimumIdleSize}"></property> <property name="autoUnLockTime" value="${cache.redis.autoUnLockTime}"></property> <property name="connectTimeout" value="${cache.redis.connectTimeout}"></property> </bean>
上边是xml的配置方式,注解的方式也可以,原理都是一样的,再有上边配置的mybatisCacheService bean可以根据自己的实际情况更换,喝本文描述的缓存策略实现没有必然关系。
下面看下Factory类的工厂方法:
public static SqlSessionFactory getSqlSessionFactory(DataSource datasource, MybatisCacheService cacheService) { try { MyBatisInterceptor myBatisCache = new MyBatisInterceptor(cacheService); Properties p = new Properties(); p.setProperty("offsetAsPageNum", "true"); p.setProperty("rowBoundsWithCount", "true"); p.setProperty("reasonable", "true"); myBatisCache.setProperties(p); SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); sqlSessionFactoryBean.setDataSource(datasource); sqlSessionFactoryBean.setPlugins(new Interceptor[]{myBatisCache}); PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(); sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/mapper/*.xml")); Collection l = sqlSessionFactoryBean.getObject().getConfiguration().getMappedStatements(); Set<String> allClassName=new HashSet<String>(); for (Object m : l) { if (m instanceof MappedStatement) { MappedStatement ms = (MappedStatement) m; //System.out.println("=============="+ms.getId()); String sql = ms.getBoundSql(null).getSql(); if (StringUtils.containsIgnoreCase(sql, "select")) { Statement statement = CCJSqlParserUtil.parse(sql); Select selectStatement = (Select) statement; TablesNamesFinder tablesNamesFinder = new TablesNamesFinder(); List<String> tableList = tablesNamesFinder.getTableList(selectStatement); Set<String> tables = tables(tableList); //存储数据库表和mapper中的方法对应关系,数据库表中的数据发生过更改,可以知道要清除哪个方法产生的缓存 methods(MyBatisCacheConfiguration.TABLE_METHOD, tables, ms.getId()); } else if (StringUtils.containsIgnoreCase(sql, "insert")) { // System.out.println(sql.split("\\s+")[2]); } else if (StringUtils.containsIgnoreCase(sql, "delete")) { // System.out.println(sql.split("\\s+")[2]); } else if (StringUtils.containsIgnoreCase(sql, "update")) { // System.out.println(sql.split("\\s+")[1]); } //记录所有的Mapper类 allClassName.add(StringUtils.substring(ms.getId(),0,StringUtils.lastIndexOf(ms.getId(),'.'))); } } //mapper中含有@MyBatisCache(disCache = true)的方法,直接查数据库 getDisCacheMethod(MyBatisCacheConfiguration.DIS_CACHE_METHOD,allClassName); return sqlSessionFactoryBean.getObject(); }catch(Exception e){ e.printStackTrace(); } return null; }
工厂方法内容:1,创建自定义的mybatis拦截器mybatisCache;2,创建SqlSessionFactory,并将拦截器配置进去;3,解析mapper下所有的xml文件,将query类型的sql中的表名提取出来并和对应的mapper方法关联起来保存到内存中(MyBatisCacheConfiguration.TABLE_METHOD),此外还有一个MyBatisCacheConfiguration.DIS_CACHE_METHOD,保存的是不需要缓存的方法(通过自定义注解@MyBatisCache(disCache = true)来标示),对缓存策略没有什么影响,就不做说明了。3,最后通过sqlSessionFactoryBean的getObject方法返回实例。
然后再看下自定义的mybatis拦截器的实现,缓存功能逻辑都在这里边了:
public MyBatisInterceptor(MybatisCacheService cacheService) { this.cacheService = cacheService; } @Override public Object intercept(Invocation invocation) throws Throwable { try { Object[] args = invocation.getArgs(); MappedStatement mappedStatement = (MappedStatement) args[0]; Object parameter = args[1]; BoundSql boundSql = mappedStatement.getBoundSql(parameter); String sql = boundSql.getSql(); String invocationMethodName = invocation.getMethod().getName(); if (StringUtils.equals("query", invocationMethodName)) { //判断方法是否在非缓存集合,在则直接查询数据库 if (contains(mappedStatement.getId())) { log.info("读取数据库"); if (SqlUtil.getLocalPage() != null) { log.info("分页拦截"); return pageIntercept(invocation); } else { log.info("普通拦截"); return invocation.proceed(); } } else { boolean isPage = false; String method = MyBatisCacheConfiguration.MYBATIS_CACHE_PREFIX+DigestUtils.md5Hex(mappedStatement.getId()); //方法参数的变化会自动体现到CacheKey上 String cacheKey = createCacheKey(mappedStatement, parameter, (RowBounds) args[2], boundSql).toString(); StringBuffer sb = new StringBuffer(cacheKey); Object parameterObject = boundSql.getParameterObject(); //判断方法参数是否为空,不为空需要将参数信息写入sb,作为key的一部分 if (parameterObject != null) { String parameterObjectType = parameterObject.getClass().getSimpleName(); //参数信息 if (SqlUtil.getLocalPage() != null) { isPage = true; sb.append(":").append(parameterObjectType); //拦截前获得分页数据 sb.append(":").append("pageNum"); sb.append(":").append(SqlUtil.getLocalPage().getPageNum()); sb.append(":").append("pageSize"); sb.append(":").append(SqlUtil.getLocalPage().getPageSize()); } } log.info(method); log.info(sb.toString()); String key = DigestUtils.md5Hex(sb.toString()); Map<String, Object> map = getCache(method); if (map.get(key) == null) { Object obj = null; if (isPage) { obj = pageIntercept(invocation); setCache(method, key, parsePage((Page) obj)); } else { obj = invocation.proceed(); setCache(method, key, obj); } log.info("读取数据库"); return obj; } else { log.info("读取缓存"); if (isPage) { Page page = parseMap((Map<String, Object>) map.get(key)); if (SqlUtil.getLocalPage() != null) SqlUtil.clearLocalPage(); return page; } else { return map.get(key); } } } } else if (StringUtils.equals("update", invocation.getMethod().getName())) { if (StringUtils.containsIgnoreCase(sql, "insert")) { Set<String> m = MyBatisCacheConfiguration.TABLE_METHOD.get(sql.split("\\s+")[2]); for (String mapName : m) { delCache(mapName); } } else if (StringUtils.containsIgnoreCase(sql, "delete")) { Set<String> m = MyBatisCacheConfiguration.TABLE_METHOD.get(sql.split("\\s+")[2]); for (String mapName : m) { delCache(mapName); } } else if (StringUtils.containsIgnoreCase(sql, "update")) { Set<String> m = MyBatisCacheConfiguration.TABLE_METHOD.get(sql.split("\\s+")[1]); for (String mapName : m) { delCache(mapName); } } return invocation.proceed(); } else { return invocation.proceed(); } } catch (Exception e) { e.printStackTrace(); return invocation.proceed(); } }
主要逻辑就是对query类和update类的处理,“query”的逻辑主要是‘ else{}’部分,逻辑在最开始已经说了,就是缓存数据,之后cache中没有的才去查数据库;“update”部分处理都是一样的,就是从sql中提取出表名,根据表明从MyBatisCacheConfiguration.TABLE_METHOD中得到方法在缓存中的key,最终清除缓存。
通过这个实现,默认就对所有的mapper方法进行了缓存(如果有不想缓存的加上@MyBatisCache(disCache = true)),不用每个方法都去添加一遍@Cacheable注解,而且不用关心name,key等属性的维护,自动维护数据的一致性;功能上和mybatis的二级缓存逻辑没啥区别,主要就是不用在xml文件中添加cache的标签了,再有就是集成了PageHelper插件,解决了分页插件和mybatis的二级缓存联合使用的数据一致性问题,对于分页数据也可以正常缓存。
该实现很简单,功能也是相对简陋,当然我说的方式也应该可以通过spring cache的自定义方式来实现,再有对于分页插件和Mybatis的二级缓存结合使用问题的解决应该有更简单的解决办法;在此主要是抛砖引玉,希望有想法的朋友分享下好的想法。
以上的描述内容为最初的实现,代码实现以及配置做了较大改动,如将缓存拦截器与分页插件分离,同时支持PageHelper4和PageHelper5;增加了guava cache的默认cache服务实现等,欢迎指教!
再有,关于自动缓存插件和其他插件(比如分页插件)的执行顺序问题,我在“说说MyBatis插件执行顺序(PageHelper 5 问题)”进行了说明。