java代码操作Redis数据库

Redis 是一个基于内存高性能的key-value数据库。

先学习用命令操作Redis数据，再来写java代码操作，先用命令的方式做下，然后使用该Redis 提供api方式操作一下会更能容易理解。

学习地址：

【1】http://www.yiibai.com/redis/redis_quick_guide.html

【2】http://www.redis.cn/（Redis官方中文站）

【3】  http://www.runoob.com/redis/redis-tutorial.html

所需jar包：

commons-pool-2.4.2.jar（因为我这里使用了连接池）

jedis-2.9.0.jar（操作Redis数据库所需jar包。）

junit-4.12.jar（我这里使用了单元测试，所以添加了这个jar包）

我这里用了Maven

在POM.xml配置里面添加依赖jar包配置：

<dependencies>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.4.2</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

【1】工具类：

package com.cjh.redis.utils;

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

/**
* Created by 陈嘉豪 on 2017/7/26.
*/
public class RedisUtils {

private static String HOST="127.0.0.1";

private static int PORT=6379;

private static int TIMEOUT=10000;

private static String PASSWORD="chenjiahao";

//连接耗尽时是否阻塞，false报异常，true阻塞直到超时（默认）
private static boolean isBlock=true;

private static JedisPool jedisPool =null;

static{
//使用连接池

//【2】创建JedisPool所需的连接池配置
JedisPoolConfig poolConfig = new JedisPoolConfig();
//最大连接数，默认8
poolConfig.setMaxTotal(1024);
//最大空闲数,默认8
poolConfig.setMaxIdle(200);
//最小空闲连接数，默认0
poolConfig.setMinIdle(0);
//对象最小空闲时间，默认1800000毫秒(30分钟)
poolConfig.setMinEvictableIdleTimeMillis(1800000);
//获取连接的最大等待毫秒数。如果设为小于0，则永远等待
poolConfig.setMaxWaitMillis(-1);

//在创建对象时检测对象是否有效，true是，默认值是false
poolConfig.setTestOnCreate(true);
//从对象池获取对象时检测对象是否有效，默认false
poolConfig.setTestOnBorrow(true);
//在向对象池中归还对象时是否检测对象有效，true是，默认值是false
poolConfig.setTestOnReturn(false);
//在检测空闲对象线程检测到对象不需要移除时，是否检测对象的有效性。true是，默认值是false
poolConfig.setTestWhileIdle(false);
//检测空闲对象线程每次检测的空闲对象的数量。默认值是3；如果这个值小于0,则每次检测的空闲对象数量等于当前空闲对象数量除以这个值的绝对值，并对结果向上取整
poolConfig.setNumTestsPerEvictionRun(3);
//是否启用后进先出, 默认true
poolConfig.setLifo(true);
//多长时候执行一次空闲对象检测。单位是毫秒数。如果小于等于0，则不执行检测线程。默认值是-1
poolConfig.setTimeBetweenEvictionRunsMillis(-1);
//当对象池没有空闲对象时，新的获取对象的请求是否阻塞。true阻塞。默认值是true;
poolConfig.setBlockWhenExhausted(true);

///是否启用pool的jmx管理功能, 默认true
poolConfig.setJmxEnabled(true);

//【1】创建JedisPool连接池
jedisPool = new JedisPool(poolConfig, HOST, PORT, TIMEOUT, PASSWORD);

}

/**
* 同步获取Jedis
* @return
*/
public synchronized static Jedis getJedis(){

if(jedisPool!=null){
//获取Jedis对象
Jedis jedis = jedisPool.getResource();
return jedis;
}
return null;
}
/**
* 释放jedis资源
*/
public static void releaseResource(Jedis jedis){
if( jedis !=null ){
jedisPool.returnResource(jedis);
}
}
}

【2】测试类

package com.cjh.redis.test;

import com.cjh.redis.utils.RedisUtils;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class RedisTest {

private Jedis jedis;

public static void main(String[] args){

}

/**
* 连接redis服务
*/
@Test
public void connectionRedis(){
//连接本地的Redis服务
Jedis jedis = new Je
b1a8
dis("127.0.0.1",6379);
//如果有密码，则需要下面权限认证
jedis.auth("chenjiahao");
System.out.println("连接成功！");

//查看服务是否运行
System.out.println("服务正在运行："+jedis.ping());
}
@Before
public void getJedis(){
jedis = RedisUtils.getJedis();
}

/**
* 测试Redis存储String
*/
@Test
public void testString(){

jedis.set("name","爱华");

System.out.println(jedis.get("name"));

jedis.append("name","，嘉豪");

System.out.print(jedis.get("name"));
//存储多个键值
jedis.mset("name","爱华","age","20");

jedis.incr("age");

System.out.println(jedis.get("name")+","+jedis.get("age"));

jedis.del("name","age");

System.out.println(jedis.get("name")+","+jedis.get("age"));
}

/**
* 测试redis存储List
*/
@Test
public void testList(){
jedis.del("lists");
//在头部添加
jedis.lpush("lists","o1","o2");
//第一个是key，第二个参数是起始位置，第三个是结束位置,-1表示全部输出
System.out.println(jedis.lrange("lists",0,-1));

jedis.del("lists");
//在尾部后添加
jedis.rpush("lists","o1","o2");
System.out.println(jedis.lrange("lists",0,-1));
}

/**
* 测试Redis存储Set
*/
@Test
public void testSet_(){

jedis.sadd("users","爱华");
jedis.sadd("users","嘉豪");
//全部输出set集合中的元素
System.out.println(jedis.smembers("users"));
//判断是否是set集合中的元素
System.out.println(jedis.sismember("users","嘉豪"));
//获取set集合中元素的总数目
System.out.println(jedis.scard("users"));
//随机获取set集合中的元素
System.out.println(jedis.srandmember("users"));

jedis.del("users");
}

/**
* 测试Redis存储Map（Hash）
*/
@Test
public void testMap(){
Map<String,String> map = new HashMap<>();
map.put("name","嘉豪");
map.put("name2","爱华");
jedis.hmset("person",map);
Iterator<String> iterator = jedis.hkeys("person").iterator();
while( iterator.hasNext() ){
System.out.println(jedis.hmget("person",iterator.next()));
}
jedis.del("person");
}

/**
* 测试List排序
*/
@Test
public void testListSort(){

this.jedis.del("array");
this.jedis.rpush("array","88");
this.jedis.rpush("array","56");
this.jedis.rpush("array","1");
this.jedis.rpush("array","2");
System.out.println(this.jedis.lrange("array",0,-1));
this.jedis.sort("array");
System.out.println(this.jedis.lrange("array",0,-1));

this.jedis.del("array");

}
}

最后测试的时候，首先开启Redis服务端，再进行测试。Redis的密码也要注意，简单的操作就到这里了。