首页手记补习系列(14)-springboot redis...

补习系列(14)-springboot redis 整合-数据读写

标签：

Java SpringBoot Redis

[TOC]

一、简介

在补习系列(A3)-springboot redis 与发布订阅一文中，我们介绍了使用 Redis 实现消息订阅发布的机制，并且给出了一个真实用例。

然而，绝大多数场景下 Redis 是作为缓存被使用的(这是其主要优势)。除此之外，由于Redis 提供了 AOF以及RDB两种持久化机制，某些情况下也可以作为临时数据库使用。

本次将介绍 SpringBoot 中如何使用 Redis 进行缓存读写。

Redis 的基本命令

在学习之前，需要先了解一些Redis 的基本命令，可以参考这里

http://www.redis.cn/

二、SpringBoot Redis 读写

A. 引入 spring-data-redis

添加依赖


 <!-- redis -->

  <dependency>

   <groupId>org.springframework.boot</groupId>

   <artifactId>spring-boot-starter-data-redis</artifactId>

   <version>${spring-boot.version}</version>

  </dependency>

spring-boot-starter-redis在1.4版本已经废弃

配置redis连接

application.properties


# redis 连接配置

spring.redis.database=0 

spring.redis.host=127.0.0.1

spring.redis.password=

spring.redis.port=6379

spring.redis.ssl=false



# 连接池最大数

spring.redis.pool.max-active=10 

# 空闲连接最大数

spring.redis.pool.max-idle=10

# 获取连接最大等待时间(s)

spring.redis.pool.max-wait=600000

B. 序列化

同样，我们需要指定 JSON作为 Key/HashKey/Value的主要方式：


    /**

     * 序列化定制

     * 

     * @return

     */

    @Bean

    public Jackson2JsonRedisSerializer<Object> jackson2JsonSerializer() {

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(

                Object.class);



        // 初始化objectmapper

        ObjectMapper mapper = new ObjectMapper();

        mapper.setSerializationInclusion(Include.NON_NULL);

        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        return jackson2JsonRedisSerializer;

    }



   /**

     * 操作模板

     * 

     * @param connectionFactory

     * @param jackson2JsonRedisSerializer

     * @return

     */

    @Bean

    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory connectionFactory,

            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer) {



        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

        template.setConnectionFactory(connectionFactory);



        // 设置key/hashkey序列化

        RedisSerializer<String> stringSerializer = new StringRedisSerializer();

        template.setKeySerializer(stringSerializer);

        template.setHashKeySerializer(stringSerializer);



        // 设置值序列化

        template.setValueSerializer(jackson2JsonRedisSerializer);

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();



        // template.setValueSerializer(new

        // GenericToStringSerializer<Object>(Object.class));

        return template;

    }

Jackson2JsonRedisSerializer是Jackson转换的桥接器；

RedisTemplate是用于读写的主要操作类；

C. 读写样例

首先定义一个Pet实体类


public class RedisPet {



    private String name;

    private String type;

... ignore get set

利用RedisTemplate封装一层Repository，如下：


    @Repository

    public static class PetRepository {



        private static final String KEY = "Pets";



        @Autowired

        private RedisTemplate<String, Object> redisTemplate;

        private HashOperations<String, String, Object> hashOperations;



        @PostConstruct

        private void init() {

            hashOperations = redisTemplate.opsForHash();

        }



        public void add(RedisPet pet) {

            hashOperations.put(KEY, pet.getName(), pet);

        }



        public RedisPet find(String name) {

            return (RedisPet) hashOperations.get(KEY, name);

        }



        public Map<String, Object> findAll() {

            return hashOperations.entries(KEY);

        }

        

        public void clear() {

            hashOperations.getOperations().delete(KEY);

        }

    }

在**PetRepository **的实现中，我们利用Hash结构来存储 Pet信息(Pet.name是key)

分别实现了添加(add)/查找(get)/清除(clear)等方法。

最后，实现读写调用：




@Service

public class RedisDataOperation {



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



    @Autowired

    private PetRepository petRepo;





    @PostConstruct

    public void start() {



        RedisPet pet1 = new RedisPet("Polly", "Bird");

        RedisPet pet2 = new RedisPet("Tom", "Cat");



        //写入宠物信息

        petRepo.add(pet1);

        petRepo.add(pet2);



        //打印宠物信息

        logger.info("polly {}", JsonUtil.toJson(petRepo.find("Polly")));

        logger.info("pets  {}", JsonUtil.toJson(petRepo.findAll()));



        //清空

        petRepo.clear();

    }

上面的代码在应用启动时，会写入两个Pet信息，之后完成清理，控制台输出如下：


RedisDataOperation : polly {"name":"Polly","type":"Bird"}

RedisDataOperation : pets {"Tom":{"name":"Tom","type":"Cat"},"Polly":{"name":"Polly","type":"Bird"}}

三、方法级缓存

除了上面的RedisTemplate，spring-data-redis还提供了方法级缓存,

就是将业务方法的执行结果缓存起来，后面再次调用直接从缓存中取得结果返回。

这种方式可以简化缓存逻辑的代码，比如配置类数据的读取，通过方法注解就可以实现，

下面是一个样例：


/**

 * 方法级缓存样例

 * 

 * @author atp

 *

 */

@Service

public class RedisCacheOperation {



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



    public static final String PREFIX = "pets:";

    public static final String WRAP_PREFIX = "'pets:'";



    /**

     * 当结果不为空时缓存

     * 

     * @param name

     * @return

     */

    @Cacheable(value = "petCache", key = WRAP_PREFIX + "+#name", unless = "#result==null")

    public RedisPet getPet(String name) {

        logger.info("get pet {}", name);

        return new RedisPet(name, "Bird");

    }



    /**

     * 当结果不为空时淘汰缓存

     * 

     * @param pet

     * @return

     */

    @CacheEvict(value = "petCache", key = WRAP_PREFIX + "+#pet.name", condition = "#result!=null")

    public RedisPet updatePet(RedisPet pet) {

        logger.info("update pet {}", pet.getName());

        return new RedisPet(pet.getName(), "Bird1");

    }



    /**

     * 当结果为true时淘汰缓存

     * 

     * @param name

     * @return

     */

    @CacheEvict(value = "petCache", key = WRAP_PREFIX + "+#name", condition = "#result==true")

    public boolean deletePet(String name) {

        logger.info("delete pet {}", name);

        return true;

    }

}

涉及到几个注解：

|注解 |说明|

|-----|-----|

|@Cachable |方法执行结果缓存 |

|@CachePut |方法执行结果缓存(强制) |

|@CacheEvict |方法执行时触发删除 |

其中 @CachePut 与 @Cachable 的区别在于，前者一定会执行方法，并尝试刷新缓存(条件满足)，

而后者则是当缓存中不存在时才会执行方法并更新。

注解中的属性 key/condition 都支持通过 Spring EL 表达式来引用参数对象。

启用注解

除了上面的代码，我们还需要使用 @EnableCaching 启用注解：


@EnableCaching

@Configuration

public class RedisConfig {



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



    /**

     * 缓存管理，支持方法级注解

     * 

     * @param template

     * @return

     */

    @Bean

    public RedisCacheManager cacheManager(RedisTemplate<String, Object> template) {

        RedisCacheManager redisCacheManager = new RedisCacheManager(template);

        // 默认过期时间

        redisCacheManager.setDefaultExpiration(30 * 60 * 1000);

        return redisCacheManager;

    }

当@Cacheable 的key属性为空时，框架会自动生成，格式类似：


param1,param2,param3...

如果希望修改默认的行为，可以使用自定义的 KeyGenerator：


    /**

     * 定制方法缓存的key生成策略

     *

     * @return

     */

    @Bean

    public KeyGenerator keyGenerator() {

        return new KeyGenerator() {

            @Override

            public Object generate(Object target, Method method, Object... args) {

                StringBuilder sb = new StringBuilder();

                sb.append(target.getClass().getName());

                sb.append(method.getName());



                for (Object arg : args) {

                    sb.append(arg.toString());

                }

                return sb.toString();

            }

        };

    }

单元测试

使用一小段单元测试代码来测试方法级缓存功能


@RunWith(SpringRunner.class)

@SpringBootTest(classes =BootSampleRedis.class)

public class RedisCacheOperationTest {



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



    @Autowired

    private RedisTemplate<String, Object> redisTemplate;



    @Autowired

    private RedisCacheOperation operation;



    private RedisPet pet1 = new RedisPet("Polly", "Bird");



    @Test

    public void testGet() {

        operation.getPet(pet1.getName());



        Object object = redisTemplate.opsForValue().get(RedisCacheOperation.PREFIX + pet1.getName());

        logger.info(String.valueOf(object));



        assertNotNull(object);

    }



    @Test

    public void testUpdate() {

        operation.updatePet(pet1);



        Object object = redisTemplate.opsForValue().get(RedisCacheOperation.PREFIX + pet1.getName());

        logger.info(String.valueOf(object));



        assertNull(object);

    }



    @Test

    public void testDelete() {

        operation.getPet(pet1.getName());



        // delete cache

        operation.deletePet(pet1.getName());



        Object object = redisTemplate.opsForValue().get(RedisCacheOperation.PREFIX + pet1.getName());

        logger.info(String.valueOf(object));



        assertNull(object);

    }



}

四、连接池

如果希望通过代码来配置 Jedis 的连接池(熟悉的方式)，可以声明 JedisConnectionFactory 实现：


    /**

     * 连接池配置

     *

     * @return

     */

    @Bean

    public JedisConnectionFactory jedisConnectionFactory() {

        JedisPoolConfig config = new JedisPoolConfig();



        // 最大连接

        config.setMaxTotal(10);

        // 最大空闲，与最大连接保持一致，可减少频繁键链的开销

        config.setMaxIdle(10);

        // 连接最大空闲时间

        config.setMinEvictableIdleTimeMillis(10 * 60 * 1000);

        // 获取连接等待的最大时长

        config.setMaxWaitMillis(30000);



        // 进行空闲连接检测的时间间隔

        config.setTimeBetweenEvictionRunsMillis(30 * 1000);

        // 取消不必要的test，有利于性能提升

        config.setTestOnBorrow(false);![](https://img2018.cnblogs.com/blog/242916/201812/242916-20181206231048870-1133770725.png)



        config.setTestOnReturn(false);



        JedisConnectionFactory factory = new JedisConnectionFactory(config);

        factory.setHostName("127.0.0.1");

        factory.setPort(6379);



        logger.info("redis config init first");

        return factory;

    }

更多配置可参考这里

示例代码可从码云gitee 下载。

https://gitee.com/littleatp/springboot-samples/