第一步：依赖包导入（pom.xml）
<!-- 这两个包分别是Jedis与redisTemplate的使用，其实redisTemplate底层用到了Jedis，后面工具类我会说明两个用法区别-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.7.1.RELEASE</version>
</dependency>
第二步：数据源与配置文件（ApplicationContext-redis.xml 与 redis.properties）
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
">
<!-- 加载配置 -->
<context:property-placeholder location="classpath:redis.properties" />
<!-- jedis连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="maxWaitMillis" value="${redis.maxWait}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
<property name="maxTotal" value="${redis.maxTotal}" />
<property name="blockWhenExhausted" value="true" />
</bean>
<!-- jedis连接工程的配置 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}" />
<property name="port" value="${redis.port}" />
<property name="poolConfig" ref="jedisPoolConfig" />
<property name="password" value="" />
<property name="usePool" value="true"/>
<property name="timeout" value="${redis.timeout}"></property>
</bean>
<!-- redisTemplate配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<!-- 对key的默认序列化器。默认值是StringSerializer -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<!-- 是对value的默认序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。 -->
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
<!-- 存储Map时key需要的序列化配置 -->
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<!-- 存储Map时value需要的序列化配置 -->
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
</bean>
</beans>#redis中心
#绑定的主机地址
redis.host=127.0.0.1
#指定Redis监听端口，默认端口为6379
redis.port=6379
#授权密码（可以不使用，默认无密码，如果需要，去安装目录下修改配置）
redis.password=******
#最大空闲数：空闲链接数大于maxIdle时，将进行回收
redis.maxIdle=100
#最大连接数：能够同时建立的“最大链接个数”
redis.maxTotal=200
#最大等待时间：单位ms
redis.maxWait=1000
#使用连接时，检测连接是否成功
redis.testOnBorrow=false
#当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
redis.timeout=10000
第三步：工具类封装（redisTemplate 和 Jedis各方法的使用）
/**
* redis工具类
* @author cg
* @date 2018年11月27日
*/
@Service("redisDaoSupport")
public class RedisDaoSupport{
//使用注解，引入redisTemplate对象
@Resource(name="redisTemplate")
RedisTemplate<String, Object> redisTemplate;
/**
* 删除/判断（修改此处暂不写，其实就是先删再存）
*/
//删除key和对应的value
public void delete(String key){
redisTemplate.delete(key);
}
//删除多个key和对应的value
public void delete(List<String> keys){
redisTemplate.delete(keys);
}
//判断是否含key
public Boolean hasKey(String key){
return redisTemplate.hasKey(key);
}
/**
* 方式一：以Object形式存取,其实就是强行把各类型.toString之后存取,注意原则怎么存的怎么取，然后强转
*/
//保存key-Object
public void set(String key,Object obj){
redisTemplate.opsForValue().set(key, obj);
}
//获取key-Object
public Object get(String key){
return redisTemplate.opsForValue().get(key);
}
//保存key-Object，同时设置失效时间(秒)，也可毫秒，分，时，天，具体进入TimeUnit查看更改。因为redis版本过低 我不支持毫秒级别及以下的 过期时间类型，如有需求升高版本就行
public void setAndTimeOut(String key,Object obj, Integer expise){
redisTemplate.opsForValue().set(key, obj, expise,TimeUnit.SECONDS);
}
/**
* 方式二：以各类型结构形式存取各对象,使用redisTemplate包方法
*/
//String存储
public void setString(String key,String str){
redisTemplate.opsForValue().set(key, str);
}
//String存储(设置失效)
public void setStringAndTimeOut(String key,String str,Integer expise){
redisTemplate.opsForValue().set(key, str);
redisTemplate.expire(key, expise, TimeUnit.SECONDS);
}
//String获取
public String getString(String key){
return redisTemplate.opsForValue().get(key).toString();
}
//List存储
public void setList(String key,List<Object> value2){
redisTemplate.opsForList().leftPush(key,value2);
}
//List存储(设置失效)
public void setListAndTimeOut(String key,List<Object> value2,Integer expise){
redisTemplate.opsForList().leftPush(key,value2);
redisTemplate.expire(key, expise, TimeUnit.SECONDS);
}
//List获取
@SuppressWarnings("unchecked")
public List<Object> getList(String key){
return (List<Object>)redisTemplate.opsForList().leftPop(key);
}
//Map存储
public void setMap(String key,Map<Object,Object> value3){
redisTemplate.opsForHash().putAll(key,value3);
}
//Map存储(设置失效)
public void setMapAndTimeOut(String key,Map<Object,Object> value3,Integer expise){
redisTemplate.opsForHash().putAll(key,value3);
redisTemplate.expire(key, expise, TimeUnit.SECONDS);
}
//Map获取
public Map<Object,Object> getMap(String key){
return redisTemplate.opsForHash().entries(key);
}
//取所有key
public Set<Object> getMapKeys(String key){
return redisTemplate.opsForHash().keys(key);
}
//取所有value
public List<Object> getMapValues(String key){
return redisTemplate.opsForHash().values(key);
}
//取对应Map对应key值
public Object getValueByMapKey(String map,String key){
return redisTemplate.opsForHash().get(map, key);
}
//Set存储
public void setSet(String key,Set<Object> set){
redisTemplate.opsForSet().add(key, set);
}
//Set存储(设置失效)
public void setSetAndTimeOut(String key,Set<Object> set,Integer expise){
redisTemplate.opsForSet().add(key, set);
redisTemplate.expire(key, expise, TimeUnit.SECONDS);
}
//Set获取
public Set<Object> getSet(String key){
return redisTemplate.opsForSet().members(key);
}
/**
* 方式三：使用依赖包Jedis相应方法进行（Set,Map,List）类型结构形式存取各对象
*/
//先获取Jedis
public Jedis getJedis(){
Properties pros = getPprVue();
String host = pros.getProperty("redis.host"); //地址
String port = pros.getProperty("redis.port"); //端口
String pass = pros.getProperty("redis.pass"); //密码
Jedis jedis = new Jedis(host,Integer.parseInt(port));
jedis.auth(pass);
return jedis;
}
//读取redis.properties 配置文件
public Properties getPprVue(){
InputStream inputStream = DbFH.class.getClassLoader().getResourceAsStream("redis.properties");
Properties p = new Properties();
try {
p.load(inputStream);
inputStream.close();
} catch (IOException e) {
//读取配置文件出错
e.printStackTrace();
}
return p;
}
//新增(存储Map)
public String addMap(String key, Map<String, String> map) {
Jedis jedis = getJedis();
String result = jedis.hmset(key,map);
jedis.close();
return result;
}
//获取map
public Map<String,String> getMap2(String key){
Jedis jedis = getJedis();
Map<String, String> map = new HashMap<String, String>();
Iterator<String> iter=jedis.hkeys(key).iterator();
while (iter.hasNext()){
String ikey = iter.next();
map.put(ikey, jedis.hmget(key,ikey).get(0));
}
jedis.close();
return map;
}
//新增(存储List)
public void addList(String key, List<String> list){
Jedis jedis = getJedis();
jedis.del(key); //开始前，先移除所有的内容
for(String value:list){
jedis.rpush(key,value);
}
jedis.close();
}
//获取List
public List<String> getList2(String key){
Jedis jedis = getJedis();
List<String> list = jedis.lrange(key,0,-1);
jedis.close();
return list;
}
//新增(存储set)
public void addSet(String key, Set<String> set){
Jedis jedis = getJedis();
jedis.del(key);
for(String value:set){
jedis.sadd(key,value);
}
jedis.close();
}
//获取Set
public Set<String> getSet2(String key){
Jedis jedis = getJedis();
Set<String> set = jedis.smembers(key);
jedis.close();
return set;
}
/*
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("spring/ApplicationContext-redis.xml");
RedisTemplate redisTemplate=(RedisTemplate) context.getBean("redisTemplate");
System.out.println(redisTemplate.opsForHash().get("key", "username"));
System.out.println(redisTemplate.opsForHash().get("key", "age"));
}*/
}
第四步：通过Debug来模拟测试
//##############jquery请求准备（简易的）###############
<button class="btn" onclick="testRedis()">redis封装测试</button><br /><br/>
//redis测试
function testRedis() {
$.post(' http://127.0.0.1:8080/cg/appRedisDemo/redisDemo', {
}, function(rescnt) {
console.log(rescnt);
})
}
/**
* RedisDemo
* @author cg
* @date 2018年11月28日
*/
@Controller
@RequestMapping(value="/appRedisDemo")
public class RedisDemoController extends BaseController{
@Resource(name="redisDaoSupport")
private RedisDaoSupport redisDaoSupport;
/**
* 请讲接口 http://127.0.0.1:8080/项目名称/appRedisDemo/redisDemo.do
* demo展示的测试redisDaoSupport各封装方法,前提打开redis服务端
* 具体redis的应用场景->百度下即可
*/
@SuppressWarnings("unchecked")
@RequestMapping(value="/redisDemo")
@ResponseBody
public Object redis(){
Map<String,Object> map = new HashMap<String,Object>();
//为避免错误，通过以下步骤来清理也就是理解为初始化，测试做准备，完全没必要
redisDaoSupport.set("aaa","111" );// debug处
redisDaoSupport.set("bbb","222" );
redisDaoSupport.set("ccc","333" );
redisDaoSupport.set("ddd","444" );
redisDaoSupport.set("eee","555" );
System.err.println(redisDaoSupport.hasKey("aaa"));//debug处
System.err.println(redisDaoSupport.hasKey("bbb"));
System.err.println(redisDaoSupport.hasKey("ccc"));
System.err.println(redisDaoSupport.hasKey("ddd"));
System.err.println(redisDaoSupport.hasKey("eee"));
redisDaoSupport.delete("aaa");// debug处
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.err.println(redisDaoSupport.hasKey("aaa"));//判断缓存里是否有key debug处
System.err.println(redisDaoSupport.hasKey("bbb"));//判断缓存里是否有key
System.err.println(redisDaoSupport.hasKey("ccc"));//判断缓存里是否有key
System.err.println(redisDaoSupport.hasKey("ddd"));//判断缓存里是否有key
System.err.println(redisDaoSupport.hasKey("eee"));//判断缓存里是否有key
//模拟数据
String value1="大家好";//String debug处
Map<Object, Object> value2 = new HashMap<Object, Object>();//Map
value2.put("name", "岗子");
value2.put("age", "22");
List<Object> value3 = new ArrayList<Object>();//List
value3.add("你们好啊1");
value3.add("你们好啊1");
Set<Object> value4 = new HashSet<Object>();//Set
value4.add("你们好啊2");
value4.add("你们好啊3");
Map<Object, Object> value5 = new HashMap<Object, Object>();//Map
List<Object> value6 = new ArrayList<Object>();//List
value6.add("你们好啊1");
value6.add("你们好啊1");
value5.put("xxxxxxxxxx", value3);
value5.put("yyyyyyyyyy", value6);
System.out.println("######################################################################");
//测试方式一（未设置失效情况）
redisDaoSupport.set("aaa",value1 );//debug处
redisDaoSupport.set("bbb",value2 );
redisDaoSupport.set("ccc",value3 );
redisDaoSupport.set("ddd",value4 );
redisDaoSupport.set("eee",value5 );
System.err.println(redisDaoSupport.get("aaa")); //debug处 输出：大家好
System.err.println(redisDaoSupport.get("bbb")); //debug处 输出：{name=admin, age=22}
System.err.println(redisDaoSupport.get("ccc")); //debug处 输出：[你们好啊1, 你们好啊1]
System.err.println(redisDaoSupport.get("ddd")); //debug处 输出：[你们好啊2, 你们好啊3]
System.err.println(redisDaoSupport.get("eee")); //debug处 输出： {xxxxxxxxxx=[你们好啊1, 你们好啊1], yyyyyyyyyy=[你们好啊1, 你们好啊1]}
System.err.println(redisDaoSupport.hasKey("aaa")); //debug处
System.err.println(redisDaoSupport.hasKey("bbb"));
System.err.println(redisDaoSupport.hasKey("ccc"));
System.err.println(redisDaoSupport.hasKey("ddd"));
redisDaoSupport.delete("aaa"); //debug处
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.out.println("######################################################################");
//测试方式一（设置失效情况）
redisDaoSupport.setAndTimeOut("aaa", value1, 30);//debug处
redisDaoSupport.setAndTimeOut("bbb", value2, 90);
redisDaoSupport.setAndTimeOut("ccc", value3, 40);
redisDaoSupport.setAndTimeOut("ddd", value4, 40);
redisDaoSupport.setAndTimeOut("eee",value5,90 );
System.err.println(redisDaoSupport.hasKey("aaa"));//debug处
System.err.println(redisDaoSupport.hasKey("bbb"));
System.err.println(redisDaoSupport.hasKey("ccc"));
System.err.println(redisDaoSupport.hasKey("ddd"));
System.err.println(redisDaoSupport.hasKey("eee"));
System.err.println(redisDaoSupport.get("aaa")); //根据失效时间，来进行debug下一步
System.err.println(redisDaoSupport.get("bbb")); //根据失效时间，debug处
System.err.println(redisDaoSupport.get("ccc")); //根据失效时间，debug处
System.err.println(redisDaoSupport.get("ddd")); //根据失效时间，debug处
System.err.println(redisDaoSupport.get("eee")); //根据失效时间，debug处
redisDaoSupport.delete("aaa");//debug处
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.out.println("######################################################################");
//测试方式二（未设置失效情况）
redisDaoSupport.setString("aaa",value1 );// debug处
redisDaoSupport.setMap("bbb",value2 );
redisDaoSupport.setList("ccc",value3 );
redisDaoSupport.setSet("ddd",value4 );
redisDaoSupport.setMap("eee",value5 );
System.err.println(redisDaoSupport.getString("aaa"));//debug处 输出：大家好
System.err.println(redisDaoSupport.getMap("bbb"));//debug处 输出：{name=admin, age=22}
System.err.println(redisDaoSupport.getList("ccc"));//debug处 输出：[你们好啊1, 你们好啊1]
System.err.println(redisDaoSupport.getSet("ddd"));//debug处 输出：[[你们好啊2, 你们好啊3]] 通过此处初步就可看出两种方式的不同，后面也会通过redis可视化工具看出
System.err.println(redisDaoSupport.getMap("eee"));//debug处 输出：{xxxxxxxxxx=[你们好啊1, 你们好啊1], yyyyyyyyyy=[你们好啊1, 你们好啊1]}
System.err.println(redisDaoSupport.getMapValues("bbb"));//debug处 输出：[admin, 22]
System.err.println(redisDaoSupport.getValueByMapKey("bbb", "age"));//debug处 输出：22
redisDaoSupport.delete("aaa");//debug处
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.out.println("######################################################################");
//测试方式二（设置失效情况）
redisDaoSupport.setStringAndTimeOut("aaa", value1, 30);//代表30秒后失效 debug处
redisDaoSupport.setMapAndTimeOut("bbb", value2, 60);
redisDaoSupport.setListAndTimeOut("ccc", value3, 90);
redisDaoSupport.setSetAndTimeOut("ddd", value4, 120);
redisDaoSupport.setMapAndTimeOut("eee", value5, 150);
System.err.println(redisDaoSupport.getString("aaa"));//根据失效时间，debug处
System.err.println(redisDaoSupport.getMap("bbb"));//根据失效时间，debug处
System.err.println(redisDaoSupport.getList("ccc"));//根据失效时间，debug处
System.err.println(redisDaoSupport.getSet("ddd"));//根据失效时间，debug处
System.err.println(redisDaoSupport.getMap("eee"));//根据失效时间，debug处
System.err.println(redisDaoSupport.getValueByMapKey("eee", "xxxxxxxxxx"));//根据失效时间，debug处
redisDaoSupport.delete("aaa");//debug处
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.out.println("######################################################################");
//测试方式一存储，方式二获取（会发现除String类型外，其余类型获取会报redis里的结构转换错误（nested exception is redis.clients.jedis.exceptions.JedisDataException:），可以大致判断redisTemplate最底层是使用用了Jedis）
redisDaoSupport.set("aaa",value1 );//debug处
redisDaoSupport.set("bbb",value2 );
redisDaoSupport.set("ccc",value3 );
redisDaoSupport.set("ddd",value4 );
redisDaoSupport.set("eee",value5 );
System.err.println(redisDaoSupport.getString("aaa"));//debug处
System.err.println(redisDaoSupport.getMap("bbb"));//debug处 报错：WRONGTYPE Operation against a key holding the wrong kind of value; nested exception is redis.clients.jedis.exceptions.JedisDataException: WRONGTYPE Operation against a key holding the wrong kind of value
System.err.println(redisDaoSupport.getList("ccc"));//debug处
System.err.println(redisDaoSupport.getSet("ddd"));//debug处
System.err.println(redisDaoSupport.getMap("eee"));//debug处
//测试方式二存储，方式一获取（会发现除String类型外，其余类型获取会报redis里的结构转换错误，如上）
redisDaoSupport.setString("aaa",value1 );// debug处
redisDaoSupport.setMap("bbb",value2 );
redisDaoSupport.setList("ccc",value3 );
redisDaoSupport.setSet("ddd",value4 );
redisDaoSupport.setMap("eee",value5 );
System.err.println(redisDaoSupport.get("aaa"));// debug处
System.err.println(redisDaoSupport.get("bbb"));// debug处
System.err.println(redisDaoSupport.get("ccc"));// debug处
System.err.println(redisDaoSupport.get("ddd"));// debug处
System.err.println(redisDaoSupport.get("eee"));// debug处
System.out.println("######################################################################");
redisDaoSupport.delete("aaa");
redisDaoSupport.delete("bbb");
redisDaoSupport.delete("ccc");
redisDaoSupport.delete("ddd");
redisDaoSupport.delete("eee");
System.err.println(redisDaoSupport.hasKey("aaa"));
System.err.println(redisDaoSupport.hasKey("bbb"));
System.err.println(redisDaoSupport.hasKey("ccc"));
System.err.println(redisDaoSupport.hasKey("ddd"));
System.err.println(redisDaoSupport.hasKey("eee"));
System.out.println("######################################################################");
//测试方式一存储Map,获取时对Object进行类型强转Map<Object, List<Object>>
redisDaoSupport.set("eee",value5);//存储Map
Map<Object, List<Object>> map2 =(Map<Object, List<Object>>)redisDaoSupport.get("eee");
List<Object> list = map2.get("xxxxxxxxxx");
for (Object object : list) {
System.err.println(object); // debug处
}
System.out.println("######################################################################");
map.put("result", "测试完成");
return AppUtil.returnObject(new PageData(), map);
}
}最后：通过可视化工具查看各存储结构，了解本质不同之处
方式一：以Object形式存取,其实就是强行把各类型.toString之后存取
方式二：以各类型结构形式存取各对象,使用redisTemplate包方法
好了，我也不知道我说了啥，写了一大堆，也不知道理解是不是有误，感谢大家查看，评论就关了，若有疑问或错误恳请邮件通知，感谢探讨，谢谢。chengang8750@qq.com
版权声明：本文为weixin_42164766原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。