springboot之整合redis

缓存应用场景

什么是缓存？
在互联网场景下，尤其 2C 端大流量场景下，需要将一些经常展现和不会频繁变更的数据，存放在存取速率更快的地方。缓存就是一个存储器，在技术选型中，常用 Redis 作为缓存数据库。缓存主要是在获取资源方便性能优化的关键方面
缓存的应用场景有哪些呢？
比如常见的电商场景，根据商品 ID 获取商品信息时，店铺信息和商品详情信息就可以缓存在 Redis，直接从 Redis 获取。减少了去数据库查询的次数。但会出现新的问题，需要对缓存进行更新，防止数据读入错误

image.png

Redis在CENTOS7中安装

daemonize设置为yes，设置为后台启动

image.png

运行在主机ip，端口6379地址

springboot整合redis-使用Jedis客户端

创建springboot工程

工程目录如下

image.png

pom文件

    4.0.0

    com.enowsh.springboot_redis
    demo
    0.0.1-SNAPSHOT
    jar

    demo
    Demo project for Spring Boot

    
        org.springframework.boot
        spring-boot-starter-parent
        2.0.2.RELEASE
         
    

    
        UTF-8
        UTF-8
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter-data-redis
            
                
                    ch.qos.logback
                    logback-classic
                
            
        
        
            org.springframework.boot
            spring-boot-starter-web
            
                
                    ch.qos.logback
                    logback-classic
                
            
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            1.3.2
        

        
            mysql
            mysql-connector-java
            runtime
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            com.alibaba
            druid
            1.0.9
        
        
            org.slf4j
            slf4j-log4j12
            1.7.25
        
        
            com.github.pagehelper
            pagehelper
            3.4.2
        
        
            redis.clients
            jedis
            2.9.0
        
        
            commons-lang
            commons-lang
            2.6
        


    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

注意：要在两个地方去掉logback-classic包，不然会报错

springboot整合mybatis

引入mapper文件，配置数据源以及mybatis等的配置，此处不再赘述

配置Jedis客户端

application.properties设置redis的属性

#redis配置
redis.host=192.168.73.128
redis.port=6379
#用户缓存key配置
REDIS_USER_KEY=REDIS_USER_KEY

写config类，配置Jedis

package com.enowsh.springboot_redis.config.redis;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author:wong
 */
@Configuration
public class RedisConfig {

    @Value("${redis.host}")
    private String host;

    @Value("${redis.port}")
    private int port;

    @Bean
    public JedisPool jedisPool(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port);
        return jedisPool;
    }

    @Bean
    public Jedis jedis(){
        Jedis jedis = jedisPool().getResource();
        return jedis;
    }
}

注意点：

• 使用@Value注解引入属性
• 创建JedisPool的bean，初始化构造函数参数，分别是：JedisPoolConfig对象，主机地址，端口号
• 为了使用方便，配置Jedis的bean

编写service测试

package com.enowsh.springboot_redis.service.impl;

import com.enowsh.springboot_redis.mapper.PmsUserMapper;
import com.enowsh.springboot_redis.pojo.PmsResult;
import com.enowsh.springboot_redis.pojo.PmsUser;
import com.enowsh.springboot_redis.service.UserService;
import com.enowsh.springboot_redis.utils.JsonUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import redis.clients.jedis.Jedis;

import java.util.Date;

/**
 * @author:wong
 */
@Service
@Transactional //默认开启所有public方法的事务
public class UserServiceImpl implements UserService {
    @Autowired
    private PmsUserMapper pmsUserMapper;

    @Autowired
    private Jedis jedis;

    @Value("${REDIS_USER_KEY}")
    private String REDIS_USER_KEY;

    @Override
    public PmsResult getUserById(long id) {
        //添加查询缓存逻辑
        try {
            String s = jedis.hget(REDIS_USER_KEY,id+"");
            if (!StringUtils.isBlank(s)){
                PmsUser pmsUser=JsonUtils.jsonToPojo(s,PmsUser.class);
                return PmsResult.ok(pmsUser);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        PmsUser pmsUser = pmsUserMapper.selectByPrimaryKey(id);
        if (pmsUser==null)
            return PmsResult.build(400,"未查询到用户");
        else {
            //添加写入缓存逻辑,将用户信息写入缓存，以json串的模式写入
            try {
                jedis.hset(REDIS_USER_KEY ,id+"", JsonUtils.objectToJson(pmsUser));
                //设置用户信息有效期,一天过期
                jedis.expire(REDIS_USER_KEY ,86400);
            }catch (Exception e){
                e.printStackTrace();
            }
            return PmsResult.ok(pmsUser);
        }
    }

    @Override
    public PmsResult getUserByIdentity(int identity) {
        return null;
    }

    @Override
    public PmsResult addUser(PmsUser user) {
        //添加删除缓存逻辑,问题是如何删除一类用户
        try{
            jedis.del(REDIS_USER_KEY);
        }catch (Exception e){
            e.printStackTrace();
        }
        if (user==null)
            return PmsResult.build(400,"用户为空");
        Date date=new Date();
        user.setCreated(date);
        user.setUpdated(date);
        pmsUserMapper.insert(user);
        return PmsResult.ok();
    }

    @Override
    public PmsResult testRedis() {
        String a = jedis.get("a");
        return PmsResult.ok(a);
    }

    @Override
    public PmsResult deleteUserById(long id) {
        return null;
    }

    @Override
    public PmsResult updateUser(PmsUser user) {
        return null;
    }
}

测试点：

• 查询数据：先从缓存中查询，如果命中，则返回数据，如果未命中，则从数据库中查询，并将数据写入缓存。此处写缓存使用Jedis的hset方法，利于统一规划管理
• 操作数据：操作数据时，为了防止更新后还是读缓存原来的数据，导致错误，需要清空缓存

controller

package com.enowsh.springboot_redis.controller;

import com.enowsh.springboot_redis.pojo.PmsResult;
import com.enowsh.springboot_redis.pojo.PmsUser;
import com.enowsh.springboot_redis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * @author:wong
 */
@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/find/{id}")
    @ResponseBody
    public PmsResult findUserById(@PathVariable long id){
        PmsResult pmsResult= userService.getUserById(id);
        return pmsResult;
    }

    @RequestMapping("/test/redis")
    @ResponseBody
    public PmsResult testRedis(){
        PmsResult pmsResult = userService.testRedis();
        return pmsResult;
    }

    @RequestMapping(value = "/add",method = RequestMethod.POST)
    @ResponseBody
    public PmsResult addUser(PmsUser user,String username){
        PmsResult pmsResult = userService.addUser(user);
        return pmsResult;
    }
}

测试结果

get请求：http://localhost:8080/user/find/44

image.png

缓存 ：

image.png

post请求：http://localhost:8080/user/add

image.png

缓存:

image.png