Redis（使用Jedis）初步使用
关于redis，网上有太多的介绍，也有使用，但是找了很多，基本都是用的spring-data-redis，而不是jedis。二者的比较可以在网上查看，个人还是先琢磨着用了jedis的实现。
提到redis，肯定会想到memcached，那就简单的介绍一下memcached。
memcached：内存对象缓存系统，能回避读取磁盘时发生的I/O消耗成本，在web应用程序和数据库之间复制粘贴memcached时会产生较好的读取性能。常用于需要快速查询的应用程序。memcached所有的值均是字符串，而redis支持丰富的功能集，同时redis可以持久化数据。
Redis：redis远程字典服务器，开源，高级的NOSQL键值数据存储。redis是一种内存型数据存储，也可以将它写入磁盘中实现耐久性。
redis使用两种方式来持久存储数据：RDB和AOF。
RDB持久性：按照指定的间隔对数据集执行时间点快照，不是非常持久，而且可能会丢失一些数据，但是速度非常快。
AOF持久性要长得多，而且记录了服务器收到的每个写入操作，写入操作在服务器启动时重新执行，重新构建原始数据集，查询redis时，将从内存中获取数据，绝不从磁盘获取数据。
Redis支持的数据类型：字符串，列表，集合，有序集，哈希值，速度快，操作原子性。所以多个客户端会并发访问一个redis服务器，获取相同的更新值。
Redis多效用，1，缓存2消息队列（redis支持发布，订阅）3短期应用程序数据（web回话，web页面命中计数）。
接下来记录我自己根据在网上研究的实现的一个小demo。
redis的安装网上有很多，可以自行研究安装。
环境：maven+mybaitis+springmvc
首先jar的引用：pom.xml中
<!--与redis集成-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.6.0</version>
</dependency>
然后配置文件：redis.properties
#redis相关配置
#最大连接数，设定为8
redis.maxTotal=8
#最大空闲连接数，设定为5
redis.maxIdle=5
#最小空闲连接数，即为初始化连接数，设定为1
redis.minIdle=1
#最大等待时间单位为毫秒，设定为10秒
redis.maxWaitMillis=10000
#对获取到的connection进行validateObject检验
redis.testOnBorrow=true
#redis域名或ip配置
redis.hostName=localhost
#redis开设的端口号
redis.port=6379
配置文件：spring-config-redis.xml
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:c="http://www.springframework.org/schema/c"
xmlns:p="http://www.springframework.org/schema/p"xmlns:cache="http://www.springframework.org/schema/cache"xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/cachehttp://www.springframework.org/schema/cache/spring-cache.xsd">
<!--basicjedispoolconfiguration-->
<beanid="JedisPoolConfig"class="redis.clients.jedis.JedisPoolConfig">
<!--最大连接数限制，系统默认为8-->
<propertyname="maxTotal"value="${redis.maxTotal}"/>
<!--最大空闲连接数限制，系统默认为8-->
<propertyname="maxIdle"value="${redis.maxIdle}"/>
<!--最小空闲连接数限制，系统默认为0-->
<propertyname="minIdle"value="${redis.minIdle}"/>
<!--最大等待时间单位为毫秒，设定为10秒-->
<propertyname="maxWaitMillis"value="${redis.maxWaitMillis}"/>
<!--对获取到的connection进行validateObject检验-->
<propertyname="testOnBorrow"value="${redis.testOnBorrow}"/>
<propertyname="timeBetweenEvictionRunsMillis"value="-1"/>
</bean>
<!--这边设置各个业务的redis域名/ip以及对应的端口号-->
<!--期望将各个业务应用用到的redis隔离开，目前通过端口号隔离-->
<beanid="JedisPool"class="redis.clients.jedis.JedisPool">
<constructor-argindex="0"ref="JedisPoolConfig"/>
<constructor-argindex="1"value="${redis.hostName}"/>
<constructor-argindex="2"value="${redis.port}"/>
</bean>
<!--JedisPoolmanager-->
<beanid="JedisTemplate"class="com.demo.modules.cache.jedis.JedisTemplate">
<constructor-argindex="0"name="jedisPool"ref="JedisPool"/>
</bean>
</beans>
JedisTemplate是另外实现的一个类。
publicclassJedisTemplate{
privateLoggerlogger=LoggerFactory.getLogger(JedisTemplate.class);
@Autowired
privateJedisPooljedisPool;
publicJedisTemplate(JedisPooljedisPool){
this.jedisPool=jedisPool;
}
//设置key并且设定一个默认失效时间
//设置失效时间，此处单位秒seconds
publicvoidset(Stringkey,Stringvalue,intexpiredseconds){
if(key!=null&&value!=null&&expiredseconds>0){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
//获取jedispool对象
jedisPool=getJedisPool();
if(jedisPool!=null){
//从jedispool连接池里边获取一个jedis连接对象
jedis=jedisPool.getResource();
jedis.setex(key,expiredseconds,value);
logger.info("jedisTemplate>>>setkey={},value={},expired={}succeed",newObject[]{key,value,expiredseconds});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>setkey={},value={},expired={}failede={}",newObject[]{key,value,expiredseconds,e.getCause()});
}finally{
//处理完毕后，一定将jedis连接对象释放回到连接池中
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
}
//设置key-value不设置失效时间
publicvoidset(Stringkey,Stringvalue){
if(key!=null&&value!=null){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
jedis.set(key,value);
logger.info("jedisTemplate>>>setkey={},value={}succeed",newObject[]{key,value});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>setkey={},value={}failede={}",newObject[]{key,value,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
}
//根据key查询value
publicStringget(Stringkey){
Stringvalue="";
if(null!=key&&!"".equals(key)){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
Stringtmp=jedis.get(key);
value=tmp!=null?tmp:value;
logger.info("jedisTemplate>>>getkey={},value={}succeed",newObject[]{key,value});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>getkey={},value={}failede={}",newObject[]{key,value,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
returnvalue;
}
//设置hset,key-fieldKey-value值
publicvoidhset(Stringkey,StringfieldKey,Stringvalue){
if(key!=null&&value!=null&&fieldKey!=null){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
jedis.hset(key,fieldKey,value);
logger.info("jedisTemplate>>>hsetkey={},fieldKey={},value={}succeed",newObject[]{key,fieldKey,value});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hsetkey={},fieldKey={},value={}failede={}",newObject[]{key,fieldKey,value,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
}
//获取hgetallkey对应的值，放在map<fieldKey,value>中返回
publicMap<String,String>hgetAll(Stringkey){
Map<String,String>map=newHashMap<String,String>();
if(key!=null){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
Map<String,String>tmpmap=jedis.hgetAll(key);
map=tmpmap!=null?tmpmap:map;
logger.info("jedisTemplate>>>hgetallkey={},value={}succeed",newObject[]{key,tmpmap});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hgetkey={},value={},failede={}",newObject[]{key,map,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
returnmap;
}
/**
*<pre>
*查询匹配keys全部key键值列表
*
*redis里边的keys*命令
*/
publicSet<String>keys(StringkeysPattern){
Set<String>set=newHashSet<String>();
if(keysPattern!=null&&!"".equals(keysPattern)){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
Set<String>tmp=jedis.keys(keysPattern);
set=tmp!=null?tmp:set;
logger.info("jedisTemplate>>>keyskeyPattern={},set.size={}",newObject[]{keysPattern,set.size()});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>keyskeyPattern={},failede={}",newObject[]{keysPattern,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
returnset;
}
//从hset中hget出对应的key-field对应的value值
publicStringhget(Stringkey,StringfieldKey){
Stringvalue="";
if(key!=null&&fieldKey!=null){
JedisPooljedisPool=null;
Jedisjedis=null;
try{
jedisPool=getJedisPool();
if(jedisPool!=null){
jedis=jedisPool.getResource();
Stringtmp=jedis.hget(key,fieldKey);
value=tmp!=null?tmp:value;
logger.info("jedisTemplate>>>hgetkey={},fieldKey={},value={}succeed",newObject[]{key,fieldKey,value});
}
}catch(Exceptione){
if(jedisPool!=null){
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hgetkey={},fieldKey={},value={}failede={}",newObject[]{key,fieldKey,value,e.getCause()});
}finally{
if(jedisPool!=null){
jedisPool.returnResource(jedis);
}
}
}
returnvalue;
}
publicJedisPoolgetJedisPool(){
returnjedisPool;
}
publicvoidsetJedisPool(JedisPooljedisPool){
this.jedisPool=jedisPool;
}
}
接下来在service中使用
@Service
publicclassUserServiceImplimplementsUserService{
@Autowired
privateUserRepositoryuserRepository;
@Autowired
privateJedisTemplatejedisTemplate;
publicUsergetUserByName(Stringname){
Useru=(User)SerializeUtil.deserialization(jedisTemplate.get("user"));
Useruser=null;
if(null==u){
user=userRepository.getUserByUserName(name);
jedisTemplate.set("user",SerializeUtil.serialization(user),1*60*60);
}else{
user=u;
}
returnuser;
}
}
SerializeUtil是一个序列化的工具类：
publicclassSerializeUtil{
publicstaticStringserialization(Objectobj){
Stringresult=StringUtils.EMPTY;
ObjectOutputStreamoos=null;
try{
ByteArrayOutputStreambos=newByteArrayOutputStream();
oos=newObjectOutputStream(bos);
oos.writeObject(obj);
result=bos.toString("ISO-8859-1");
result=URLEncoder.encode(result,"UTF-8");
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
if(oos!=null){
oos.close();
oos=null;
}
}catch(Exceptione){
}
returnresult;
}
}
publicstaticObjectdeserialization(Stringserial){
if(StringUtils.isBlank(serial)){
returnnull;
}
ObjectInputStreamois=null;
Objectresult=null;
try{
Stringstr=URLDecoder.decode(serial,"UTF-8");
ByteArrayInputStreambis=newByteArrayInputStream(str.getBytes("ISO-8859-1"));
ois=newObjectInputStream(bis);
result=ois.readObject();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(ClassNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}finally{
try{
if(ois!=null){
ois.close();
ois=null;
}
}catch(Exceptione){
}
returnresult;
}
}
}
再加上controller调用service方法。打开本地的redis服务。