SSM框架整合Redis及简单使用

工具：Eclipse
环境：JDK8 Tomcat8.5
Redis版本：3.0.504

1.导入jar包

除了SSM相关jar包外，还要导入redis的相关jar包(这里我用的是：spring-data-redis-1.8.4.RELEASE.jar、jedis-2.9.0.jar），项目jar所以jar包如下：

2.增加Redis的配置文件

在Spring配置文件(我的文件名是：applicationContext.xml)的基础上创建application-redis.xml，application-redis.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    <!--设置连接池-->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="300"/>
        <!-- 最大连接数 -->
        <property name="maxTotal" value="500" />
        <!-- 每次释放连接的最大数目 -->
        <property name="numTestsPerEvictionRun" value="1024" />
        <!-- 释放连接的扫描间隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="30000" />
        <!-- 连接最小空闲时间 -->
        <property name="minEvictableIdleTimeMillis" value="1800000" />
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="1000" />
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="true" />
        <property name="testOnReturn" value="true" />
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="true" />
        <!-- 连接耗尽时是否阻塞, false报异常,true阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted" value="false" />
    </bean>
    <!--Spring整合Jedis,设置连接属性-->
    <!--
      hostName->自己的redis访问地址
      port->redis端口
      password->redis访问地址对应的密码
      pool-config-ref->引用连接池的配置
     -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:hostName="127.0.0.1" 
          p:port="6379"
          p:password="yuange"
          p:pool-config-ref="poolConfig"
          p:timeout="100000"/>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer">
        	<!--对key的序列化器-->
        	<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对value的序列化器-->
        <property name="valueSerializer">
           <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对hash key的序列化器-->
   		 <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对hash value的序列化器-->
 		<property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
    </bean>
</beans>

这里有很重要的一点：从Redis中读写都需要进行序列化器，如果序列化器没有配置好，那么在进行读写的时候会出现乱码。
配置好application-redis.xml之后，在applicationContext.xml文件中引用application-redis.xml的配置(即在applicationContext.xml中beans标签内插入以下代码)

<!--引用src路径下的application-redis.xml-->
<import resource="classpath:application-redis.xml" />

添加完成后spring的配置文件如下：

创建Springmvc配置文件

3.创建用于操作redis的接口

在src目录下创建service包，并创建接口RedisOperate.java和其实现类RedisOperateImpl.java。

RedisOperate.java

package service;
import java.util.Map;
/*
 * 简单操作的接口
 */
public interface RedisOperate {
	public String get(String key);//获取string key的value
	public void hmset(String key,Map<String,String> map);//创建多个hash key
	public void hset(String key,String field,String value);//创建hash key
	public void set(String key,String value);//创建string key
}

RedisOperateImpl.java

package service;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
/*
 * 简单操作的接口实现
 */
@Service("redisOperate")   
public class RedisOperateImpl implements RedisOperate{
	private static final Log logger = LogFactory.getLog(RedisOperateImpl.class);//日志
	@Resource(name="redisTemplate")
    private RedisTemplate<String,String> redisTemplate;
	@Override
	public String get(String key) {
		return (String)redisTemplate.opsForValue().get(key);
	}
	@Override
	public void hmset(String key,Map<String,String> map) {
		redisTemplate.opsForHash().putAll(key, map);
	}
	@Override
	public void hset(String key, String field, String value) {
		redisTemplate.opsForHash().put(key,field,value);
	}
	@Override
	public void set(String key, String value) {
		redisTemplate.opsForValue().set(key, value);
	}
}

4.启动redis

如下图说明启动成功

打开redis目录下的redis-cli测试我们在配置文件中设置的地址和密码能否连接到redis，连接成功如下图

5.测试操作redis

创建controller包，并在其目录下创建IndexController.java，通过web页面展示redis的内容来测试对redis的操作。

首先我们先往redis里面设置一个key，IndexController.java的代码如下：

package controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import service.RedisOperate;
@Controller
public class IndexController {
	@Autowired
	private RedisOperate redisOperate;
	@ResponseBody
	@RequestMapping("/test")
	public String test() {
		/*创建string key*/
		redisOperate.set("one","1111111111");
		return "hello redis";
	}
}

在浏览器的地址栏输入 http://localhost:8080/redisTest/test，进入此页面，当进入此页面时，按照IndexController.java中的逻辑，我们创建了一个名字为“one”的key，它的值是1111111111。为了验证这一操作，我们运行redis目录下的redis-cli，进入我们配置文件中配置的地址（127.0.0.1）和密码（yuange），然后执行 get one 命令，看看能不能获取到刚刚controller设置的值，如下图：

由图可见，controller中往redis里面set key的操作成功。

那么set一个hash key呢？同理，将IndexController.java中test()方法的代码改写为如下代码，然后在浏览器输入http://localhost:8080/redisTest/test，进入页面。

@RequestMapping("/test")
	@ResponseBody
	public String test() {
		redisOperate.hset("two","name","zhoujielun");
		return "hello redis";
	}

这时候，按理说redis中应该有一个名字为two的key，且它的有一个属性为name，属性值为zhoujielun，按照上面的方法，我们先用 hget two name 命令获取一下刚刚设置的key值，结果如下：

然而，从结果看出，这个者为空。难道刚刚的操作没有成功吗？于是我们首先判断该key是否存在
由图可见，two这个key是存在的。既然存在，我们就用 hgetall命令看看他的所有属性的属性值，验证属性是否设置成功，如下图：
图中 1）后面的属性名称（field），2）后面的是属性值（value）。从图中国可知，属性名本来应该是name，但是前面却多了一串不知道什么东西的乱码，属性值也是一样，这就是application-redis.xml中hash key的序列化配置错误引起的。
我们在controller设置key和value类型应该要与序列化器类型对应。

redisOperate.hset("two","name","zhoujielun");

由这行代码可知，key和value的类型都是string，但是我最开始只配置了string key的string类型序列化器，并没有配置 hash key的string类型序列化器，如下

所有，加上hash key的string类型序列化器，就行了。所以，对于本项目的测试（我这里配置的都是string类型对应的序列化器，如果插入的值非string类型，需要对应另外类型的序列化器），正确的序列化配置如下：

<property name="keySerializer">
        	<!--对key的序列化器-->
        	<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对value的序列化器-->
        <property name="valueSerializer">
           <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对hash key的序列化器-->
   		 <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        	<!--对hash value的序列化器-->
 		<property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>

设置好之后，重启项目，查看用hgetall查看结果如下：

插入 hash key成功！

接下来，将IndexController.java的test()方法改成：

		@RequestMapping(value = "/test",produces = "application/json; charset=utf-8")
	@ResponseBody
	public String test() {
		String redisKey = redisOperate.get("one");
		return "redis中获得的value是"+redisKey;
	}

再次进入 http://localhost:8080/redisTest/test 页面
然后进入用get命令获取one的值

页面展示的结果和redis中的一样，取值成功。
同理，RedisTemplate对redis其他的操作也可以通过上述步骤实现操作redis。