springboot集成Redis

#

在spring中使用redis配置好配置文件

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=192.168.*.***
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=****
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1  
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8  
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0  
# 连接超时时间（毫秒）
spring.redis.timeout=0  

既可以在其他类中直接注入 StringRedisTemplate 和 RedisTemplate 直接使用了
如：
写成服务类：

@Service
public class RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Resource(name="stringRedisTemplate")
    private ValueOperations<String,String> valOpsStr;

    @Autowired
    private RedisTemplate redisTemplate;

    @Resource(name="redisTemplate")
    private ValueOperations<Object, Object> valOpsObj;

    public String getStr(String key){
        return valOpsStr.get(key);
    }

    public void setStr(String key ,String val){
        valOpsStr.set(key, val);
    }

    public void del(String key){
        stringRedisTemplate.delete(key);
    }

    public Object getObj(Object o){
        return valOpsObj.get(o);
    }

    public void setObj(Object o1,Object o2){
        valOpsObj.set(o1, o2);
    }

    public void delObj(Object o){
        redisTemplate.delete(o);
    }
}

在测试类中即可测试

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestRedis {

    @Autowired
    private RedisService redisService;

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        System.out.println("设值。。。。。。");
        redisService.setStr("name", "zzm");
    }

    @Test
    public void test2(){
        System.out.println("取值。。。。。");
        System.out.println(redisService.getStr("name"));
    }

//  @Test
//  public void test3(){
//      System.out.println("删除。。。");
//      redisService.del("name");
//  }

    @Test
    public void test4(){
        System.out.println("设值.......obj");
        User u1 = new User("me", "zzm");
        redisService.setObj("me", u1);
    }

    @Test
    public void test5(){
        System.out.println("取值。。。。。。obj");
        System.out.println(redisService.getObj("me"));
    }

//  @Test
//  public void test6(){
//      System.out.println("删除。。。obj");
//      redisService.delObj(1);
//  }
}

其中实体类User

public class User implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String id;
    private String name;


    public User() {
        super();
    }
    public User(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
}

代码中设值取值是ok的，但是使用redis-cli getkey时 user无法显示，这是应为user没有序列化在redis读取无法直接展示，可添加下列配置：

@Configuration
@EnableCaching //启用缓存
public class CatchConfig extends CachingConfigurerSupport {

    /**
     * 自定义key. 这个可以不用
     * 此方法将会根据类名+方法名+所有参数的值生成唯一的一个key,即使@Cacheable中的value属性一样，key也会不一样。
     */
/*    @Bean
    public KeyGenerator keyGenerator() {
       System.out.println("RedisCacheConfig.keyGenerator()");
       return new KeyGenerator() {
           @Override
           public Object generate(Object o, Method method, Object... objects) {
               // This will generate a unique key of the class name, the method name
               //and all method parameters appended.
               StringBuilder sb = new StringBuilder();
               sb.append(o.getClass().getName());
               sb.append(method.getName());
               for (Object obj : objects) {
                   sb.append(obj.toString());
               }
               System.out.println("keyGenerator=" + sb.toString());
               return sb.toString();
           }
       };
    }
    */

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
       /* //设置缓存过期时间
        // rcm.setDefaultExpiration(60);//秒
        //设置value的过期时间
        Map<String,Long> map=new HashMap();
        map.put("test",60L);
        rcm.setExpires(map);*/
        return rcm;
    }

     /**
     * RedisTemplate配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //定义key序列化方式
        //RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型会出现异常信息;需要我们上面的自定义key生成策略，一般没必要
        //定义value的序列化方式
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

       // template.setKeySerializer(redisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

再次运行，然后用redis-cli获取，可以显示，ok完成

127.0.0.1:6379> get me
"[\"om.zzm.test.domain.entity.User\",{\"id\":\"me\",\"name\":\"zzm\"}]"
127.0.0.1:6379>