redis 的简单使用_redis flush list-CSDN博客

百度百科上是这样定义redis的：

redis是一个key-value 存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list( 链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了 memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。 [1]

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

redis的官网地址，非常好记，是redis.io。（特意查了一下，域名后缀io属于国家域名，是british Indian Ocean territory，即英属印度洋领地）

下面来学习redis

步骤：

1、安装Redis

官方网站：http://redis.io/

官方下载：http://redis.io/download 可以根据需要下载不同版本

windows版：https://github.com/mythz/redis-windows

图形化工具：RedisDesktopManager 可去百度搜索下载

2、解压文件，双击redis-server.exe

3、出现如下图说明已经启动

4、本次重点是eclipse 开发

项目依赖的jar 包

项目结构为：

5、redis.properties 内容：

ADDR=127.0.0.1
PORT=6379
AUTH=WshkeMrVWh4Y4KRcbtvanDUh2
MAX_ACTIVE=300
MAX_IDLE=200
MAX_WAIT=10000
TIMEOUT=10000

6、demo代码：

package snippet;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.commons.lang.StringUtils;

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

public final class RedisClient {
// 手动写各项配置
// private static String ADDR = "127.0.0.1"; //Redis服务器IP
// private static int PORT = 6379; //Redis的端口号
// private static String AUTH ="WshkeMrVWh4Y4KRcbtvanDUh2";//"admin";//访问密码
// private static int MAX_ACTIVE = 300;//可用连接实例的最大数目，默认值为8；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
// private static int MAX_IDLE = 200; //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
// private static int MAX_WAIT = 10000;//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
// private static int TIMEOUT = 10000;
// private static boolean TEST_ON_BORROW = true;//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
// private static JedisPool jedisPool = null;
// private static Properties prop=null;
//配置文件读取
private static String ADDR ; //Redis服务器IP
private static int PORT ; //Redis的端口号
private static String AUTH ;//"admin";//访问密码
private static int MAX_ACTIVE; //可用连接实例的最大数目，默认值为8；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_IDLE ; //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_WAIT ;//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
private static int TIMEOUT ;
private static boolean TEST_ON_BORROW=true ;//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
private static JedisPool jedisPool = null;
private static Properties prop=null;

/**
* 初始化Redis连接池
*/

private static Properties loadProperty() {
Properties prop=new Properties();
try {
InputStream is=System.class.getResourceAsStream("/redis.properties");
prop.load(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
return prop;
}

static {
try {
prop = loadProperty();
ADDR = (String) prop.get("ADDR");
PORT = Integer.valueOf(prop.get("PORT")+"");
AUTH = (String) prop.get("AUTH");
MAX_ACTIVE = Integer.valueOf( prop.get("MAX_ACTIVE")+"");
MAX_IDLE = Integer.valueOf( prop.get("MAX_IDLE")+"");
MAX_WAIT = Integer.valueOf( prop.get("MAX_WAIT")+"");
TIMEOUT = Integer.valueOf( prop.get("TIMEOUT")+"");
JedisPoolConfig config = new JedisPoolConfig();

config.setMaxActive(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWait(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 获取Jedis实例
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
return resource;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}


private static Jedis jedis = getJedis();

/**
* 释放jedis资源
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
}

/***
* 清空所有db
*/
public static void flushAll(){
jedis.flushAll();
RedisClient.returnResource(jedis);
}

/***
* 清空当前db
*/
public static void flushDb(){
jedis.flushDB();
RedisClient.returnResource(jedis);
}

/***
* 模糊查询所有的key
* 例如所有包含‘name’的key
* @param key
* 用法说明： *key* 包含key, key* 以key开头， *key 以key结尾
* @return
* 返回的是key集合不是 value
*/
public static Set<String> getAllKeySetByParrten(String key){
Set<String> keySet = new HashSet<String>();
if(StringUtils.isNotBlank(key)){
keySet = jedis.keys(key);
}
RedisClient.returnResource(jedis);
return keySet;
}

/***
* 判断当前key是否已经存在于redis中
* @param key
* @return
*/
public static boolean isExistsKey(String key){
boolean isExists = false;
if(StringUtils.isNotBlank(key)){
isExists = jedis.exists(key);
}
RedisClient.returnResource(jedis);
return isExists;
}

/***
* 存key并且有超时时间
* @param key
* @param seconds
* @param value
*/
public static void setKeyByTimeout(String key,int seconds,String value){
if(StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value)){
jedis.setex(key, seconds, value);
RedisClient.returnResource(jedis);
}
}

/***
* 获取key的剩余超时时间
* @param key
* @return
*/
public static long gettime(String key){
long time = 0;
if(StringUtils.isNotBlank(key)){
time = jedis.ttl(key);
}
RedisClient.returnResource(jedis);
return time;
}

/***
* 取消超时时间的设置
* @param key
*/
public static void cancleTime(String key){
if(StringUtils.isNotBlank(key)){
jedis.persist(key);
}
RedisClient.returnResource(jedis);
}

/***
* int类型递增/递减：incr()/decr()
* @param key
* key
* @param type
* 0递增/1递减
*/
public static void valueIncrOrDecr(String key,int type){
if(StringUtils.isNotBlank(key)){
switch (type) {
case 0:
jedis.incr(key); // 递增
break;
case 1:
jedis.decr(key); ///递减
break;
}
}
RedisClient.returnResource(jedis);
}

/***
* 存单个string类型
* @param key
* @param value
*/
public static void setStringVal(String key,String value){
if(StringUtils.isNotBlank(key)&&StringUtils.isNotBlank(value)){
// Jedis jedis = RedisClient.getJedis();
jedis.set(key, value);
RedisClient.returnResource(jedis);
}
}

/***
* 根据key获取单个value
* @param key
* @return
*/
public static String getStringVal(String key){
String value = null;
if(StringUtils.isNotBlank(key)){
// Jedis jedis = RedisClient.getJedis();
value = jedis.get(key);
RedisClient.returnResource(jedis);
}
return value;
}

/***
* 根据key 给value后面拼加
* @param key
* @param appendVal
*/
public static void appendStringVal(String key,String appendVal){
if(StringUtils.isNotBlank(key)&&StringUtils.isNotBlank(appendVal)){
jedis.append(key, appendVal);
RedisClient.returnResource(jedis);
}
}

/***
* 根据key删除单个
* @param key
*/
public static void delStringVal(String key){
if(StringUtils.isNotBlank(key)){
jedis.del(key);
RedisClient.returnResource(jedis);
}
}

/***
* 存多个String
* @param keys
* @param values
*/
// public static void mSetStringVal(String[] keys,String[] values){
// if((null != keys && keys.length > 0) && (null != values && values.length > 0)){
// for (String str : keys) {
//
// }
// }
//
// }

/***
* 存Map
* @param key
* @param map
*/
public static void setMapValue(String key,Map<String, String> map){
if(StringUtils.isNotBlank(key) && null != map){
jedis.hmset(key, map);
RedisClient.returnResource(jedis);
}
}

/***
* 根据key获取map中的值
* @param key
* redis里面的key
* @param mapKeys
* map里面的key 可以传多个
* @return
*/
public static List<String> getMapValue(String key,String ... mapKeys){
List<String> strList = new ArrayList<String>();
if(StringUtils.isNotBlank(key) && (null != mapKeys && mapKeys.length > 0)){
strList = jedis.hmget(key, mapKeys);
RedisClient.returnResource(jedis);
}
return strList;
}

/***
* 删除map中的某个键值
* @param key
* redis里面的key
* @param mapKey
* map里面的key
*/
public static void delMapKey(String key,String... mapKey){
if(StringUtils.isNotBlank(key) && (null != mapKey && mapKey.length > 0)){
jedis.hdel(key, mapKey);
RedisClient.returnResource(jedis);
}
}

/***
* 获取map里面的所有的key
* @param key
*/
public static void getMapKey(String key){
Iterator<String> iter=jedis.hkeys(key).iterator();
while (iter.hasNext()){
String mapKey = iter.next();
System.out.println(mapKey+":"+jedis.hmget(key,mapKey));
}
RedisClient.returnResource(jedis);
}

/***
* 存List
* lpush方式存入，先进后出
* @param key
* @param value
*/
public static void setListValueByLpush(String key,String... values){
if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
jedis.lpush(key, values);
}
RedisClient.returnResource(jedis);
}

/***
* 存List
* rpush方式存入，先进先出
* @param key
* @param value
*/
public static void setListValueByRpush(String key,String... values){
if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
jedis.rpush(key, values);
}
RedisClient.returnResource(jedis);
}

/***
* 对List排序
* @param key
*/
public static void sortList(String key){
if(StringUtils.isNotBlank(key)){
jedis.sort(key);
}
}

/***
* 获取redis中的list
* lrange是按范围取出
* @param key
* key
* @param beginIndex
* 起点位置
* @param endIndex
* 是结束位置， -1表示取得所有，jedis.llen获取长度
*
* @return
*/
public static List<String> getListValue(String key,long beginIndex,long endIndex){
List<String> listStr = new ArrayList<String>();
if(StringUtils.isNotBlank(key)){
listStr = jedis.lrange(key, beginIndex, endIndex);
}
RedisClient.returnResource(jedis);
return listStr;
}

/***
* 清空指定key存放的list
* @param key
*/
public static void flushListValue(String... keys){
if(null != keys && keys.length > 0){
jedis.del(keys);
RedisClient.returnResource(jedis);
}
}

/***
* 将Set存入redis
* @param key
* @param value
*/
public static void setSetValue(String key,String... values){
if(StringUtils.isNotBlank(key) && (null != values && values.length > 0)){
jedis.sadd(key, values);
}
RedisClient.returnResource(jedis);
}

/***
* 获取redis存放的set
* 无序
* @param key
* @return
*/
public static Set<String> getSetListByKey(String key){
Set<String> valSet = new HashSet<String>();
if(StringUtils.isNotBlank(key)){
valSet = jedis.smembers(key);
RedisClient.returnResource(jedis);
}
return valSet;
}

/***
* 移除set中的key
* @param key
* @param setKeys
*/
public static void removeSetValue(String key,String... setKeys){
if(StringUtils.isNotBlank(key) && (null != setKeys && setKeys.length > 0)){
jedis.srem(key,setKeys);
RedisClient.returnResource(jedis);
}
}

/***
* 判断setKey是否是key的元素
* @param key
* @param setKey
* @return
*/
public static boolean isKeyInSet(String key,String setKey){
boolean isExists = false;
if(StringUtils.isNotEmpty(key) && StringUtils.isNotBlank(setKey)){
isExists = jedis.sismember(key,setKey);
}
RedisClient.returnResource(jedis);
return isExists;
}

/***
* 获取set中元素的个数
* @param key
* @return
*/
public static long getSetValueCount(String key){
long count = 0;
if(StringUtils.isNotBlank(key)){
count = jedis.scard(key);
}
RedisClient.returnResource(jedis);
return count;
}

/***
* 随机获取一个set元素
* @param key
* @return
*/
public static String getSetValueByRandem(String key){
String value = null;
if(StringUtils.isNotBlank(key)){
value = jedis.srandmember(key);
}
RedisClient.returnResource(jedis);
return value;
}



public static void main(String[] args) throws InterruptedException {

//rest1();
RedisClient.flushAll();
Jedis jedis = RedisClient.getJedis();
System.out.println("Connection to server sucessfully");
jedis.set("user".getBytes(), SerializationUtil.serialize(new People("hu", 23, null)));

List listAll=new ArrayList();

List<People> li=new ArrayList();
for(int i=0;i<10;i++){
li.add(new People("hu"+i, 23, new City("上海"+i,"浦东新区"+i)));
}

List<People> li2=new ArrayList();
for(int i=0;i<10;i++){
li2.add(new People("hu"+i, 23, new City("上海"+i,"浦东新区"+i)));
}

listAll.add(li);
listAll.add(li2);

jedis.set("list".getBytes(), SerializationUtil.serialize(listAll));











jedis.lpush("userList".getBytes(), SerializationUtil.serialize(new People("hu", 23, new City("上海","浦东新区"))));
jedis.lpush("userList".getBytes(), SerializationUtil.serialize(new People("liu", 23, new City("西安","高新区"))));
jedis.lpush("userList".getBytes(), SerializationUtil.serialize(new People("l", 23, new City("郑州","软件园"))));
//设置key的有效时间
jedis.expire("userList".getBytes(),30);

Thread.sleep(2000);
//取消key的有效时间
jedis.persist("userList".getBytes());
//获取key的有效时间， -1 为未设置有效期或者已经取消。
long lp= jedis.ttl("userList".getBytes());
System.out.println(lp);




//存储数据到列表中
jedis.lpush("tutorial-list", "5");
jedis.lpush("tutorial-list", "2");
jedis.lpush("tutorial-list", "3");
// 获取存储的数据并输出
List<String> list = jedis.lrange("tutorial-list", 0 ,5);

List<byte[]> bs = jedis.lrange("userList".getBytes(), 0 ,5);

JSONArray jsonArray=new JSONArray();

for(byte[] b:bs){
People desP = (People) SerializationUtil.deserialize(b);
jsonArray.add(new JSONObject().fromObject(desP));

}
System.out.println(jsonArray.toString());

// System.out.println("date"+new Date().toLocaleString());
// for (int i = 0; i < 10000; i++) {
// jedis.set("name"+i, "hu");
//}

//sortList
SortingParams sortingParameters=new SortingParams();
sortingParameters.asc();
sortingParameters.desc();
//sortingParameters.by("name");
list=jedis.sort("tutorial-list", sortingParameters);

System.out.println("date"+new Date().toLocaleString());
for(int i=0; i<list.size(); i++) {
System.out.println("Stored string in redis:: "+list.get(i));
}
}

private static void rest1() {
/* Jedis jedis = RedisClient.getJedis();
jedis.set("name", "wxw");
System.out.println(jedis.get("name"));
RedisClient.returnResource(jedis);*/
System.out.println("=======================");
System.out.println(jedis.sinterstore("setA", "setB"));

System.out.println(jedis.sdiffstore("setA", "setB"));
System.out.println("=======================");
// RedisClient.flushAll();
RedisClient.setStringVal("name","wxw");
System.out.println(RedisClient.getStringVal("name"));
RedisClient.appendStringVal("name", " is me!");
System.out.println(RedisClient.getStringVal("name"));

Map<String,String> mapStr = new HashMap<String, String>();
mapStr.put("1", "11");
mapStr.put("2", "22");
mapStr.put("3", "33");
mapStr.put("4", "44");
Map<String,String> mapStr1 = new HashMap<String, String>();
mapStr1.put("name", "胡赵娜");
JSONObject jsonObject=JSONObject.fromObject(mapStr1);
mapStr.put("5", jsonObject.toString());
RedisClient.setMapValue("wxwMap", mapStr);

Map<String,String> mapStr2 = new HashMap<String, String>();
mapStr2.put("1", "11");
mapStr2.put("2", "22");
mapStr2.put("3", "33");
mapStr2.put("4", "44");
Map<String,String> mapStr3 = new HashMap<String, String>();
mapStr2.put("name", "胡赵娜");
JSONObject jsonObject1=JSONObject.fromObject(mapStr3);
mapStr2.put("5", jsonObject1.toString());
RedisClient.setMapValue("wxwMap1", mapStr2);

RedisClient.getMapValue("wxwMap", "1","3");

RedisClient.setStringVal("age", "22");
RedisClient.jedis.incr("age"); // 值递增/递减：incr()/decr()
System.out.println(RedisClient.getStringVal("age"));
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
System.out.println(RedisClient.getMapValue("wxwMap", "1","3"));
System.out.println(RedisClient.getMapValue("wxwMap", "4"));
System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");

jedis.lpush("wxw", "my");
jedis.lpush("wxw", "name");
jedis.lpush("wxw", "is");
jedis.lpush("wxw", "chauvet");

jedis.lpush("liu", "my");
jedis.lpush("liu", "hu","name","age");

System.out.println(jedis.lrange("wxw",0,-1));

jedis.del("wxw");
jedis.rpush("wxw", "my");
jedis.rpush("wxw", "name");
jedis.rpush("wxw", "is");
jedis.rpush("wxw", "chauvet");
System.out.println(jedis.lrange("wxw",0,-1));

Jedis jedis = RedisClient.getJedis();
jedis.set("name", "wxw");
System.out.println(jedis.keys("*am*"));
RedisClient.returnResource(jedis);

//5. 事务支持：
//@ 获取事务：
Transaction tx = jedis.multi();
// @ 批量操作：tx采用和jedis一致的API接口
for(int i = 0;i < 10;i ++) {
tx.set("key" + i, "value" + i);
System.out.println("--------key" + i);
try {
// Thread.sleep(1000);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// @ 执行事务：针对每一个操作，返回其执行的结果，成功即为Ok
List<Object> results = tx.exec();
for (int i = 0; i < results.size(); i++) {
Object object =results.get(i);
//JSONObject jsonObject=JSONObject.fromObject(object);
System.out.println(object.toString());
}
}
}

City 类

package snippet;

import java.io.Serializable;

public class City implements Serializable{
private String name;
private String adress;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAdress() {
return adress;
}
public void setAdress(String adress) {
this.adress = adress;
}
public City(String name, String adress) {
super();
this.name = name;
this.adress = adress;
}
}

People 类

package snippet;

import java.io.Serializable;

public class People implements Serializable {
private String name;
private int age;
private City city;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public City getCity() {
return city;
}
public void setCity(City city) {
this.city = city;
}
public People(String name, int age, City city) {
super();
this.name = name;
this.age = age;
this.city = city;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.name+" "+this.age+" "+this.city.getName()+" "+this.city.getAdress();
}

}

SerializationUtil 类

package snippet;
/**
* 序列化就是将一个对象转换为二进制的数据流。这样就可以进行传输，或者保存到文件中。如果一个类的对象要想实现序列化，就必须实现serializable接口。在此接口中没有任何的方法，此接口只是作为一个标识，表示本类的对象具备了序列化的能力而已。
* 反序列化:将二进制数据流转换成相应的对象。
* 如果想要完成对象的序列化，则还要依靠ObjectOutputStream和ObjectInputStream,前者属于序列化操作，而后者属于反序列化操作。
*
*/

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializationUtil {
/**
* 序列化
*
* @param object
* @return
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
}
return null;
}

/**
* 反序列化
*
* @param bytes
* @return
*/
public static Object deserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {

}
return null;
}

}

8、觉得对你有用的话，别忘了打赏一下啊。