SpringBoot - Redis 连接池

Redis 主要是用来做一些数据的缓存，用来处理一些临时数据，比如用户登录凭证，频繁访问但不会频繁更新的数据，

想使用 Redis 连接池。

首先需要在 中导入如下包：

<dependency>
    <groupId></groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.</version>
</dependency>
<dependency>
    <groupId></groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

然后需要创建一个配置文件 :

import org.;
import org.;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;

@Configuration  
@EnableAutoConfiguration  
public class RedisConfig {

    private Logger logger = (());

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

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

    @Value("${}")
    private int timeout;

    @Value("${-idle}")
    private int maxIdle;

    @Value("${-wait}")
    private long maxWaitMillis;

    @Value("${}")
    private String password;
      
    @Bean  
    @ConfigurationProperties(prefix="")  
    public JedisPoolConfig getRedisConfig(){  
        JedisPoolConfig config = new JedisPoolConfig();
        (maxIdle);
        (maxWaitMillis);
        return config;
    }  
      
    @Bean  
    @ConfigurationProperties(prefix="")  
    public JedisConnectionFactory getConnectionFactory(){  
        JedisConnectionFactory factory = new JedisConnectionFactory();  
        JedisPoolConfig config = getRedisConfig();  
        (config);
        (host);
        (password);
        (timeout);
        ("JedisConnectionFactory bean init success.");  
        return factory;  
    }  
      
      
    @Bean  
    public RedisTemplate<?, ?> getRedisTemplate(){
        return new StringRedisTemplate(getConnectionFactory());
    }
}

在代码里面配置好RedisConfig后，需要在 中配置 Redis 参数：

########################################################
###Redis (RedisConfiguration)
########################################################
=0
=6379
=127.0.0.1
=123

-idle=8
-idle=1
-active=8
-wait=6000
=5000

配置好之后，还需要封装一个操作类，用来简化我们的操作，首先定义接口：

/**
 * Redis 操作封装类
 *
 * @author Demon-HY
 */
public interface RedisService {

    boolean set(String key, String value);

    String get(String key);

    boolean expire(String key, long expire);

    <T> boolean setList(String key, List<T> list);

    <T> List<T> getList(String key, Class<T> clz);

    long lpush(String key, Object obj);

    long rpush(String key, Object obj);

    String lpop(String key);

    boolean set(final String key, final String value, long expire);


    Long incr(String key, long growthLength);

    boolean del(String key);
}  

接下来实现这个接口，在实现里面会用到我们之前配置的RedisConfig 中的 RedisTemplate：

@Service
public class RedisServiceImpl implements RedisService, Serializable {

    @Autowired
    private RedisTemplate<String, ?> redisTemplate;

    @Override
    public boolean set(final String key, final String value) {
        return ((RedisCallback<Boolean>) connection -> {
            RedisSerializer<String> serializer = ();
            ((key), (value));
            return true;
        });
    }

    @Override
    public boolean set(final String key, final String value, long expire) {
        set(key, value);
        return expire(key, expire);
    }

    @Override
    public String get(final String key) {
        try {
            return ((RedisCallback<String>) connection -> {
                RedisSerializer<String> serializer = ();
                byte[] value = ((key));
                return (value);
            });
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public boolean expire(final String key, long expire) {
        return (key, expire, );
    }

    @Override
    public <T> boolean setList(String key, List<T> list) {
        String value = (list);
        return set(key, value);
    }

    @Override
    public <T> List<T> getList(String key, Class<T> clz) {
        String json = get(key);
        if (json != null) {
            return (json, clz);
        }
        return null;
    }

    @Override
    public long lpush(final String key, Object obj) {
        final String value = (obj);

        return ((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = ();
            return ((key), (value));
        });
    }

    @Override
    public long rpush(final String key, Object obj) {
        final String value = (obj);
        return ((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = ();
            return (long) ((key), (value));
        });
    }

    @Override
    public String lpop(final String key) {
        return ((RedisCallback<String>) connection -> {
            RedisSerializer<String> serializer = ();
            byte[] res = ((key));
            return (res);
        });
    }

    @Override
    public Long incr(String key, long growthLength) {
        return ().increment(key, growthLength);
    }

    @Override
    public boolean del(String key) {
        return ((RedisCallback<Boolean>) connection -> {
            RedisSerializer<String> serializer = ();
            ((key));
            return true;
        });
    }
}

现在准备工作都好了，可以直接使用了：

@RestController
public class TestHttpApi implements Serializable {

    @Autowired
    private RedisService redisService;

    @RequestMapping("test")
    public void testRedis() {
        ("test", "123");
        ("test", 10);
    }
}