本文主要对springboot集成redis做一个简单的介绍。

文章中使用到的redis和redisclient工具可参考另外两篇博客进行下载和安装。

windows安装redis及redisClient客户端指导手册

第一步、创建springboot项目，idea创建即可，按照指导下一步下一步即可。

第二步、引入关键依赖。替换pom.xml为 ,主要的依赖为 spring-boot-starter-data-redis 其余是辅助工具，已有的springboot项目只引入这个依赖即可

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>redisexample</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redisexample</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

第三步、配置文件，设置redis的连接池属性，便于连接，此处设置需要和开启的redis服务对齐，如host、port、password

server.port=8080
#redis主机
spring.redis.host=127.0.0.1
#redis端口号
spring.redis.port=6379
#redis密码
spring.redis.password=
#redis连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#redis连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#redis连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#redis连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000

第四步、封装RedisUtil工具类，便于操作redis。具体参考

其中，封装的操作类主要为StringRedisTemplate，还有一个操作类RedisTemplate，他们为父子关系，两者的区别，就不做过多介绍。需要注意的是，两者是不能共用彼此存入的数据，谁存入一般谁才能取。

每个方法的作用，见名知意。对于zset，set、等可通过stringRedisTemplate.opsForxxx进行操作相应的数据结构。

其中StringRedisTemplate的注入获取，可通过注入，也可参考 

springboot获取bean的几种常用方式

/**
 * redis工具封装类
 *
 * @author object
 * @since 2022年6月18日
 */
public class RedisUtil {
    private static StringRedisTemplate stringRedisTemplate = SpringContextUtil3.getBean(StringRedisTemplate.class);
    private static final String DEAFAULT_KEY_PREFIX = "";

    private RedisUtil(){}

    public static <K,V> void strSet(K key, V value) {
        if (value != null) {
            stringRedisTemplate.opsForValue().set(DEAFAULT_KEY_PREFIX + key, JSON.toJSONString(value));
        }
    }

    public static <K, V> void strSet(K key, V value, long timeout, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(DEAFAULT_KEY_PREFIX + key, JSON.toJSONString(value), timeout, unit);
    }

    public static <K, SK, V> void hashPut(K key, SK subKey, V value) {
        stringRedisTemplate.opsForHash().put(DEAFAULT_KEY_PREFIX + key, subKey, value);
    }

    public static <K, SK, V> void hashPut(K key, SK subKey, V value, long timeout, TimeUnit unit) {
        stringRedisTemplate.opsForHash().put(DEAFAULT_KEY_PREFIX + key, subKey, value);
        stringRedisTemplate.expire(DEAFAULT_KEY_PREFIX + key, timeout, unit);
    }

    public static <K, SK> Object getHash(K key, SK subKey) {
        return stringRedisTemplate.opsForHash().get(DEAFAULT_KEY_PREFIX + key, subKey);
    }

    public static <K> String getStr(K key) {
        return stringRedisTemplate.opsForValue().get(DEAFAULT_KEY_PREFIX + key);
    }

    public static <K, V> V getObject(K key, Class<V> clazz) {
        String value = getStr(key);
        V result = null;
        if (!StringUtils.isEmpty(value)) {
            result = JSONObject.parseObject(value, clazz);
        }
        return result;
    }

    public static <K, V> List<V> getList(K key, Class<V> clazz) {
        String value = getStr(key);
        List<V> result = Collections.emptyList();
        if (!StringUtils.isEmpty(value)) {
            result = JSONArray.parseArray(value, clazz);
        }
        return result;
    }

    public static void delete(String key) {
        stringRedisTemplate.delete(key);
    }

    public static void delete(Collection<String> keys) {
        stringRedisTemplate.delete(keys);
    }

    public static byte[] dump(String key) {
        return stringRedisTemplate.dump(key);
    }

    public static Boolean hasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    // 设置过期时间
    public static Boolean expire(String key, long timeout, TimeUnit unit) {
        return stringRedisTemplate.expire(key, timeout, unit);
    }

    public static Boolean expireAt(String key, Date date) {
        return stringRedisTemplate.expireAt(key, date);
    }

    // 移除key的过期时间，永久保存
    public static Boolean persist(String key) {
        return stringRedisTemplate.persist(key);
    }

    public static Long getExpire(String key, TimeUnit unit) {
        return stringRedisTemplate.getExpire(key, unit);
    }

    public static Long getExpire(String key) {
        return stringRedisTemplate.getExpire(key);
    }
}

第五步、新建测试接口，便于测试redis操作，也可以在本地，不需要用接口的方式测试

@RequestMapping("/test")
@RestController(value = "/test")
public class TestApi {

    @Autowired
    TestService testService;

    @Autowired
    SpringContextUtil4 springContextUtil4;

    @Autowired
    SpringContextUtil5 springContextUtil5;

    @RequestMapping("/getobject/{key}")
    public User getObject(HttpServletRequest request, @PathVariable(value = "key") String key) {
        // 第一种
        StringRedisTemplate bean1 = SpringContextUtil1.getBean("stringRedisTemplate", StringRedisTemplate.class);
        // 第二种
        StringRedisTemplate bean2 = SpringContextUtil2.getBean(request.getServletContext(), "stringRedisTemplate", StringRedisTemplate.class);
        // 第三种
        StringRedisTemplate bean3 = SpringContextUtil3.getBean(StringRedisTemplate.class);
        // 第四种
        StringRedisTemplate bean4 = springContextUtil4.getBean(StringRedisTemplate.class);
        // 第五种
        StringRedisTemplate bean5 = springContextUtil5.getBean(StringRedisTemplate.class);
        return testService.getObject(key);
    }

    @RequestMapping("/addobject")
    public String addObject() {
        testService.addObjects();
        return "添加成功！！";
    }

    @RequestMapping("/addobjectlimit")
    public String addobjectlimit() {
        testService.addobjectlimit();
        return "限时,添加成功！！";
    }



    @RequestMapping("/addhash")
    public String addhash() {
        testService.addhash();
        return "addhash添加成功！！";
    }

    @RequestMapping("/addhashlimit")
    public String addhashlimit() {
        testService.addhashlimit();
        return "addhashlimit添加成功！！";
    }

    @RequestMapping("/gethash/{key}/{subkey}")
    public Object gethash(@PathVariable(value = "key") String key, @PathVariable(value = "subkey") String subkey) {
        return testService.gethash(key, subkey);
    }


}

@Service
public class TestService {
    public void addObjects() {
        User user = new User();
        user.setId(1);
        user.setName("test");
        user.setAge(16);

        RedisUtil.strSet("testKey", user);
    }

    public void addobjectlimit() {
        User user = new User();
        user.setId(1);
        user.setName("addobjectlimit");
        user.setAge(16);
        RedisUtil.strSet("addobjectlimit", user, 1, TimeUnit.MINUTES);
    }

    public User getObject(String key) {
        return RedisUtil.getObject(key, User.class);
    }

    public void addhash() {
        RedisUtil.hashPut("addhash", "addhashsubKey", "addhashValue");
    }

    public void addhashlimit() {
        RedisUtil.hashPut("addhashlimit", "addhashlimitsubKey", "addhashlimitValue", 1, TimeUnit.MINUTES);
    }

    public Object gethash(String key, String subKey) {
        return RedisUtil.getHash(key, subKey);
    }
}

@Data
public class User {
    private int id;
    private String name;
    private int age;
}

第六步、本地启动redis服务，redis成功启动后，启动springboot项目。

调用这个接口

    @RequestMapping("/addobject")
    public String addObject() {
        testService.addObjects();
        return "添加成功！！";
    }

调用前：

调用后：

和本地service写的代码一致，存储成功

第七步、获取刚刚存入的数据

调用这个接口，获取刚刚的数据 key需要传入刚刚传入的key,及 "testKey"

@RequestMapping("/getobject/{key}")
public User getObject(HttpServletRequest request, @PathVariable(value = "key") String key) {
    // 第一种
    StringRedisTemplate bean1 = SpringContextUtil1.getBean("stringRedisTemplate", StringRedisTemplate.class);
    // 第二种
    StringRedisTemplate bean2 = SpringContextUtil2.getBean(request.getServletContext(), "stringRedisTemplate", StringRedisTemplate.class);
    // 第三种
    StringRedisTemplate bean3 = SpringContextUtil3.getBean(StringRedisTemplate.class);
    // 第四种
    StringRedisTemplate bean4 = springContextUtil4.getBean(StringRedisTemplate.class);
    // 第五种
    StringRedisTemplate bean5 = springContextUtil5.getBean(StringRedisTemplate.class);
    return testService.getObject(key);
}

获取成功，本地调试成功。其余的接口，和测试就不再做更多的展示，本地自行调试。