SpringBoot2.0 集成Reids，作为数据库或者缓存。并支持CRUD
Redis的优势：
1、性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
2、丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
3、原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
4、丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。
Redis可作为数据库，可降低数据IO的读操作，减轻IO的压力。可以减少CPU和内存的压力。并且可以修改表结构，特殊对待某一条数据。并且Redis是NoSQL，读取速度快，对于较大数据处理快。
Redis做缓存，可用于高频次访问的数据；也可用于分布式架构中session共享。
搭建步骤：
一、采用IDEA搭建Springboot项目，并引入redis所需的依赖。如下
org.springframework.boot
spring-boot-starter-data-redis
2.0.0.RELEASE
org.springframework.boot
spring-boot-starter-redis
二、配置Redis数据源信息
server.port=1104
server.tomcat.uri-encoding=UTF-8
#################redis基础配置###################
# 数据库设置
spring.redis.database=5
#宿主机IP
spring.redis.host=localhost
#端口号
spring.redis.port=6379
#密码
spring.redis.password=jane@2018
# 连接超时时间 单位 ms（毫秒）
spring.redis.timeout=3000
#################redis线程池设置#################
# 连接池中的最大空闲连接，默认值也是8。
spring.redis.jedis.pool.max-idle=500
#连接池中的最小空闲连接，默认值也是0。
spring.redis.jedis.pool.min-idle=50
# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
spring.redis.jedis.pool.max-wait=2000
# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
spring.redis.jedis.pool.max-active=1000
三、编写Redis配置类
添加一个conf包，放置redis的一些配置类
1、首先添加RedisConf类，实例化Redis的一系列操作对象，例如HashOperations、SetOperations等，本demo中只使用了HashOperations。但是其他操作对象同样实例，以便后续的扩展
package com.jane.demo.conf.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.*;
/**
* @author jane
* @version 2018/03/08
*/
@Configuration
public class RedisConf {
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 实例化 HashOperations 对象,可以使用 Hash 类型操作
*/
/*@Bean
public HashOperations hashOperations() {
return redisTemplate.opsForHash();
}*/
/**
* 实例化 ValueOperations 对象,可以使用 String 操作
*/
@Bean
public ValueOperations valueOperations() {
return redisTemplate.opsForValue();
}
/**
* 实例化 ListOperations 对象,可以使用 List 操作
* @return
*/
@Bean
public ListOperations listOperations() {
return redisTemplate.opsForList();
}
/**
* 实例化 SetOperations 对象,可以使用 Set 操作
*/
@Bean
public SetOperations setOperations() {
return redisTemplate.opsForSet();
}
/**
* 实例化 ZSetOperations 对象,可以使用 ZSet 操作
*/
@Bean
public ZSetOperations zSetOperations() {
return redisTemplate.opsForZSet();
}
} 2、分别定义了读和取的Redis库接口
2.1 Redis写操作库接口IWriteRedisRepository
package com.jane.demo.conf;
/**
* 缓存写操作
* @param
*/
public interface IWriteRedisRepository extends IRedisRepository {
/**
* 插入缓存，并不过期
* @param key 键
* @param t 值
*/
void put(String key, T t);
/**
*插入缓存
* @param key 键
* @param t 值
* @param expire 过期时间,如果为-1,则不设置过期时间
*/
void put(String key, T t, long expire);
/**
* 移除缓存
* @param key
*/
void remove(String key);
/**
* 清空缓存
*/
void empty();
} 2.2 Redis读操作库接口 IReadRedisRepository
package com.jane.demo.conf;
import java.util.List;
import java.util.Set;
/**
* 缓存读操作
*
* @author jane
* @version 2018/03/08
*/
public interface IReadRedisRepository extends IRedisRepository {
/**
* 获取键值key的Value
* @param key 键
* @return
*/
T get(String key);
/**
* 获取所有缓存Value信息
* @return
*/
List getAll();
/**
* 获取所有键值key
* @return
*/
Set getKeys();
/**
* 键值key是否存在
* @param key 键
* @return
*/
boolean isKeyExists(String key);
/**
* Redis缓存计数器
* @return
*/
long count();
}
3、创建一个抽象类AbstractRedisRepository
package com.jane.demo.conf.impl;
import com.alibaba.fastjson.JSON;
import com.jane.demo.conf.IReadRedisRepository;
import com.jane.demo.conf.IWriteRedisRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* Redis缓存操作
*
* @author jane
* @version 2018/03/08
*/
public abstract class AbstractRedisRepository implements IReadRedisRepository, IWriteRedisRepository {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private HashOperations hashOperations;
/**
* 插入缓存，并不过期
* @param key 键
* @param t 值
*/
@Override
public void put(String key, T t) {
put(key, t, -1);
}
/**
* 插入缓存
* @param key 键
* @param t 值
* @param expire 过期时间,如果为-1,则不设置过期时间
*/
@Override
public void put(String key, T t, long expire) {
hashOperations.put(getRedisKey(), key, JSON.toJSONString(t));
if (expire != -1) {
stringRedisTemplate.expire(getRedisKey(), expire, TimeUnit.SECONDS);
}
}
/**
* 移除缓存
* @param key
*/
@Override
public void remove(String key) {
hashOperations.delete(getRedisKey(), key);
}
/**
* 清空缓存
*/
@Override
public void empty() {
Set set = hashOperations.keys(getRedisKey());
set.forEach(key -> hashOperations.delete(getRedisKey(), key));
}
/**
* 获取缓存Value
* @param key
* @return
*/
@Override
public T get(String key) {
return JSON.parseObject(hashOperations.get(getRedisKey(), key), getSerializeClass());
}
/**
* 序列化对象
* @return
*/
protected abstract Class getSerializeClass();
/**
* 获取所有缓存Value
* @return
*/
@Override
public List getAll() {
return JSON.parseArray(JSON.toJSONString(hashOperations.values(getRedisKey())), getSerializeClass());
}
/**
* 获取所有缓存的key
* @return
*/
@Override
public Set getKeys() {
return hashOperations.keys(getRedisKey());
}
/**
* 键值key是否存在
* @param key 键
* @return
*/
@Override
public boolean isKeyExists(String key) {
return hashOperations.hasKey(getRedisKey(), key);
}
/**
* 缓存计数器
* @return
*/
@Override
public long count() {
return hashOperations.size(getRedisKey());
}
}
4、创建一个RedisKey的类，这个类的作用类似于数据库中表名，比如我添加的是USER_KEY。即用户表
package com.jane.demo.conf;
/**
* 系統模块名称,类似与表名
* @author jane
* @version 2018/03/09
*/
public class RedisKey {
public final static String USER_KEY = "JANE.DEMO.USER"; //用户（表）
}四、添加简单的业务逻辑和实体类
1、添加实体类User
package com.jane.demo.entity;
import lombok.Data;
/**
* 用户类
* 登录名唯一作为键值
* @author jane
* @version 2018/03/09
*/
@Data
public class User {
private String name; //用户姓名
private String phoneNumber; //电话
private String loginName; //登录名（唯一）
}
2、添加继承AbstractRedisRepository的UserRedis类，并设置起redisKey和序列化。
package com.jane.demo.redis;
import com.jane.demo.conf.RedisKey;
import com.jane.demo.conf.impl.AbstractRedisRepository;
import com.jane.demo.entity.User;
import org.springframework.stereotype.Component;
/**
* 用户模块
* @author jane
* @version 2018/03/09
*/
@Component
public class UserRedis extends AbstractRedisRepository {
@Override
public String getRedisKey() {
return RedisKey.USER_KEY;
}
@Override
protected Class getSerializeClass() {
return User.class;
}
} 3、添加UserService，简单定义user的CRUD。
package com.jane.demo.service;
import com.jane.demo.entity.User;
import com.jane.demo.redis.UserRedis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @author jane
* @version 2018/03/09
*/
@Service
public class UserService {
@Autowired
private UserRedis userRedis;
/**
* 保存用户（登录名唯一，作为键值）
* @param user 用户信息
*/
public void saveUser(User user){
userRedis.put(user.getLoginName(), user);
}
/**
* 根据登录名获取用户信息
* @param loginName 登录名
* @return 用户信息
*/
public User getUser(String loginName){
return userRedis.get(loginName);
}
/**
* 判断当前登录名称是否存在
* @param loginName 登录名
* @return 存在返回true，否则false
*/
public boolean isExsist(String loginName){
return userRedis.isKeyExists(loginName);
}
/**
* 获取所有用户信息
* @return 用户集
*/
public List findAll(){
return userRedis.getAll();
}
} 4、添加UserController控制层，用于用户的简单交互。
package com.jane.demo.controller;
import com.jane.demo.entity.User;
import com.jane.demo.model.JsonModel;
import com.jane.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/**
* 用户控制层
* @author jane
* @version 2018/03/09
*/
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@RequestMapping(value = "/test", method = RequestMethod.GET)
public JsonModel test(){
return new JsonModel(200, "测试成功");
}
@RequestMapping(value = "/create", method = RequestMethod.POST)
public JsonModel create(User user){
if (!userService.isExsist(user.getLoginName())){
userService.saveUser(user);
return new JsonModel(200,"成功添加！");
}else {
return new JsonModel(304,"已存在，无法添加！");
}
}
@RequestMapping(value = "/getOne", method = RequestMethod.GET)
public JsonModel get(String loginName){
return new JsonModel(200, userService.getUser(loginName),"成功");
}
}
五、采用junit中的MockMvc测试控制层
package com.jane.demo.controller;
import com.alibaba.fastjson.JSONObject;
import com.jane.demo.entity.User;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
/**
* 用户控制层测试
*
* @author jane
* @version 2018/03/11
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserControllerTest {
/** 模拟MVC对象*/
private MockMvc mockMvc;
/**注入Web应用上下文*/
@Autowired
private WebApplicationContext webApplicationContext;
@Before
public void setup(){
this.mockMvc = MockMvcBuilders.webAppContextSetup(this.webApplicationContext).build();
}
/**
* 测试用户的添加
* @throws Exception
*/
@Test
@Ignore
public void testCreate()throws Exception{
User user = new User();
user.setName("JunitTest");
user.setPhoneNumber("1234531");
user.setLoginName("junit");
MvcResult result = mockMvc.perform(post("/user/create?name=JunitTest&phoneNumber=1234531&loginName=junit").contentType(MediaType.APPLICATION_JSON)
.content(JSONObject.toJSONString(user)))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andReturn();
System.out.println(result.getResponse().getContentAsString());
}
/**
* 测试web项目是否部署成功
* @throws Exception
*/
@Test
@Ignore
public void testWeb()throws Exception {
String result = mockMvc.perform(get("/user/test").contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andReturn().getResponse().getContentAsString();
System.out.println("-------返回的JSON:" + result);
}
/**
* 测试getOne
* @throws Exception
*/
@Test
public void testGetOne()throws Exception {
MvcResult result = mockMvc.perform(get("/user/getOne").contentType(MediaType.APPLICATION_JSON)
.param("loginName","jane"))
.andExpect(status().isOk())
.andReturn();
System.out.println(result.getResponse().getContentAsString());
}
}项目源代码地址：https://github.com/jane0827/redis_springboot