spring-data-redis 整合springboot 2.1.3.RELEASE

既然要整合框架,那么必不可少的要查询官方文档。

网上的文档,可以作为参考,但是千万不要直接用,除非标好了版本等信息 (且需要自己验证) 。

spring-data-redis官方文档:https://docs.spring.io/spring-data/redis/docs/2.1.5.RELEASE/reference/html/

不过这文档里面,也没写其他东西,没有实质性的作用;还是看看吧。

其他版本,可以根据这个网址,自己找。

 

1. 引入依赖



   org.springframework.boot
   spring-boot-starter-data-redis




   org.apache.commons
   commons-pool2
   ${commons-pool2.version}


## 因为springboot版本不同,所以spring-data-redis版本也不一定相同。
## 这里的springboot版本为 2.1.3.RELEASE ,所以 spring-data-redis版本为:2.1.5.RELEASE

2. 增加配置 (根据自己的情况配置)

spring:
  redis:  ###### redis 配置
    host: 47.96.***.61  # ip地址
    database: 0  # redis数据库  0-15
    port: 63791  # 端口号
    password: # 无密码不填
    timeout: 30000s   # 连接超时时间 (默认1天)
    lettuce:
      shutdown-timeout: 100ms # 关闭超时时间 默认 100ms
      pool: # lettuce 连接池
        max-active: 8 # 连接池最大连接数 默认 8(-1 :表示没有限制)
        max-wait: 60000ms # 连接池最大阻塞等待时间 默认-1ms (-1 :表示没有限制) 这里设置1分钟
        max-idle: 8 # 最大空闲连接  默认 8
        min-idle: 0 # 最小空闲连接  默认 0

这时候,redis就可以开始简单的调用了。

但是,还需要一些简单的配置。 比如序列化redisTemplete保存的数据呀,还有就是redis缓存的配置呀,等

package com.toad.config.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author wangqinmin
 * @date: 2019/3/20 10:29
 * redis配置: RedisConfig文件名不能修改
 * 配置序列化方式以及缓存管理器 @EnableCaching 开启缓存
 */
@Configuration
@EnableCaching
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {

    /**
     * 配置自定义redisTemplate
     * 因为使用的连接客户端为:Lettuce,所以RedisConnectionFactory实际传入数据为 LettuceConnectionFactory
     *
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setValueSerializer(jackson2JsonRedisSerializer());
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    /**
     * json序列化
     *
     * @return
     */
    @Bean
    public RedisSerializer jackson2JsonRedisSerializer() {
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        return serializer;
    }

    /**
     * 配置缓存管理器
     * 需要注意的是 你在RedisTemplate中的配置的key,value序列化方法并不会生效
     * 需要在RedisCacheConfiguration中单独配置。
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 生成一个默认配置,通过config对象即可对缓存进行自定义配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        // 设置缓存的默认过期时间,也是使用Duration设置 (此处为缓存1分钟)
        config = config.entryTtl(Duration.ofMinutes(1))
                // 设置 key为string序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value为json序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
                // 不缓存空值
                .disableCachingNullValues();

        // 设置一个初始化的缓存空间set集合
        Set cacheNames = new HashSet<>();
        cacheNames.add("timeGroup");
        cacheNames.add("user");
        cacheNames.add("UUser");

        // 对每个缓存空间应用不同的配置
        Map configMap = new HashMap<>();
        configMap.put("timeGroup", config);
        // 该缓存空间,缓存时间120秒
        configMap.put("user", config.entryTtl(Duration.ofSeconds(120)));
        configMap.put("UUser", config.entryTtl(Duration.ofDays(3)));

        // 使用自定义的缓存配置初始化一个cacheManager
        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                // 一定要先调用该方法设置初始化的缓存名,再初始化相关的配置
                .initialCacheNames(cacheNames)
                .withInitialCacheConfigurations(configMap)
                .build();
        return cacheManager;
    }

} 
  

redis的保存数据调用的例子:

package com.toad.swan.web.controller;

import com.toad.common.base.BaseController;
import com.toad.common.baseclass.ApiResult;
import com.toad.swan.entity.UUser;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

/**
 * 

* 充电订单 前端控制器 *

* * @author wangqinmin * @since 2019-03-21 */ @RestController @RequestMapping("/redis") @Slf4j @Api("redis") public class RedisController extends BaseController { @Autowired private RedisTemplate redisTemplate; //private RedisTemplate redisTemplate; /** * 添加用户 */ @PostMapping("/add") @ApiOperation(value = "redis添加用户", notes = "redis", response = ApiResult.class) public Object addSysUser(@Valid @RequestBody UUser uUser) throws Exception { redisTemplate.opsForValue().set("uUserTest", uUser.toString()); logger.info("redis保存数据为:[{}]", uUser.toString()); return success(true); } /** * 获取用户 */ @PostMapping("/get") @ApiOperation(value = "redis获取用户", notes = "redis", response = ApiResult.class) public Object addUser() throws Exception { Object uu = redisTemplate.opsForValue().get("uUserTest"); redisTemplate.delete("uUserTest"); logger.info("redis中获取数据:[{}]", uu); logger.error("redis中获取数据:[{}]", uu); logger.warn("redis中获取数据:[{}]", uu); logger.debug("redis中获取数据:[{}]", uu); return success(uu); } }

使用redis缓存的例子:

package com.toad.swan.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.toad.swan.entity.UUser;
import com.toad.swan.mapper.UUserMapper;
import com.toad.swan.service.UUserService;
import com.toad.swan.web.param.UUserParam;
import com.toad.swan.web.vo.UUserVo;
import com.toad.common.baseclass.*;
import com.toad.common.base.BaseServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;

/**
 * 

* 服务实现类 *

* * @author wangqinmin * @since 2019-03-21 */ @Service @Transactional(rollbackFor = Exception.class) @Slf4j public class UUserServiceImpl extends BaseServiceImpl implements UUserService { @Autowired private UUserMapper uUserMapper; /** * 修改缓存 *

* redis缓存--更新(修改)数据 * * @param uUser * @return * @CachePut 应用到写数据的方法上,如新增/修改方法,调用方法时会自动把相应的数据放入缓存 */ @CachePut(value = {"user"}, key = "#root.args[0]", unless = "#user eq null ") @Override public boolean redisCacheUpdateById(UUser uUser) { int i = uUserMapper.updateById(uUser); if (i == 1) { return true; } return false; } /** * 删除缓存 * * @param id * @return * @CacheEvict 应用到删除数据的方法上,调用方法时会从缓存中删除对应key的数据condition 与unless相反,只有表达式为真才会执行。 * redis缓存--移除数据 */ @CacheEvict(value = {"user"}, key = "#root.args[0]", condition = "#result eq true") @Override public boolean redisCacheRemoveById(String id) { int i = uUserMapper.deleteById(id); if (i == 1) { return true; } return false; } /** * redis缓存--获取一条数据 * * @param id * @return * @Cacheable 应用到读取数据的方法上,先从缓存中读取,如果没有再从DB获取数据,然后把数据添加到缓存中key 缓存在redis中的keyunless 表示条件表达式成立的话不放入缓存 */ @Cacheable(value = "user", key = "args[0]", unless = "#result eq null ") @Override public UUserVo redisCacheGetUUserById(String id) { return uUserMapper.getUUserById(id); } }

package com.toad.common.base;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.toad.common.baseclass.OrderEnum;
import com.toad.common.baseclass.QueryParam;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author wangqinmin
 * @date 2018-11-08
 */
public abstract class BaseServiceImpl, T> extends ServiceImpl implements BaseService {

    protected Logger logger = LoggerFactory.getLogger(getClass());

    protected Page setPageParam(QueryParam queryParam) {
        return setPageParam(queryParam, null, null);
    }

    protected Page setPageParam(QueryParam queryParam, String defaultOrderField, OrderEnum orderEnum) {
        Page page = new Page();
        page.setCurrent(queryParam.getCurrent());
        page.setSize(queryParam.getSize());
        page.setAsc(queryParam.getAscs());
        page.setDesc(queryParam.getDescs());

        if (orderEnum == OrderEnum.DESC) {
            page.setDesc(defaultOrderField);
        } else {
            page.setAsc(defaultOrderField);
        }

        return page;
    }

}
package com.toad.common.base;

import com.baomidou.mybatisplus.extension.service.IService;

/**
 * @author wangqinmin
 * @date 2018-11-08
 */
public interface BaseService extends IService {

}

 

你可能感兴趣的:(Nosql)