redis个人基础教程（三）springboot redis demo篇

前提需要启动redis服务

1. 引入pom

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

2. 在yml中配置redis参数

spring:
  redis:
    host: 127.0.0.1
    password:
    port: 6379
    database: 0
    timeout: 60s  # 数据库连接超时时间，2.0 中该参数的类型为Duration，这里在配置的时候需要指明单位
    # 连接池配置，2.0中直接使用jedis或者lettuce配置连接池
    lettuce:
      pool:
        # 最大空闲连接数
        max-idle: 500
        # 最小空闲连接数
        min-idle: 50
        # 等待可用连接的最大时间，负数为不限制
        max-wait:  -1
        # 最大活跃连接数，负数为不限制
        max-active: -1

3. 设置配置类，大致的思路采用lettuce，先读取配置，初始化连接，然后创建RedisTemplate设置连接工厂

这里使用了连接池相关配置需要额外引入pom

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
			<version>2.5.0</version>
		</dependency>

package com.skindow.config;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;

import java.time.Duration;

/**
 * Created by Administrator on 2019/8/19.
 */
public class RedisConfig {
    @Bean
    @ConditionalOnBean(name = "defaultRedisConfig")
    public LettuceConnectionFactory defaultLettuceConnectionFactory(RedisStandaloneConfiguration defaultRedisConfig,
                                                                    GenericObjectPoolConfig defaultPoolConfig) {
        LettuceClientConfiguration clientConfig =
                LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(100))
                        .poolConfig(defaultPoolConfig).build();
        return new LettuceConnectionFactory(defaultRedisConfig, clientConfig);
    }

    @Bean
    @ConditionalOnBean(name = "defaultLettuceConnectionFactory")
    public RedisTemplate<String, String> defaultRedisTemplate(
            LettuceConnectionFactory defaultLettuceConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(defaultLettuceConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Configuration
    @ConditionalOnProperty(name = "host", prefix = "spring.redis")
    public static class DefaultRedisConfig {
        @Value("${spring.redis.host}")
        private String host;
        @Value("${spring.redis.port}")
        private Integer port;
        @Value("${spring.redis.password}")
        private String password;
        @Value("${spring.redis.database}")
        private Integer database;

        @Value("${spring.redis.lettuce.pool.max-active}")
        private Integer maxActive;
        @Value("${spring.redis.lettuce.pool.max-idle}")
        private Integer maxIdle;
        @Value("${spring.redis.lettuce.pool.max-wait}")
        private Long maxWait;
        @Value("${spring.redis.lettuce.pool.min-idle}")
        private Integer minIdle;

        @Bean
        public GenericObjectPoolConfig defaultPoolConfig() {
            GenericObjectPoolConfig config = new GenericObjectPoolConfig();
            config.setMaxTotal(maxActive);
            config.setMaxIdle(maxIdle);
            config.setMinIdle(minIdle);
            config.setMaxWaitMillis(maxWait);
            return config;
        }

        @Bean
        public RedisStandaloneConfiguration defaultRedisConfig() {
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
            config.setHostName(host);
            config.setPassword(RedisPassword.of(password));
            config.setPort(port);
            config.setDatabase(database);
            return config;
        }
    }
}

4. 创建java类测试
   注意：由于我在提供者使用redis所以我这边测试需要使用消费者去调用dubbo接口，为了省麻烦你可以直接在控制层调用

创建提供者

   @Override
    public String testRedis(String key,String value) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value))
        {
            return "key or value is empty!";
        }
        //10s有效期
        defaultRedisTemplate.opsForValue().set(key,value,60, TimeUnit.SECONDS);
        return "success";
    }

   @Override
    public String getValueByKey(String key) {
        if (StringUtils.isEmpty(key))
        {
            return "key is empty!";
        }
        return defaultRedisTemplate.opsForValue().get(key);
    }

创建api接口

    String testRedis(String key,String value);
    String getValueByKey(String key);

创建消费者

@RequestMapping("/api/demo")
public class DemoController {
    @Autowired
    private DemoService demoService;
 	@RequestMapping("/setRedis")
    @ResponseBody
    public String setRedis(@RequestParam(value="value") String value,@RequestParam(value="key") String key)
    {
        return demoService.testRedis(key,value);
    }
    @RequestMapping("/getRedis")
    @ResponseBody
    public String getRedis(@RequestParam(value="key") String key)
    {
        return demoService.getValueByKey(key);
    }
    }

5. 调用API测试redis

这里我使用postmen进行测试，当然由于get请求方式你可以直接使用浏览器进行调用

ok，成功。我们用Redis Desktop Manager 工具进行查看

通过截图我们可以看key-value成功放到redis当中，并且可以看出当前剩余时间为55s
现在我们调用api查询该key

成功获取到该key对应的value值
项目地址：
https://github.com/skindowSyc/firstProject.git 对应tag redisDemo