【Spring Boot&&Spring Cloud系列】Spring Boot中使用NoSql数据库Redis

github地址：https://github.com/AndyFlower/Spring-Boot-Learn/tree/master/spring-boot-nosql-redis

一、加入依赖到pom.xml

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>
 <!--转换json数据格式的数据-->
 <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
 </dependency>

二、创建Redis服务类

Redis提供了下列几种数据类型可以存取

• String
• hash
• list
• set和zset

在Spring Boot中没有提供像JPA那样的资源库接口，我们自定义一个User的服务类。

 package com.slp.repository;

 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import com.slp.entity.User;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Repository;
 import org.springframework.util.StringUtils;

 import java.util.List;
 import java.util.concurrent.TimeUnit;

 /**
  * Created by sangliping on 2017/8/18.
  */
 @Repository
 public class UserRedis {
     @Autowired
     private RedisTemplate<String,String> redisTemplate;
     public void add(String key,Long time,User user){
         Gson gson = new Gson();
       redisTemplate.opsForValue().set(key,gson.toJson(user),time, TimeUnit.MINUTES);
     }

     public void add(String key, Long time, List<User> users){
         Gson gson = new Gson();
         redisTemplate.opsForValue().set(key,gson.toJson(users),time,TimeUnit.MINUTES);
     }

     public User get(String key){
         Gson gson = new Gson();
         User user = null;
         String userJson = redisTemplate.opsForValue().get(key);
         if(!StringUtils.isEmpty(userJson)){
             user = gson.fromJson(userJson,User.class);
         }
         return user;
     }

     public List<User> getList(String key){
         Gson gson = new Gson();
         List<User> lu = null;
         String listjson = redisTemplate.opsForValue().get(key);
         if(!StringUtils.isEmpty(listjson)){
             lu = gson.fromJson(listjson,new TypeToken<List<User>>(){}.getType());
         }
         return lu;
     }

     public void delete (String key){
         redisTemplate.opsForValue().getOperations().delete(key);
     }
 }

因为Redis没有表结构的概念，所以要实现MySql数据库中标的数据在Redis中存取，需要做一些转换，这里我们使用了Gson,将对象转换为JSON格式的文本进行存储，取出数据时再将JSON文本数据转换为Java对象。

Redis使用了key-value的方式存储数据，所以在存入时要生成一个唯一的key,而要查询或删除的时候就使用这个唯一的key进行操作。

默认情况下Redis中的数据是永久存储的，可以指定生命周期来进行控制。

要想正确的调用RedisTemplate需要做一些初始化工作，即对它存取的字符串进行一个JSON格式的系列化初始配置（此处没有注入因为测试也有一个配置文件都注入会冲突，正式的时候这里要注入）

 package com.slp.config;

 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

 /**
  * Created by sangliping on 2017/8/18.
  */

 public class RedisConfig {
     public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
         StringRedisTemplate template = new StringRedisTemplate(factory);
         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.setValueSerializer(jackson2JsonRedisSerializer);
         template.afterPropertiesSet();
         return template;
     }
 }

三、测试准备

1、参数配置

 spring.datasource.url=jdbc:mysql://localhost:3306/dev?characterEncoding=utf-8
 spring.datasource.username=root
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 spring.datasource.password=123456
 spring.jpa.database=mysql
 spring.jpa.show-sql=true
 spring.jpa.hibernate.ddl-auto=update
 spring.jpa.hibernate.naming.strategy=org.hibernate.cfg.ImprovedNamingStrategy
 spring.jpa.propertie.hibernate.dialect=org.hibernate.dialect.MySQLDialect
 spring.redis.database=1
 spring.redis.host=localhost
 spring.redis.port=6379
 spring.redis.pool.max-idle=8
 spring.redis.pool.min-idle=0
 spring.redis.pool.max-active=8
 spring.redis.pool.max-wait=-1

2、编写测试类

 package com.slp;

 import com.slp.entity.Department;
 import com.slp.entity.Role;
 import com.slp.entity.User;
 import com.slp.repository.UserRedis;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 /**
  * Created by sangliping on 2017/8/18.
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = {RedisConfig.class, UserRedis.class})
 public class RedisTest {
     private static Logger logger = LoggerFactory.getLogger(RedisTest.class);
     @Autowired
     UserRedis userRedis;

     @Before
     public void setup(){
         Department department = new Department();
         department.setName("设计部");

         Role role = new Role();
         role.setName("admin");

         User user = new User();
         user.setName("slp");
         user.setCreatedate(new Date());
         user.setDeparment(department);

         List<Role> roles = new ArrayList<Role>();
         roles.add(role);

         user.setRoles(roles);
         userRedis.delete(this.getClass().getName()+":userByName:"+user.getName());
         userRedis.add(this.getClass().getName()+":userByName:"+user.getName(),10L,user);

     }
     @Test
     public void get(){
         User u = userRedis.get(this.getClass().getName()+":userByName:user");
     }
 }

3、配置测试变量

 package com.slp;

 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

 /**
  * Created by sangliping on 2017/8/18.
  */
 @Configuration
 public class RedisConfig {
     @Bean
     public JedisConnectionFactory jedisConnectionFactory(){
         JedisConnectionFactory factory =  new JedisConnectionFactory();
         factory.setHostName("127.0.0.1");
         factory.setPort(6379);
         return factory;
     }

     @Bean
     public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
         StringRedisTemplate template = new StringRedisTemplate(factory);
         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.setValueSerializer(jackson2JsonRedisSerializer);
         template.afterPropertiesSet();
         return template;
     }
 }

4、执行完成redis中数据