10_Redis教程之Java代码实现
一.Redis的基本使用
3.使用连接池连接单机版
Java代码操作Redis,可以需要使用Jedis类库,也就是Redis支持Java的第三方类库.
注意:Jedis2.7以上的版本才支持集群操作!
1.pom文件：
redis.clients
jedis
2.9.0
@Test
public void testJedis() throws Exception {
// 第一步:创建一个Jedis对象,需要指定服务端的ip及端口.
Jedis jedis = new Jedis("10.0.135.131", 6379);
// 第二步：使用Jedis对象操作数据库,每个redis命令对应一个方法.
String result = jedis.get("hello");
// 第三步：打印结果。
System.out.println(result);
// 第四步:关闭Jedis
jedis.close();
}
public static void main(String[] args) {
Jedis jedis = new Jedis("10.211.55.12", 6379); //默认端口6379可以省略
jedis.auth("lx"); //无密码此步可省略
//String操作
jedis.set("abc", "test1"); // 存数据
System.err.println("String:" + jedis.get("abc")); // 取数据
//hash操作
jedis.hset("hash1", "name", "zhangan");
jedis.hset("hash1", "pass", "123456");
Map hash1 = jedis.hgetAll("hash1");
for(String s:hash1.keySet()){
System.err.println("hash:"+s+"--->"+hash1.get(s));
}
//list操作
jedis.lpush("list1", "Java");
jedis.lpush("list1", "Html5");
jedis.lpush("list1", "Python");
// 获取存储的数据并输出
List list = jedis.lrange("list1", 0, -1);
for (int i = 0; i < list.size(); i++) {
System.err.println("列表项为: " + list.get(i));
}
//set操作
jedis.sadd("set1", "MySQL");
jedis.sadd("set1", "Redis");
Set set1 = jedis.smembers("set1");
for (String s : set1) {
System.err.println("set:" + s);
}
//zset操作
jedis.zadd("zset1",1.2,"java");
jedis.zadd("zset1",2.2,"html");
Set set2=jedis.zrange("zset1",0,3);
for(String s :set2){
System.err.println("zset:" + s);
}
//系统命令
Set keys = jedis.keys("*");
Iterator it = keys.iterator();
while (it.hasNext()) {
String key = it.next();
System.err.println(key);
}
}
@Test
public void testJedisPool() throws Exception {
// 第一步:创建一个JedisPool对象,需要指定服务端的ip及端口.
JedisPool jedisPool = new JedisPool("10.0.135.131", 6379);
// 第二步：从JedisPool中获得Jedis对象。
Jedis jedis = jedisPool.getResource();
// 第三步：使用Jedis操作redis服务器。
jedis.set("jedis", "test");
String result = jedis.get("jedis");
System.out.println(result);
// 第四步：操作完毕后关闭jedis对象，连接池回收资源。
jedis.close();
// 第五步：关闭JedisPool对象。
jedisPool.close();
}
@Test
public void testJedisCluster() throws Exception {
// 第一步：使用JedisCluster对象。需要一个Set参数。Redis节点的列表。
Set nodes = new HashSet();
nodes.add(new HostAndPort("10.0.135.131", 7001));
nodes.add(new HostAndPort("10.0.135.131", 7002));
nodes.add(new HostAndPort("10.0.135.131", 7003));
nodes.add(new HostAndPort("10.0.135.131", 7004));
nodes.add(new HostAndPort("10.0.135.131", 7005));
nodes.add(new HostAndPort("10.0.135.131", 7006));
JedisCluster jedisCluster = new JedisCluster(nodes);
// 第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
jedisCluster.set("hello", "100");
String result = jedisCluster.get("hello");
// 第三步：打印结果
System.out.println(result);
// 第四步：系统关闭前，关闭JedisCluster对象。
jedisCluster.close();
}
将常用的操作redis的方法提取出一个接口类，分别对应单机版和集群版创建两个实现类。
public interface JedisClient {
String set(String key, String value);
String get(String key);
Boolean exists(String key);
Long expire(String key, int seconds);
Long ttl(String key);
Long incr(String key);
Long hset(String key, String field, String value);
String hget(String key, String field);
Long hdel(String key, String... field);
}
public class JedisClientPool implements JedisClient {
@Autowired
private JedisPool jedisPool;
@Override
public String set(String key, String value) {
Jedis jedis = jedisPool.getResource();
String result = jedis.set(key, value);
jedis.close();
return result;
}
@Override
public String get(String key) {
Jedis jedis = jedisPool.getResource();
String result = jedis.get(key);
jedis.close();
return result;
}
@Override
public Boolean exists(String key) {
Jedis jedis = jedisPool.getResource();
Boolean result = jedis.exists(key);
jedis.close();
return result;
}
@Override
public Long expire(String key, int seconds) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.expire(key, seconds);
jedis.close();
return result;
}
@Override
public Long ttl(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.ttl(key);
jedis.close();
return result;
}
@Override
public Long incr(String key) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.incr(key);
jedis.close();
return result;
}
@Override
public Long hset(String key, String field, String value) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hset(key, field, value);
jedis.close();
return result;
}
@Override
public String hget(String key, String field) {
Jedis jedis = jedisPool.getResource();
String result = jedis.hget(key, field);
jedis.close();
return result;
}
@Override
public Long hdel(String key, String... field) {
Jedis jedis = jedisPool.getResource();
Long result = jedis.hdel(key, field);
jedis.close();
return result;
}
}
public class JedisClientCluster implements JedisClient {
@Autowired
private JedisCluster jedisCluster;
@Override
public String set(String key, String value) {
return jedisCluster.set(key, value);
}
@Override
public String get(String key) {
return jedisCluster.get(key);
}
@Override
public Boolean exists(String key) {
return jedisCluster.exists(key);
}
@Override
public Long expire(String key, int seconds) {
return jedisCluster.expire(key, seconds);
}
@Override
public Long ttl(String key) {
return jedisCluster.ttl(key);
}
@Override
public Long incr(String key) {
return jedisCluster.incr(key);
}
@Override
public Long hset(String key, String field, String value) {
return jedisCluster.hset(key, field, value);
}
@Override
public String hget(String key, String field) {
return jedisCluster.hget(key, field);
}
@Override
public Long hdel(String key, String... field) {
return jedisCluster.hdel(key, field);
}
}
注意：单机版和集群版不能共存，使用单机版时注释集群版的配置。使用集群版时把单机版注释掉。
三.SSM框架中基于Redis实现缓存 1.创建数据库和留言表-- ----------------------------
-- Table structure for `tb_msg`
-- ----------------------------
DROP TABLE IF EXISTS `tb_msg`;
CREATE TABLE `tb_msg` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`msg` varchar(50) NOT NULL,
`name` varchar(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of tb_msg
-- ----------------------------
4.0.0
war
SSM_Redis
xph
SSM_Redis
1.0
org.springframework
spring-webmvc
4.3.11.RELEASE
org.springframework
spring-aspects
4.3.11.RELEASE
org.springframework
spring-orm
4.3.11.RELEASE
org.springframework
spring-context-support
4.3.11.RELEASE
org.mybatis
mybatis
3.4.2
org.mybatis
mybatis-spring
1.3.1
mysql
mysql-connector-java
5.1.38
com.alibaba
druid
1.1.2
javax.servlet
javax.servlet-api
3.1.0
provided
log4j
log4j
1.2.17
com.fasterxml.jackson.core
jackson-databind
2.9.2
org.springframework.data
spring-data-redis
1.7.2.RELEASE
org.springframework
spring-aop
org.springframework
spring-orm
redis.clients
jedis
2.9.0
com.alibaba
fastjson
1.2.40
org.slf4j
slf4j-api
1.7.25
org.apache.maven.plugins
maven-compiler-plugin
3.6.0
1.8
1.8
UTF-8
src/main/java
**/*.xml
**/*.properties
src/main/resources
**/*.xml
**/*.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://10.211.55.12:3306/db_case?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=syc
### Global logging configuration
log4j.rootLogger=DEBUG, stdout
### Uncomment for MyBatis logging
log4j.logger.org.apache.ibatis=DEBUG
### Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
#访问地址
redis.host=10.211.55.12
#访问端口
redis.port=6379
#注意，如果没有password，此处不设置值，但这一项要保留
redis.password=lx
#最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
redis.maxIdle=300
#连接池的最大数据库连接数。设为0表示无限制
redis.maxActive=600
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWait=1000
#在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
redis.testOnBorrow=true
M_SSM_Base
contextConfigLocation
classpath:spring/spring-service.xml
org.springframework.web.context.ContextLoaderListener
springMVC
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:spring/springMVC.xml
springMVC
/
redis_msg.html
package com.qf.domain;
public class Msg {
private Long id;
private String msg;
private String name;
public Long getId() {
return id;
}
public String getMsg() {
return msg;
}
public String getName() {
return name;
}
public void setId(Long id) {
this.id = id;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Msg{" +
"id=" + id +
", msg='" + msg + '\'' +
", name='" + name + '\'' +
'}';
}
}
public interface MsgMapper {
//新增
int add(Msg msg);
//查询所有
List queryAll();
}
insert into tb_msg(msg,name) values(#{msg},#{name})
select * from tb_msg
@Service
@Transactional
public class MsgService {
@Autowired
private MsgMapper mapper;
@Autowired
private RedisUtil redisUtil;
//保存
public boolean save(Msg msg) throws JsonProcessingException {
boolean res=mapper.add(msg)>0?true:false;
if(res){
//让Redis中的数据进行失效
redisUtil.expire("msgs",0);
}
return res;
}
//查询
public List queryAll(){
List msgs;
//获取Redis中的数据
List list=redisUtil.lGet("msgs",0,-1);
//验证Redis中是否存在数据
if(list!=null && list.size()>0){
msgs= JSON.parseArray(list.get(0).toString(),Msg.class);
}else{//不存在数据就去数据库查询，并将数据存储在Redis中
msgs= mapper.queryAll();
redisUtil.lSet("msgs",JSON.toJSONString(msgs));
}
return msgs;
}
}
@Controller
public class MsgController {
@Autowired
private MsgService service;
//新增数据
@RequestMapping("/msg.add")
public void add(Msg msg, HttpServletResponse response) throws IOException {
response.getWriter().print(service.save(msg));
}
//查询数据
@ResponseBody
@RequestMapping("/msg.query")
public List queryAll(){
System.err.println(service.queryAll());
return service.queryAll();
}
}
public class RedisUtil {
private RedisTemplate redisTemplate;
public void setRedisTemplate(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}
//=============================common============================
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key,long time){
try {
//if(time>0){
redisTemplate.expire(key, time, TimeUnit.SECONDS);
//}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key){
return redisTemplate.getExpire(key,TimeUnit.SECONDS);
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String ... key){
if(key!=null&&key.length>0){
if(key.length==1){
redisTemplate.delete(key[0]);
}else{
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
//============================String=============================
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
public Object get(String key){
return key==null?null:redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key,Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key,Object value,long time){
try {
if(time>0){
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
}else{
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta){
if(delta0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item){
redisTemplate.opsForHash().delete(key,item);
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item){
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item,-by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set sGet(String key){
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key,Object value){
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object...values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key,long time,Object...values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if(time>0) expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key){
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object ...values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List lGet(String key, long start, long end){
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key){
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index,Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key,long count,Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
Redis实现留言信息的缓存
留言人：
内容：
保存
重置
//设置数据表格
$('#dg').datagrid({
url:'msg.query',
columns:[[
{field:'id',title:'代码',width:100},
{field:'name',title:'留言人',width:100},
{field:'msg',title:'内容',width:100,align:'right'}
]]
});
//新增留言消息
function addMsg(){
//新增留言
$.post("msg.add","msg="+$("#msg").val()+"&name="+$("#name").val(),function (data) {
if(data){//如果成功，就重新加载数据
$('#dg').datagrid('load');
}
});
}
