【转】 springBoot(8)---整合redis

【转】 springBoot(8)---整合redis

Springboot整合redis

 

步骤讲解

 

 1、第一步jar导入：

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

      如果你本地没有相应jar包，你可以在mevan存放jar包的库中，找到Setting文件，添加阿里云镜像，在跟新就可以下载相应jar包

       <mirror>
            <id>alimaven-central</id>
            <mirrorOf>central</mirrorOf>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
        </mirror>

 

第二步：application.properties配置

            spring.redis.database=0
            spring.redis.host=127.0.0.1
            spring.redis.port=6379
            # 连接超时时间 单位 ms（毫秒）
            spring.redis.timeout=3000

            #=========redis线程池设置=========
            # 连接池中的最大空闲连接，默认值也是8。
            spring.redis.pool.max-idle=200

            #连接池中的最小空闲连接，默认值也是0。
            spring.redis.pool.min-idle=200
            
            # 如果赋值为-1，则表示不限制；pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
            spring.redis.pool.max-active=2000

            # 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时
            spring.redis.pool.max-wait=1000

 

第三步创建实体

    User类

import java.util.Date;

public class User {

    private int age;
    
    private String pwd;
    
    private String phone;
    
    private Date createTime;

    
    
    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public User() {
        super();
    }

    public User(int age, String pwd, String phone, Date createTime) {
        super();
        this.age = age;
        this.pwd = pwd;
        this.phone = phone;
        this.createTime = createTime;
    }
}

JsonData工具类实体

/**
 * 这是后端向前端响应的一个包装类
 * 一般后端向前端传值会有三个属性
 * 1：响应状态
 * 2：如果响应成功，把数据放入
 * 3: 描述，响应成功描述，或者失败的描述
 */
public class JsonData implements Serializable {


    private static final long serialVersionUID = 1L;

    private Integer code; // 状态码 0 表示成功，1表示处理中，-1表示失败
    private Object data; // 数据
    private String msg;// 描述

    public JsonData() {
    }

    public JsonData(Integer code, Object data, String msg) {
        this.code = code;
        this.data = data;
        this.msg = msg;
    }

    // 成功，只返回成功状态码
    public static JsonData buildSuccess() {
        return new JsonData(0, null, null);
    }

    // 成功，传入状态码和数据
    public static JsonData buildSuccess(Object data) {
        return new JsonData(0, data, null);
    }

    // 失败，传入描述信息
    public static JsonData buildError(String msg) {
        return new JsonData(-1, null, msg);
    }

    // 失败，传入描述信息,状态码
    public static JsonData buildError(String msg, Integer code) {
        return new JsonData(code, null, msg);
    }

    // 成功，传入数据,及描述信息
    public static JsonData buildSuccess(Object data, String msg) {
        return new JsonData(0, data, msg);
    }

    // 成功，传入数据,及状态码
    public static JsonData buildSuccess(Object data, int code) {
        return new JsonData(code, data, null);
    }

    //提供get和set方法，和toString方法
}

 

第四步创建工具类

1、字符串转对象，对象转字符串工具类

import java.io.IOException;

import org.springframework.util.StringUtils;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 字符串转对象，对象转字符串的工具类
 * 因为StringRedisTemplate的opsForValue()方法需要key,value都需要String类型，所以当value值存入对象的时候
 * 先转成字符串后存入。
 */
public class JsonUtils {

    private static ObjectMapper objectMapper = new ObjectMapper();
    
    //对象转字符串
    public static <T> String obj2String(T obj){
        if (obj == null){
            return null;
        }
        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    //字符串转对象
    public static <T> T string2Obj(String str,Class<T> clazz){
        if (StringUtils.isEmpty(str) || clazz == null){
            return null;
        }
        try {
            return clazz.equals(String.class)? (T) str :objectMapper.readValue(str,clazz);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2、封装Redis类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * 功能描述：redis工具类
 * 对于redisTpl.opsForValue().set(key, value)进行了一次封装，不然每次都要这样保存值
 * 而封装后只需：new RedisClient().set(key,value);
 */
@Component
public class RedisClient {
    
    @Autowired
    private StringRedisTemplate redisTpl; //jdbcTemplate    

     // 功能描述：设置key-value到redis中    
    public boolean set(String key ,String value){
        try{
            redisTpl.opsForValue().set(key, value);
            return true;
        }catch(Exception e){
            e.printStackTrace();
            return false;
        }    
    }        

     // 功能描述：通过key获取缓存里面的值
    public String get(String key){
        return redisTpl.opsForValue().get(key);
    }        
}

 

第五步创建Controller类

RdisTestController

import java.util.Date;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.jincou.model.JsonData;
import com.jincou.model.User;
import com.jincou.until.JsonUtils;
import com.jincou.until.RedisClient;

@RestController
@RequestMapping("/api/v1/redis")
public class RdisTestController {

    
    //得到redis封装类
    @Autowired
    private RedisClient redis;
    
    //添加字符串
    @GetMapping(value="add")
    public Object add(){
         
        redis.set("username", "xddddddd");
        return JsonData.buildSuccess();
        
    }
    
    //通过key值得到value字符串
    @GetMapping(value="get")
    public Object get(){
        
        String value = redis.get("username");
        return JsonData.buildSuccess(value);
        
    }
    
    //将对象通过工具类转成String类型，存入redis中
    @GetMapping(value="save_user")
    public Object saveUser(){
        User user = new User(1, "abc", "11", new Date());
        String userStr = JsonUtils.obj2String(user);
        boolean flag = redis.set("base:user:11", userStr);
        return JsonData.buildSuccess(flag);
        
    }
    
    //通过key值得到value值，让后将value转为对象
    @GetMapping(value="find_user")
    public Object findUser(){

        String userStr = redis.get("base:user:11");
        User user = JsonUtils.string2Obj(userStr, User.class);
        return JsonData.buildSuccess(user);
        
    }        
}

 

测试效果

命名规范：如果我们key按"base:user:11"这来命名，那么那么会自动创建文件夹格式，方便查看。

 

 想太多，做太少，中间的落差就是烦恼。想没有烦恼，要么别想，要么多做。上尉【10】