数据库缓存mybatis,redis

  • 简介

    处理并发问题的重点不在于你的设计是怎样的，而在于你要评估你的并发，并在并发范围内处理。
    你预估你的并发是多少，然后测试r+m是否支持。缓存的目的是为了应对普通对象数据库的读写限制，依托与nosql的优势进行高速读写。

    redis本身也有并发瓶颈。所以你要把读写和并发区分开来处理。只读业务是不是可以用mysql分布做只读库和只读表，进行读写分离+库分布，
    拆库拆表不能搞定再考虑上多级缓存
    任何设计，你外面套一层，就多一倍的维护成本，缓存不是万金油。

    这里多级缓存主要指的是二级缓存技术，也就是依托nosql的高速读取优势。

  • mybatis

    如果底层ORM框架用的是mybatis框架，就可以用mybatis自带的缓存机制，mybatis自带一级缓存和二级缓存。
    一级缓存指的是sqlsession缓存，是session级别缓存
    二级缓存指的是mapper级别的缓存，同一个namespace公用这一个缓存，所以对SqlSession是共享的,这里的namespace指的是xml里的命名空间
    mybatis默认开启一级缓存，二级缓存默认不开启，需要手动开启。

    一级缓存
    mybatis的一级缓存是SqlSession级别的缓存，在操作数据库的时候需要先创建SqlSession会话对象，在对象中有一个HashMap用于存储缓存数据，
    此HashMap是当前会话对象私有的，别的SqlSession会话对象无法访问。
    具体流程：

    　　　　　　1.第一次执行select完毕会将查到的数据写入SqlSession内的HashMap中缓存起来

    　　　　　　2.第二次执行select会从缓存中查数据，如果select相同切传参数一样，那么就能从缓存中返回数据，不用去数据库了，从而提高了效率

    　　注意事项：

    　　　　　　1.如果SqlSession执行了DML操作（insert、update、delete），并commit了，那么mybatis就会清空当前SqlSession缓存中的所有缓存数据，
    这样可以保证缓存中的存的数据永远和数据库中一致，避免出现脏读

    　　　　　　2.当一个SqlSession结束后那么他里面的一级缓存也就不存在了，mybatis默认是开启一级缓存，不需要配置

    　　　　　　3.mybatis的缓存是基于[namespace:sql语句:参数]来进行缓存的，意思就是，SqlSession的HashMap存储缓存数据时，
    是使用[namespace:sql:参数]作为key，查询返回的语句作为value保存的。
    例如：-1242243203:1146242777:winclpt.bean.userMapper.getUser:0:2147483647:select * from user where id=?:19

    二级缓存
    二级缓存是mapper级别的缓存，也就是同一个namespace的mappe.xml，当多个SqlSession使用同一个Mapper操作数据库的时候，得到的数据会缓存在同一个二级缓存区域

    二级缓存默认是没有开启的，需要在xml配置setting全局参数中配置开启二级缓存

    <settings>
        <setting name="cacheEnabled" value="true"/><!--开启mybatis缓存 默认是false：关闭二级缓存--><settings>

    然后再具体的xml里配置

    <cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/>当前mapper下所有语句开启二级缓存

    这里配置了一个LRU缓存，并每隔60秒刷新，最大存储512个对象，而却返回的对象是只读的

    若想禁用当前select语句的二级缓存，添加useCache="false"修改如下：

    <select id="getCountByName" parameterType="java.util.Map" resultType="INTEGER" statementType="CALLABLE" useCache="false">

    具体流程：

    　　　　　　1.当一个sqlseesion执行了一次select后，在关闭此session的时候，会将查询结果缓存到二级缓存

    　　　　　　2.当另一个sqlsession执行select时，首先会在他自己的一级缓存中找，如果没找到，就回去二级缓存中找，
    找到了就返回，就不用去数据库了，从而减少了数据库压力提高了性能　

    注意事项：

    　　　　　　1.如果SqlSession执行了DML操作（insert、update、delete），并commit了，那么mybatis就会清空当前mapper缓存中的所有缓存数据，这样可以保证缓存中的存的数据永远和数据库中一致，避免出现脏读

    　　　　　　2.mybatis的缓存是基于[namespace:sql语句:参数]来进行缓存的，意思就是，SqlSession的HashMap存储缓存数据时，是使用[namespace:sql:参数]作为key，查询返回的语句作为value保存的。例如：-1242243203:1146242777:winclpt.bean.userMapper.getUser:0:2147483647:select * from user where id=?:19

  • redis

    这里我实现了spring集成Jedis，并通过解析key实现自定义缓存失效时间。官网可以下载linux下的redis，没有windows下的，但micro开发小组在github上维护了windows环境下的redis，
    https://github.com/MSOpenTech/redis/releases

    pom.xml引入依赖
      <!--redis start-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
 <!--redis end-->

    在xml配置文件里配置各种bean

     <!--JedisPool线程池-->
    <!--redis是单线程的，为了满足java多线程需求，jedis引入线程池的概念-->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="100"/>
        <property name="maxTotal" value="700"/>
        <property name="maxWaitMillis" value="1000"/>
        <property name="testOnBorrow" value="false"/>
    </bean>

    <!--创建redis连接工厂-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.hostname}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value="${redis.password}"/>
        <property name="database" value="${redis.database}"/>
        <property name="poolConfig" ref="jedisPool"/>
    </bean>

    <!--配置redistempLate -->
    <bean id="redistempLate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
        <!--<property name="defaultSerializer">-->
            <!--<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>-->
        <!--</property>-->
    </bean>
    <!--配置缓存配置信息-->
    <!--这是用的spring的cacheManager，不支持缓存有效期动态配置-->
    <!--<bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">-->
        <!--&lt;!&ndash;配置redis模板&ndash;&gt;-->
        <!--<constructor-arg name="redisOperations" ref="redistempLate"/>-->
        <!--&lt;!&ndash;默认缓存失效时间&ndash;&gt;-->
        <!--<property name="defaultExpiration" value="120"/>-->
        <!--&lt;!&ndash;是否使用前缀&ndash;&gt;-->
        <!--<property name="usePrefix" value="false"/>-->

    <!--</bean>-->

    <!--手动实现的redisCacheManager，支持缓存有效期动态配置，可在@Cacheable中的value属性添加有效时间-->
    <bean id="myRedisCacheManager" class="com.djkj.demo.common.MyRedisCacheManager">
        <!--配置redis模板-->
        <constructor-arg name="redisOperations" ref="redistempLate"/>
        <!--默认缓存失效时间-->
        <property name="defaultExpiration" value="120"/>
        <!--是否使用前缀-->
        <property name="usePrefix" value="false"/>
        <!--缓存名字和有效期的分隔符-->
        <property name="separator" value="#"/>

        <!-- 多个缓存有效期，一般的单个工程可以省略此项 -->
        <!--<property name="expires">-->
            <!--<map>-->
                <!--<entry key="caiya_a" value="1800"/>-->
            <!--</map>-->
        <!--</property>-->

    </bean>

    <!--配置RedisCacheConfig，redis缓存启动类-->
    <bean id="redisCacheConfig" class="com.djkj.demo.common.RedisCacheConfig">
        <constructor-arg ref="jedisConnectionFactory"/>
        <constructor-arg ref="redistempLate"/>
        <constructor-arg ref="myRedisCacheManager"/>
    </bean>

    这里jedisPool的数据源地址根据实际情况设置，reis默认port为6379，如果你的redis设置了校验密码则这里需要否则不用，database设置的0，redis默认生成15个数据库，0表示采用的是第一个。

    最主要的是redisCacheConfig缓存启动类和myRedisCacheManager缓存管理类，启动类里设置了缓存的key的生成策略，管理类主要实现了自定义有效期
    redisCacheConfig 
    package com.djkj.demo.common;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

import java.lang.reflect.Method;

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {

    private volatile JedisConnectionFactory jedisConnectionFactory;
    private volatile RedisTemplate<String,String> redisTemplate;
    private volatile RedisCacheManager redisCacheManager;


    public RedisCacheConfig(){
        super();
    }

    public RedisCacheConfig(JedisConnectionFactory jedisConnectionFactory
            ,RedisTemplate<String,String> redisTemplate, RedisCacheManager redisCacheManager){
        this.jedisConnectionFactory = jedisConnectionFactory;
        this.redisTemplate = redisTemplate;
        this.redisCacheManager = redisCacheManager;
    }

    public JedisConnectionFactory getJedisConnectionFactory() {
        return jedisConnectionFactory;
    }

    public RedisTemplate<String, String> getRedisTemplate() {
        return redisTemplate;
    }

    public RedisCacheManager getRedisCacheManager() {
        return redisCacheManager;
    }
    
　　//主键生成策略
    @Bean
        public KeyGenerator customKeyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                StringBuilder stringBuilder=new StringBuilder();
                stringBuilder.append(o.getClass().getName());
                stringBuilder.append(method.getName());
                for (Object obj : objects) {
                    stringBuilder.append(obj.toString().hashCode());
                }
                System.out.println(stringBuilder.toString());
                return stringBuilder.toString();
            }
        };
    }
}

    myRedisCacheManager

    package com.djkj.demo.common;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.cache.Cache;
import org.springframework.data.redis.cache.RedisCache;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCachePrefix;
import org.springframework.data.redis.core.RedisOperations;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.util.Collection;
import java.util.Collections;
import java.util.regex.Pattern;

public class MyRedisCacheManager extends RedisCacheManager {

    private static final Logger logger = Logger.getLogger(MyRedisCacheManager.class);

    private static final ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");

    private static final Pattern pattern = Pattern.compile("[+\\-*/%]");

    private String defaultCacheName;

    private String separator = "#";

    public MyRedisCacheManager(RedisOperations redisOperations) {
        this(redisOperations, Collections.<String>emptyList());
    }

    public MyRedisCacheManager(RedisOperations redisOperations, Collection<String> cacheNames) {
        super(redisOperations, cacheNames);
    }

    @Override
    public Cache getCache(String name) {
        String cacheName="";
        String expirationStr="";
        Long expiration=0L;
        String[] params = name.split(getSeparator());
        if(params.length>=1){
            cacheName = params[0];
        }
        if(params.length>=2){
            expirationStr = params[1];
        }

        if(StringUtils.isBlank(cacheName)){
            cacheName = defaultCacheName;
        }
        Cache cache = (RedisCache) super.getCache(cacheName);
        if (cache == null) {
            return null;
        }

        if(StringUtils.isNotEmpty(expirationStr)){
            try {
                expiration = Double.valueOf(expirationStr).longValue();
            }catch (Exception e){
                logger.error("expiration exchange failed!");
            }
        }

        if (expiration==null || expiration == 0L) {
            logger.warn("Default expiration time will be used for cache '{}' because cannot parse '{}', cacheName : " + cacheName + ", name : " + name);
            return cache;
        }

        return new RedisCache(cacheName, (isUsePrefix() ? getCachePrefix().prefix(cacheName) : null), getRedisOperations(), expiration);
    }


    public String getSeparator() {
        return separator;
    }

    public void setSeparator(String separator) {
        this.separator = separator;
    }

    private Long getExpiration(final String name, final int separatorIndex) {
        Long expiration = null;
        String expirationAsString = name.substring(separatorIndex + 1);
        try {
            // calculate expiration, support arithmetic expressions.
            if(pattern.matcher(expirationAsString).find()){
                expiration = (long) Double.parseDouble(scriptEngine.eval(expirationAsString).toString());
            }else{
                expiration = Long.parseLong(expirationAsString);
            }
        } catch (NumberFormatException ex) {
            logger.error(String.format("Cannnot separate expiration time from cache: '%s'", name), ex);
        } catch (ScriptException e) {
            logger.error(String.format("Cannnot separate expiration time from cache: '%s'", name), e);
        }

        return expiration;
    }

    @Override
    public void setUsePrefix(boolean usePrefix) {
        super.setUsePrefix(usePrefix);
    }

    @Override
    public void setCachePrefix(RedisCachePrefix cachePrefix) {
        super.setCachePrefix(cachePrefix);
    }

    public void setDefaultCacheName(String defaultCacheName) {
        this.defaultCacheName = defaultCacheName;
    }
}

    根据符号  #  将缓存名切割，前面的作为缓存名，后面的作为有效期


  • 具体应用方法

    在service层通过@Cacheable注解使用缓存
    //设置缓存有效时间和刷新时间
    @Cacheable(value="testPojoCache" ,keyGenerator = "customKeyGenerator")
    @Override
    public List<TestPojo> query(TestPojo bean) {
        List<TestPojo> testList = testPojoMapper.query(bean);
        if(testList.size()>0){
            for(TestPojo pojo:testList){
                pojo.setTime(sdf.format(new Date()));
                pojo.setAttr1(bean.getAttr1());
            }
        }
        return testList;
    }

    testPojoCache表示缓存name，30表示有效期，keyGenerator表示key的生成策略，用的是在配置类里通过@Bean配置的bean。

  • 进阶说明

    spring通过集成jedis的方式有别于直接通过获取Jedis对象的set方法，通过jedis.set(key,value)只会在redis服务器产生一条数据，而用注解会产生两条数据，以上面的例子为例，首先会生成一条key为testPojoCache的缓存数据，value内容是一个集合，放的是通过生存策略生成的值，再以这生成的值为key生成一条缓存数据，value为这个service方法返回的对象数据。当你根据不同的条件参数调用service的方法，都会在testPojoCache里存放键值，然后再创建缓存。那怎么调用缓存呢？在调用service方法前，redis会根据生成策略生成的值到testPojoCache里去找，看有没有。若果有，根据键值获取缓存；如果没有就查询数据库。


posted @ 2019-02-21 16:30  颜色不一样的烟火  阅读(1033)  评论(0)  编辑  收藏  举报