springboot系列(二)整合redis

redis是一个高性能的key-value缓存型数据库，提供多种数据结构的存储，也支持主从配置，并且读写性能极高，也括发布与订阅（通知）等等的特性，功能强大。可以用来存放一些有限期的有效信息。

这个是在windows上面安装的redis，解压安装后可以看到有conf文件，这个conf文件的详细介绍可以参考这篇文章，我这里用过的是设置密码和在后台执行的守护进程。

在cmd窗口下，cd到redis的安装路径，执行redis-server.exe redis.window.conf,就可以指定conf文件的配置运行redis，然后另起一个cmd窗口，之前那个不要关，同样cd到那个路径，执行redis-cli.exe -h localhost -p 6379 (如果有密码 -a xxxx),就可以使用redis了，而面对java他们也提供jedis这个客户端，而我们做的事情就是集成redis。

pom文件添加依赖

[code]	<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>

然后我们编写jedis的连接池类和操作redis的工具类

连接池类：（可以用不同的构造方法构造客户端）

[code]package com.csdn.demospringboot.cache;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

//构造链接池
public class JedisPoolWriper {
private JedisPool jedisPool;

public JedisPoolWriper(final JedisPoolConfig poolConfig, final String host,
final int port,final int timeout,final String password) {
try {
jedisPool = new JedisPool(poolConfig, host, port,timeout,password);

} catch (Exception e) {
e.printStackTrace();
}
}

public JedisPool getJedisPool() {
return jedisPool;
}

public void setJedisPool(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}
}

工具操作类：

[code]package com.csdn.demospringboot.cache;

import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.util.SafeEncoder;

public class JedisUtil {
/** 操作Key的方法 */
public Keys KEYS;
/** 对存储结构为String类型的操作 */
public Strings STRINGS;

/** Redis连接池对象 */
private JedisPool jedisPool;

/**
* 获取redis连接池
*
* @return
*/
public JedisPool getJedisPool() {
return jedisPool;
}

/**
* 设置redis连接池
*
* @return
*/
public void setJedisPool(JedisPoolWriper jedisPoolWriper) {
this.jedisPool = jedisPoolWriper.getJedisPool();
}

/**
* 从jedis连接池中获取获取jedis对象
*
* @return
*/
public Jedis getJedis() {
Jedis jedis=jedisPool.getResource();

return jedis;
}

// *******************************************Keys*******************************************//
public class Keys {

public void expire(String key, int seconds) {
if (seconds <= 0) {
return;
}
Jedis jedis = getJedis();
jedis.expire(key, seconds);
jedis.close();
}

/**
* 清空所有key
*/
public String flushAll() {
Jedis jedis = getJedis();
String stata = jedis.flushAll();
jedis.close();
return stata;
}

public long del(String... keys) {
Jedis jedis = getJedis();
long count = jedis.del(keys);
jedis.close();
return count;
}

public long pttl(String key){
Jedis sjedis=getJedis();
long time=sjedis.pttl(key);
sjedis.close();
return time;
}

public boolean exists(String key) {
// ShardedJedis sjedis = getShardedJedis();
Jedis sjedis = getJedis();
boolean exis = sjedis.exists(key);
sjedis.close();
return exis;
}

/**
* 查找所有匹配给定的模式的键
*

*            key的表达式,*表示多个，？表示一个
*/
public Set<String> keys(String pattern) {
Jedis jedis = getJedis();
Set<String> set = jedis.keys(pattern);
jedis.close();
return set;
}
}

// *******************************************Strings*******************************************//
public class Strings {
/**
* 根据key获取记录
*

* @return 值
*/
public String get(String key) {
// ShardedJedis sjedis = getShardedJedis();
Jedis sjedis = getJedis();
String value = sjedis.get(key);
sjedis.close();
return value;
}

/**
* 添加记录,如果记录已存在将覆盖原有的value
*

* @return 状态码
*/
public String set(String key, String value) {
return set(SafeEncoder.encode(key), SafeEncoder.encode(value));
}

/**
* 添加记录,如果记录已存在将覆盖原有的value

*            value
* @return 状态码
*/
public String set(byte[] key, byte[] value) {
Jedis jedis = getJedis();
String status = jedis.set(key, value);
jedis.close();
return status;
}

}

}

然后配置我们的redis:

[code]package com.csdn.demospringboot.config.redis;

import com.csdn.demospringboot.cache.JedisPoolWriper;
import com.csdn.demospringboot.cache.JedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfiguration {
@Value("${redis.hostname}")
private String hostname;
@Value("${redis.port}")
private int port;
@Value("${redis.pool.maxActive}")
private int maxTotal;
@Value("${redis.pool.maxIdle}")
private int maxIdle;
@Value("${redis.pool.maxWait}")
private long maxWaitMillis;
@Value("${redis.pool.testOnBorrow}")
private boolean testOnBorrow;
@Value("${redis.password}")
private String password;
@Value("${redis.timeout}")
private int timeout;

@Autowired
private JedisPoolConfig jedisPoolConfig;
@Autowired
private JedisPoolWriper jedisWritePool;
@Autowired
private JedisUtil jedisUtil;

/**
* 创建redis连接池的设置
*
* @return
*/
@Bean(name = "jedisPoolConfig")
public JedisPoolConfig createJedisPoolConfig() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
// 控制一个pool可分配多少个jedis实例
jedisPoolConfig.setMaxTotal(maxTotal);
// 连接池中最多可空闲maxIdle个连接 ，这里取值为20，
// 表示即使没有数据库连接时依然可以保持20空闲的连接，
// 而不被清除，随时处于待命状态。
jedisPoolConfig.setMaxIdle(maxIdle);
// 最大等待时间:当没有可用连接时,
// 连接池等待连接被归还的最大时间(以毫秒计数),超过时间则抛出异常
jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
// 在获取连接的时候检查有效性
jedisPoolConfig.setTestOnBorrow(testOnBorrow);

return jedisPoolConfig;
}

/**
* 创建Redis连接池，并做相关配置
*
* @return
*/
@Bean(name = "jedisWritePool")
public JedisPoolWriper createJedisPoolWriper() {
JedisPoolWriper jedisPoolWriper = new JedisPoolWriper(jedisPoolConfig,hostname,port,timeout,password);
return jedisPoolWriper;
}

/**
* 创建Redis工具类，封装好Redis的连接以进行相关的操作
*
* @return
*/
@Bean(name = "jedisUtil")
public JedisUtil createJedisUtil() {
JedisUtil jedisUtil = new JedisUtil();
jedisUtil.setJedisPool(jedisWritePool);
return jedisUtil;
}

/**
* Redis的key操作
*
* @return
*/
@Bean(name = "jedisKeys")
public JedisUtil.Keys createJedisKeys() {
JedisUtil.Keys jedisKeys = jedisUtil.new Keys();
return jedisKeys;
}

/**
* Redis的Strings操作
*
* @return
*/
@Bean(name = "jedisStrings")
public JedisUtil.Strings createJedisStrings() {
JedisUtil.Strings jedisStrings = jedisUtil.new Strings();
return jedisStrings;
}
}

那么在运用的时候，我们可以通过注入bean@Autowried来在service层运用，或者通过一些别的方式运用，此致整合完毕，参考代码放在我的github上面。