Mybatis+Redis緩存

mybatis 配置 基於 springboot 

mybatis:
  configuration:
    lazy-loading-enabled: false  #全局性設置懶加載。如果設爲‘false’，則所有相關聯的都會被初始化加載。
    aggressive-lazy-loading: false #true時懶加載的對象可能被任何懶屬性全部加載，否則，每個屬性都按需加載
    cache-enabled: true #開啓二級緩存
  mapper-locations: classpath:mapping/*.xml

 使用： Mapper類上添加接口

@CacheNamespace(implementation = MybatisRedisCache.class)

實現mybatis的cache接口

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;

import java.util.concurrent.locks.ReadWriteLock;

public class MybatisRedisCache implements Cache {

    Logger logger = LoggerFactory.getLogger(MybatisRedisCache.class);

    private static final String PREFIX = "MyBatisCache_";

    private String id;

    private static RedisTemplate redisTemplate;

    public static void setRedisTemplate(RedisTemplate redisTemplate){
        MybatisRedisCache.redisTemplate = redisTemplate;
    }

    public MybatisRedisCache(String id){
        logger.debug("id="+id);
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public void putObject(Object key, Object value) {

 //       RedisConnection rc = redisTemplate.getConnectionFactory().getConnection();
        if(key != null && value != null){
            redisTemplate.opsForValue().set(PREFIX + key,value);
        }else {
            logger.debug(" cache key : " + PREFIX + key);
            logger.debug(" cache value : " + PREFIX + value);
        }

 //       rc.close();
    }

    @Override
    public Object getObject(Object o) {
//        RedisConnection rc = redisTemplate.getConnectionFactory().getConnection();
 //
        logger.debug("get key : " + o);
        Object value = null;
        try {
            value = redisTemplate.opsForValue().get(PREFIX + o);
        }catch (Exception e){
            logger.debug("get key : " + e.getClass().getName());
        }
        return value;
    }

    @Override
    public Object removeObject(Object key) {
//        RedisConnection rc = redisTemplate.getConnectionFactory().getConnection();
//        JdkSerializationRedisSerializer jsrs = new JdkSerializationRedisSerializer();
          Object obj = redisTemplate.opsForValue().get(key);
            redisTemplate.delete(key);
   //     logger.debug("remove key " + key);
        return obj;
    }

    @Override
    public void clear() {
        long l = redisTemplate.delete(redisTemplate.keys(PREFIX+"*"));
        logger.debug("clear"+l);
    }

    @Override
    public int getSize() {
        int num = redisTemplate.keys(PREFIX+"*").size();
        return num;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return null;
    }
}

 redis配置

import com.oranth.applicationmarket.cache.MybatisRedisCache;
import com.oranth.applicationmarket.utils.serializer.FastJsonRedisSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
@PropertySource("classpath:redis.properties")
public class RedisConfig {
	@Value("${redis.hostName}")
    private String hostName;
 
    @Value("${redis.password}")
    private String password;
 
    @Value("${redis.port}")
    private Integer port;
    
//    @Value("redis.cluster.port.num")   
//    private Integer num;
    	
    @Value("${redis.maxIdle}")
    private Integer maxIdle;
 
    @Value("${redis.timeout}")
    private Integer timeout;
 
    @Value("${redis.maxTotal}")
    private Integer maxTotal;
 
    @Value("${redis.maxWaitMillis}")
    private Integer maxWaitMillis;
 
    @Value("${redis.minEvictableIdleTimeMillis}")
    private Integer minEvictableIdleTimeMillis;
 
    @Value("${redis.numTestsPerEvictionRun}")
    private Integer numTestsPerEvictionRun;
 
    @Value("${redis.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;
 
    @Value("${redis.testOnBorrow}")
    private boolean testOnBorrow;
 
    @Value("${redis.testWhileIdle}")
    private boolean testWhileIdle;
    
    @Value("${redis.minTotal}")
    private Integer minTotal;
    
    /**
     * 連接池 配置
     * @return
     */
    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大連接數
        jedisPoolConfig.setMaxTotal(maxTotal);
        //最小空閒連接數
        jedisPoolConfig.setMinIdle(minTotal);       
        //當池內沒有可用的連接時，最大等待時間
        jedisPoolConfig.setMaxWaitMillis(minEvictableIdleTimeMillis);
        //------其他屬性根據需要自行添加-------------
        return jedisPoolConfig;
    }
    /**
     * jedis連接工廠
     * @param jedisPoolConfig
     * @return
     */
    @Bean
    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        //單機版jedis
        RedisStandaloneConfiguration redisStandaloneConfiguration =
                new RedisStandaloneConfiguration();
        //設置redis服務器的host或者ip地址
        redisStandaloneConfiguration.setHostName(hostName);
        //設置默認使用的數據庫
        redisStandaloneConfiguration.setDatabase(0);
        //設置密碼
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        //設置redis的服務的端口號
        redisStandaloneConfiguration.setPort(port);
        
        //獲得默認的連接池構造器(怎麼設計的，爲什麼不抽象出單獨類，供用戶使用呢)
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
                (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();
        //指定jedisPoolConifig來修改默認的連接池構造器（真麻煩，濫用設計模式！）
        jpcb.poolConfig(jedisPoolConfig);
        //通過構造器來構造jedis客戶端配置
        JedisClientConfiguration jedisClientConfiguration = jpcb.build();
        //單機配置 + 客戶端配置 = jedis連接工廠
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    }
    
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 設置值（value）的序列化採用FastJsonRedisSerializer。
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);
        // 設置鍵（key）的序列化採用StringRedisSerializer。
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

//        //key序列化方式
//        template.setKeySerializer(redisSerializer);
//        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
//        //value序列化
//        template.setValueSerializer(new JdkSerializationRedisSerializer());
//        //value hashmap序列化
//        template.setHashValueSerializer(redisSerializer);
//        //key haspmap序列化
//        template.setHashKeySerializer(redisSerializer);
          MybatisRedisCache.setRedisTemplate(template);
        return template;
    }
//    @Bean
//    public RedisClusterConfiguration redisClusterConfiguration(JedisPoolConfig jedisPoolConfig){
//    	RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
//    	List<RedisNode> nodes = new ArrayList<RedisNode>();
//    	for(int i = port.intValue() + 1;i < num.intValue(); ++i){
//    		RedisNode redisNode =  new RedisNode(hostName,i);
//    		nodes.add(redisNode);
//    	}
//    	redisClusterConfiguration.setClusterNodes(nodes);
//    	
//    	
//    	
//    	return redisClusterConfiguration;
//    }
    
    
    
    /**
     * 非連接池模式
     * @return
     */
/*    @Bean
    public JedisConnectionFactory JedisConnectionFactory(){
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration ();
        redisStandaloneConfiguration.setHostName(hostName);
        redisStandaloneConfiguration.setPort(port);
        //由於我們使用了動態配置庫,所以此處省略
        //redisStandaloneConfiguration.setDatabase(database);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
        jedisClientConfiguration.connectTimeout(Duration.ofMillis(timeout));
         //序列化 反序列化
        JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration,
                jedisClientConfiguration.build());
        
        return factory;
    }*/
}