spring boot 2.0 整合redis 完整代码

1.创建maven项目：

2.pom.xml：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.anwensheng</groupId>
  <artifactId>springboot_redis</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springboot_redis</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <includeSystemScope>true</includeSystemScope>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3.编写application.yml文件：

server:
  port: 8090
  servlet:
    context-path: /redis
#redis配置
spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 3000
    password: laoan2000    #密码
    jedis:
      pool:
        min-idle: 200
        max-idle: 200
        max-active: 2000
        max-wait: 10000

4.编写工具类：

package com.anwensheng.utils;

import java.io.Serializable;

/**
 * 后端相应包装类
 * 状态码200 返回成功
 * 500 响应有问题
 */
public class JsonData implements Serializable {

    private Integer code;//状态码
    private Object data;//返回数据
    private String message;//返回信息描述

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

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

    public JsonData() {
    }
    // 成功，只返回成功状态码
    public static JsonData buildSucceful() {
        return new JsonData(200, null, null);
    }
    // 成功，传入状态码和数据
    public static JsonData ok(Object data) {
        return new JsonData(200, data, null);
    }
    // 失败，传入描述信息,状态码
    public static  JsonData buildError(String message){
        return new JsonData(500,null,message);
    }
    // 失败，传入描述信息,状态码
    public static  JsonData buildError(Integer code,String message){
        return new JsonData(code,null,message);
    }
    // 成功，传入数据,及描述信息
    public static  JsonData buildSuccesful(Object data,String message){
        return new JsonData(200,data,message);
    }
    // 成功，传入数据,及状态码
    public static  JsonData buildSuccesful(Object data,Integer code){
        return new JsonData(code,data,null);
    }
}

package com.anwensheng.utils;

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtils {

    private static ObjectMapper mapper = new ObjectMapper();

    //对象转化成字符串
    public static <T> String objToString(T object) {
        if (object == null) {
            return null;
        }
        ;
        try {
            return object instanceof String ? (String) object : mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.getStackTrace();
            return null;
        }
    }
    //字符串转化成对象

    public static <T> T str2Object(String str, Class<T> clazz) {
        if (str == null || clazz == null) {
            return null;
        }
        try {
            return clazz.equals(String.class) ? (T) str : mapper.readValue(str, clazz);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

package com.anwensheng.utils;

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 redisTemplate;

    /**
     * 保存值到缓存里面
     * @param key
     * @param value
     * @return
     */
    public boolean setkey_Value(String key, String value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.getStackTrace();
            return false;
        }
    }

    /**
     * 通过key获取缓存里对应的value
     * @param key
     * @return
     */
    public String getValue(String key){
        return redisTemplate.opsForValue().get(key);
    }
}

5.编写控制层：

package com.anwensheng.controller;

import com.anwensheng.pojo.User;
import com.anwensheng.utils.JsonData;
import com.anwensheng.utils.JsonUtils;
import com.anwensheng.utils.RedisClient;
import io.lettuce.core.dynamic.annotation.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class RedisController {
    @Autowired
    private RedisClient redisClient;

    @RequestMapping("/addKey")
    public JsonData addKey(@Param("key") String key,@Param("value") String value) {
        boolean b = redisClient.setkey_Value(key, value);
        if(b){
            return JsonData.buildSucceful();
        }
        return JsonData.buildError("添加失败！");
    }
    @RequestMapping("/getKey")
    public JsonData getKey(@Param("key") String key) {
        String value = redisClient.getValue(key);
        if (value != null) {
            return JsonData.buildSuccesful(value, "获取成功！");
        }
        return JsonData.buildError("获取失败！");
    }

    @RequestMapping("/addUser")
    public JsonData addUser(){
        User user = new User();
        user.setName("李四");
        user.setPassword("90lai");
        String s = JsonUtils.objToString(user);
        if(s!=null){
            boolean flag = redisClient.setkey_Value("user1", s);
            if(flag){
                return JsonData.buildSuccesful(null,"success");
            }
        }
        return JsonData.buildError("fail");
    }
    @RequestMapping("/getUser")
    public JsonData getUser(){

        String str = redisClient.getValue("user1");
        User user = JsonUtils.str2Object(str, User.class);
        if(user!=null){
            return JsonData.buildSuccesful(user,"success");
        }
        return JsonData.buildError("未获取到相关值！");
    }
}

6.实体类：（测试用）

package com.anwensheng.pojo;

public class User {
    private Integer uId;

    private String name;

    private String password;

    public Integer getuId() {
        return uId;
    }

    public void setuId(Integer uId) {
        this.uId = uId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password == null ? null : password.trim();
    }
}

7.启动类

package com.anwensheng;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main( String[] args ) {
        SpringApplication.run(App.class,args);

    }
}

8.开启redis服务器和客户端：

9，开启应用程序服务

测试结果：