## 本文只实现业务核心模块
### 1.redis配置类(config)
```java
/**
* 配置redis存储数据的格式问题
*/
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(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);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
```
## 2.封装redis基本的curd工具类
```java
@Component
public class RedisCommonUtil {
@Autowired
private RedisTemplate redisTemplate;
/**
* 判断是否有key所对应的值，有则返回true，没有则返回false
*
* @param key
* @return
*/
public boolean hasKey(Object key) {
return redisTemplate.hasKey(key);
}
/**
* @param key 获取的key对应的value
* @return
*/
public Object get(Object key) {
if (hasKey(key)) {
return redisTemplate.opsForValue().get(key);
} else {
return new RuntimeException("查询" + key.toString() + "不存在");
}
}
/**
* 删除单个key值
*
* @param key 需要移除的值
* @return
*/
public boolean delete(String key) {
boolean result = false;
if (!hasKey(key)) {
System.out.println("查询key=" + key + "不存在");
} else {
result = redisTemplate.delete(key);
}
return result;
}
/**
* 批量删除key
*
* @param keys
* @return
*/
public boolean delete(String... keys) {
boolean result = false;
if (!hasKey(keys)) {
System.out.println("查询" + keys.toString() + "不存在");
} else {
result = redisTemplate.delete((keys));
}
return result;
}
/**
* @param oldKey 旧的key
* @param newKey 新的key
*/
public void rename(String oldKey, String newKey) {
redisTemplate.rename(oldKey, newKey);
}
public Set<String> getPatternKey(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* @param key 存入的key
* @param value 存入的value
*/
public void set(Object key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* //存入数据
*
* @param key
* @param value
*/
public void leftPushAll(Object key, Object value) {
redisTemplate.opsForList().leftPushAll(key, value);
}
/**
* 查询全部数据
*
* @param key
* @return
*/
public List range(Object key) {
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 批量获取值
*
* @param keys
* @return List<String>
*/
public List<String> multiGet(Collection<Object> keys) {
return redisTemplate.opsForValue().multiGet(keys);
}
/**
* 在原有的值基础上新增字符串到末尾
*
* @param key
* @param value
* @return Integer
*/
public Integer append(Object key, String value) {
return redisTemplate.opsForValue().append(key, value);
}
/**
* 设置map集合到redis
*
* @param map
*/
public void multiSet(Map<Object, Object> map) {
redisTemplate.opsForValue().multiSet(map);
}
/**
* 获取字符串的长度
*
* @param key
* @return Long
*/
public Long size(String key) {
return redisTemplate.opsForValue().size(key);
}
/**
* 返回key所存储的值的类型
*
* @param key
* @return
*/
public DataType type(String key) {
return redisTemplate.type(key);
}
/**
* 返回key中字符串值得子字符
*
* @param key
* @param start
* @param end
* @return
*/
public String type(String key, long start, long end) {
return redisTemplate.opsForValue().get(key, start, end);
}
/**
* 只有在 key 不存在时设置 key 的值
*
* @param key
* @param value
* @return
*/
public Boolean setIfAbsent(String key, String value) {
return redisTemplate.opsForValue().setIfAbsent(key, value);
}
/**
* 对key设置过期时间
*
* @param key
* @param timeout
* @param unit
* @return
*/
public Boolean expire(String key, long timeout, TimeUnit unit) {
return redisTemplate.expire(key, timeout, unit);
}
/**
* @param key
* @param date
* @return
*/
public Boolean expireAt(String key, Date date) {
return redisTemplate.expireAt(key, date);
}
/**
* 查找匹配的key
*
* @param pattern
* @return
*/
public Set<String> keys(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* 讲当前数据库的key移动到指定的数据库db当中
*
* @param key
* @param dbIndex
* @return
*/
public Boolean move(String key, int dbIndex) {
return redisTemplate.move(key, dbIndex);
}
/**
* 返回key剩余的过期时间
*
* @param key
* @param unit
* @return
*/
public Long getExpire(String key, TimeUnit unit) {
return redisTemplate.getExpire(key, unit);
}
/**
* 从当前数据库中随机返回一个key
*
* @return
*/
public Object randomKey() {
return redisTemplate.randomKey();
}
/**
* 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
*
* @param map
* @return
*/
public boolean multiSetIfAbsent(Map<String, String> map) {
return redisTemplate.opsForValue().multiSetIfAbsent(map);
}
/**
* 自增长,负数则自减
*
* @param key
* @param increment
* @return
*/
public Long increment(String key, long increment) {
return redisTemplate.opsForValue().increment(key, increment);
}
/**
* 获取存储在哈希表中指定字段的值
*
* @return
*/
public Object hGet(String key, String field) {
return redisTemplate.opsForHash().get(key, field);
}
/**
* 获取存储在哈希表中
*
* @param key
* @return Map
*/
public Map<Object, Object> hGetAll(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 存储set数据
*
* @param key
* @param value
* @return
*/
public Long add(Object key, Object value) {
return redisTemplate.opsForSet().add(key, value);
}
/**
* @param key
* @return 返回全部的值
*/
public Set members(Object key) {
return redisTemplate.opsForSet().members(key);
}
/**
* @param key 移除的key
* @param obj 移除的object
* @return 返回影响的数量
*/
public Long remove(Object key, Object obj) {
return redisTemplate.opsForSet().remove(key, obj);
}
/**
* @param key
* @return 返回set集合的的大小
*/
public Long size(Object key) {
return redisTemplate.opsForSet().size(key);
}
/**
* @param key
* @param map
*/
public void putAll(Object key, Map map) {
redisTemplate.opsForHash().putAll(key, map);
}
/**
* @param key
* @return
*/
public Set keys(Object key) {
return redisTemplate.opsForHash().keys(key);
}
/**
* 把数据从缓存中取出来
*
* @param key
* @return
*/
public Object leftPop(Object key) {
return redisTemplate.opsForList().leftPop(key);
}
}
```
### 3.服务实现层即impl
```java
//省略import
/**
逻辑代码实现
* 带缓存的userService服务实现类
*/
@Service
public class UserServiceImpl implements UserService {
private final static String REDIS_KEY_SINGLE = "student_";
private final static String REDIS_KEY_LIST = "students";
@Autowired
private RedisCommonUtil redisCommonUtil;
@Autowired
private UserMapper userMapper;
/**
* @param user
* @return
*/
public int insert(User user) {
//判断该值是否存在
if (redisCommonUtil.hasKey(REDIS_KEY_LIST)) {
System.out.println("把key=" + REDIS_KEY_LIST + " 数据从缓存删除");
//缓存的数据删除
redisCommonUtil.leftPop(REDIS_KEY_LIST);
}
int row = userMapper.insert(user);
if (row > 0) {
System.out.println("数据添加成功");
//从数据库查询数据
List<User> getUserList = userMapper.selectList(null);
if (!(getUserList.size() == 0)) {
System.out.println("把key=" + REDIS_KEY_LIST + "数据存入缓存");
//再一次将数据存入缓存
redisCommonUtil.leftPushAll(REDIS_KEY_LIST, getUserList);
}
}
return row;
}
/**
* 删除用户信息
*
* @param id 处理的
* @return 相应处理成功的条目
*/
public Integer delete(Integer id) {
//判断该值是否存在
if (redisCommonUtil.hasKey(REDIS_KEY_SINGLE + id)) {
System.out.println("从缓存中删除key=" + REDIS_KEY_SINGLE + id + " 的数据");
//缓存的数据删除
redisCommonUtil.delete(REDIS_KEY_SINGLE + id);
}
if (redisCommonUtil.hasKey(REDIS_KEY_LIST)) {
System.out.println("从缓存中取出key=" + REDIS_KEY_LIST + " 的数据");
List<User> userList = (List<User>) redisCommonUtil.leftPop(REDIS_KEY_LIST);
System.out.println("移除的对象=" + userList);
}
//判断删除的用户是否存在
User user = userMapper.selectById(id);
Integer row = null;
if (user != null) {
row = userMapper.deleteById(id);
System.out.println(row > 0 ? "从数据库中删除数据成功" : "从数据库中删除数据失败");
//从数据库查询数据
List<User> getUserList = userMapper.selectList(null);
if (!(getUserList.size() == 0)) {
System.out.println("把key=" + REDIS_KEY_LIST + "数据存入缓存");
//再一次将数据存入缓存
redisCommonUtil.leftPushAll(REDIS_KEY_LIST, getUserList);
}
}
return row;
}
/**
* 更新用户信息
*
* @param user
* @return 处理成功的条目
*/
public int update(User user) {
//判断该值是否存在
if (redisCommonUtil.hasKey(REDIS_KEY_SINGLE + user.getId())) {
System.out.println("将key=" + REDIS_KEY_SINGLE + user.getId() + "数据从缓存中移除");
//缓存的数据删除
redisCommonUtil.delete(REDIS_KEY_SINGLE + user.getId());
}
if (redisCommonUtil.hasKey(REDIS_KEY_LIST)) {
System.out.println("从缓存中取出key=" + REDIS_KEY_LIST + " 的数据");
List<User> userList = (List<User>) redisCommonUtil.leftPop(REDIS_KEY_LIST);
System.out.println("移除的对象=" + userList);
}
//更新数据库的数据
int row = userMapper.updateById(user);
if (row > 0) {
System.out.println("数据更新成功");
System.out.println("把key=" + REDIS_KEY_SINGLE + user.getId() + "数据存入缓存");
//将数据存入缓存
redisCommonUtil.set(REDIS_KEY_SINGLE + user.getId(), user); //给获取单个数据提供准确数据
System.out.println("开始查询数据库...");
//从数据库查询全部用户列表数据
List<User> getUserList = userMapper.selectList(null);
if (!(getUserList.size() == 0)) {
System.out.println("把key=" + REDIS_KEY_LIST + "数据存入缓存");
//将getUserList数据存入缓存
redisCommonUtil.leftPushAll(REDIS_KEY_LIST, getUserList);
}
}
return row;
}
/**
* 查询用户列表全部数据
*
* @return
*/
public List<User> selectList() {
List<User> getUserList = null;
//1.查看该key是否存在
if (redisCommonUtil.hasKey(REDIS_KEY_LIST)) {
System.out.println("开始读取缓存中的数据 key=" + REDIS_KEY_LIST);
//2.从缓存中读取数据
getUserList = redisCommonUtil.range(REDIS_KEY_LIST);
} else {
System.out.println("开始读取数据库中的数据...");
//3.丛数据库读取数据
getUserList = userMapper.selectList(null);
if (!(getUserList.size() == 0)) {
System.out.println("把key=" + REDIS_KEY_LIST + "数据存入缓存");
//4.把数据存入缓存
redisCommonUtil.leftPushAll(REDIS_KEY_LIST, getUserList);
}
}
return getUserList;
}
/**
* @param id 查询是的id值
* @return User对象
*/
public User getOne(Integer id) {
User user = null;
//1.判断缓存是否存储了该数据
if (redisCommonUtil.hasKey(REDIS_KEY_SINGLE + id)) {
System.out.println("从缓存中获取 key=" + REDIS_KEY_SINGLE + id + " 数据");
user = (User) redisCommonUtil.get(REDIS_KEY_SINGLE + id);
} else {
System.out.println("从数据库中获取id=" + id + "的数据");
//2.从数据库读取数据
user = userMapper.selectById(id);
if (user != null) {
System.out.println("把数据存入缓存,key=" + REDIS_KEY_SINGLE + id);
//3.把数据存入缓存
redisCommonUtil.set(REDIS_KEY_SINGLE + id, user);
}
}
return user;
}
}
```
