SpringBoot整合Redis做缓存案例

前言

工作项目中使用SpringBoot框架结合Redis非关系型数据库做缓存功能，以提升数据查询效率。本文以此来记录开发过程。

一、开发步骤

1.引入Redis依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

根据SpringBoot自动版本仲裁机制，我们不需要指明redis的版本号。

2.编写redis配置信息

spring:
  application:
    name: service-user
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springcloud-alibaba-shop?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    username: root
    password: root
  redis:
    host: 192.168.220.131
    port: 6379
    password:
    database: 0
    ssl: false
    timeout: 50000d
    status: true
logging:
  config: classpath:logback-spring.xml
server:
  port: 8070
  servlet:
    context-path: /user
redis:
  status: true

3.Controller 层代码

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController extends BaseController {

    @Autowired
    private UserService userService;

    @GetMapping("/getUserByUserId")
    public Message.DataRespone<User> getUserByUserId(Integer userId) {
        User user = userService.getUserByUserId(userId);
        if (!ObjectUtils.isEmpty(user)) {
            return Message.Success.createWithData(user);
        }
        return Message.Result_IsNull.createWithData(null);
    }

}

4.Service 层代码

public interface UserService extends IService<User> {
    User getUserByUserId(int userId);
}

5.ServiceImpl 层代码

@Service
public class UserServiceImpl extends ServiceImpl<UserDao, User> implements UserService {
    @Autowired
    private UserDao userDao;
    @Resource
    private RedisUtil redisUtil;
    @Value("${redis.status}")
    private boolean redisStatus;

    private static final String REDIS_KEY_PREFIX = "USER_";

    @Override
    public User getUserByUserId(int userId) {
        User user = null;
        if (redisStatus) {
            user = (User) redisUtil.get(REDIS_KEY_PREFIX + "USER_ID_" + userId);
            if (!ObjectUtils.isEmpty(user)) {
                return user;
            }
        }
        if (ObjectUtils.isEmpty(user)) {
            user = userDao.selectById(userId);
            redisUtil.del(REDIS_KEY_PREFIX + "USER_ID_" + userId);
            if (!ObjectUtils.isEmpty(user)) {
                redisUtil.set(REDIS_KEY_PREFIX + "USER_ID_" + userId, user, 60 * 2);
            }
        }
        return user;
    }
}

6.RedisUtil Redis工具类

@Component
public class RedisUtil {


    private RedisTemplate<String, Object> redisTemplate;

    //指定用redis的序列化方式进行序列化
    @Resource
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        RedisSerializer stringSerializer = new StringRedisSerializer();//序列化为String
        //不能反序列化
        //Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);//序列化为Json
        GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(serializer);
        this.redisTemplate = redisTemplate;
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }    
}

7.发送请求，测试结果

8.查询出所有用户信息

public List<User> getAllUser() {
    List<User> result = new ArrayList<>();
    if (redisStatus) {
        List<Object> list = redisUtil.lGet(REDIS_KEY_PREFIX + "ALL_USER", 0, -1);
        if (!CollectionUtils.isEmpty(list)) {
            result = DataSwitchUtil.objToList(list, User.class);
        }
    }
    if (CollectionUtils.isEmpty(result)) {
        result = userDao.getAllUser();
        redisUtil.del(REDIS_KEY_PREFIX + "ALL_USER");
        redisUtil.lSet(REDIS_KEY_PREFIX + "ALL_USER", JSONArray.parseArray(JSON.toJSONString(result)), 60 * 2);
    }
    return result;
}

9.发送请求，测试结果