Redis入门

最新推荐文章于 2023-07-06 16:24:07 发布

developwt

最新推荐文章于 2023-07-06 16:24:07 发布

阅读量277

点赞数 1

分类专栏：开发技能

本文链接：https://blog.csdn.net/apinkgogo/article/details/77126697

版权

开发技能专栏收录该内容

6 篇文章 0 订阅

订阅专栏

NoSQL

Redis

环境配置
1.需要导入jedis.jar包
2.启动redis服务
3.代码测试连接redis
JedisPool jPool = new JedisPool("localhost",6379);
Jedis jedis = jPool.getResource();
jPool.destroy();

package src.bonc.com.base.util;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Map;
import java.util.Set;

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

/**
 * @Description:redis工具类
 * @author Administrator
 * @date 2017年08月15日
 */
public class RedisUtil {
	private static String ADDR_ARRAY = "172.16.13.179"; // ip  
    private static int PORT = 6379;         // 端口  
    private static String AUTH = "";        // 密码(原始默认是没有密码)  
    private static int   MAX_ACTIVE = -1;         // 最大连接数，默认值为8；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)  
    private static int   MAX_IDLE = 8;            // 设置最大空闲数，默认值也是8  
    private static int   MAX_WAIT = 60000;		  //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException  
    private static int   TIMEOUT = 60000;         // 超时时间  
    private static boolean TEST_ON_BORROW = true; // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的 
    private static JedisPool jedisPool = null;
    private static Jedis jedis;
    
    private RedisUtil() {
    	
    }
    
    /**
     * 单例模式
     */
    private static RedisUtil instance = new RedisUtil();
    
    /**
	 * 获取实例
	 * @return
	 */
	public static synchronized RedisUtil getInstance() {
		if (instance == null) {
			instance = new RedisUtil();
		}
		return instance;
	}
    
    public void initialPool() {
    	try {
			JedisPoolConfig config = new JedisPoolConfig();
			config.setMaxTotal(MAX_ACTIVE);
			config.setMaxIdle(MAX_IDLE);
			config.setMaxWaitMillis(MAX_WAIT);
			config.setTestOnBorrow(TEST_ON_BORROW);
			//如果密码有配置
			if (!"".equals(AUTH) && AUTH!=null) {
				setJedisPool(new JedisPool(config, ADDR_ARRAY.split(",")[0], PORT, TIMEOUT, AUTH));
			} else {
				setJedisPool(new JedisPool(config, ADDR_ARRAY.split(",")[0], PORT, TIMEOUT));
			}
		} catch (Exception e) {
			try{
	            //如果第一个IP异常，则访问第二个IP
	            JedisPoolConfig config = new JedisPoolConfig();
	            config.setMaxTotal(MAX_ACTIVE);
	            config.setMaxIdle(MAX_IDLE);
	            config.setMaxWaitMillis(MAX_WAIT);
	            config.setTestOnBorrow(TEST_ON_BORROW);
	           //如果密码有配置
	            if (!"".equals(AUTH)&&AUTH!=null) {
	            	setJedisPool(new JedisPool(config, ADDR_ARRAY.split(",")[1], PORT, TIMEOUT, AUTH));  
	            } else {
	                setJedisPool(new JedisPool(config, ADDR_ARRAY.split(",")[1], PORT, TIMEOUT));
	            }            
	        } catch (Exception e2) {
	            e2.printStackTrace();
            }
		}
    }
    
    /**
     * 在多线程环境同步初始化
     */
    private synchronized void poolInit() {
    	if (getJedisPool() == null) {  
            initialPool();
        }
    }
    
    /**
     * 同步获取Jedis实例
     * @return Jedis
     */
    public synchronized Jedis getJedisFromPool() {
        if (getJedisPool() == null) {  
        	poolInit();
        }
        Jedis jedis = null;
        try {  
            if (getJedisPool() != null) {  
            	jedis = getJedisPool().getResource(); 
            }
        } catch (Exception e) {  
        	e.printStackTrace();
        } finally {
        	returnResource(jedis);
        }
        return jedis;
      	//如果密码不为空

    }
    
    public static Jedis getJedis() {
        return jedis;
    }  
    
    /**
     * 释放jedis资源
     * @param jedis
     */
    public void returnResource(final Jedis jedis) {
        if (jedis != null && getJedisPool() !=null) {
        	getJedisPool().returnResource(jedis);
        }
    }
    
    /**
	 * 设置 判断是否是Set中的成员
	 * @param key
	 * @param value
	 */
	public static boolean isSetMember(String key ,String value){
    	boolean isMember = false;
      	Jedis jedis = new Jedis(ADDR_ARRAY,PORT);
		isMember=jedis.sismember(key, value);
		jedis.close();
		return isMember;
	}
	
	/**
	 * 设置 判断是否存在该键值
	 * @param key
	 * @return true:含有该键值； false:不含该键值
	 */
	public static boolean isJedisKey(String key){
    	boolean isMember=false;
		try {
	      	Jedis jedis = new Jedis(ADDR_ARRAY,PORT);
			isMember=jedis.exists(key);
			jedis.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return isMember;
	}
	
	 /**  
     * @Description:删除key  
     * @param key  
     * @return boolean 返回类型  
     */  
    public boolean delKey(String key)  
    {  
        Jedis jedis = null;  
        try  
        {  
            jedis = getJedis();  
            Long code = jedis.del(key);  
            if(code > 1)  
            {  
                return true;  
            }  
        }  
        catch (Exception e) {  
            return false;  
        }
        return false;  
    }
	
	public static String getADDR_ARRAY() {
		return ADDR_ARRAY;
	}

	public static void setADDR_ARRAY(String aDDR_ARRAY) {
		ADDR_ARRAY = aDDR_ARRAY;
	}

	public static int getPORT() {
		return PORT;
	}

	public static void setPORT(int pORT) {
		PORT = pORT;
	}

	public static String getAUTH() {
		return AUTH;
	}

	public static void setAUTH(String aUTH) {
		AUTH = aUTH;
	}

	public static int getMAX_ACTIVE() {
		return MAX_ACTIVE;
	}

	public static void setMAX_ACTIVE(int mAX_ACTIVE) {
		MAX_ACTIVE = mAX_ACTIVE;
	}

	public static int getMAX_IDLE() {
		return MAX_IDLE;
	}

	public static void setMAX_IDLE(int mAX_IDLE) {
		MAX_IDLE = mAX_IDLE;
	}

	public static int getMAX_WAIT() {
		return MAX_WAIT;
	}

	public static void setMAX_WAIT(int mAX_WAIT) {
		MAX_WAIT = mAX_WAIT;
	}

	public static int getTIMEOUT() {
		return TIMEOUT;
	}

	public static void setTIMEOUT(int tIMEOUT) {
		TIMEOUT = tIMEOUT;
	}

	public static boolean isTEST_ON_BORROW() {
		return TEST_ON_BORROW;
	}

	public static void setTEST_ON_BORROW(boolean tEST_ON_BORROW) {
		TEST_ON_BORROW = tEST_ON_BORROW;
	}

	public static void setJedis(Jedis jedis) {
		RedisUtil.jedis = jedis;
	}

	/**
	 * 
	 * @param filepath
	 * @return 返回一个redis配置实例
	 */
	public static void getRedisProperty(String filepath){
		
		try{
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));
			BufferedReader in = new BufferedReader(new InputStreamReader(bis,"UTF-8"), 10 * 1024 * 1024);
			while(in.ready()){
				String line = in.readLine().trim();
				//如果不是注释
				if(!line.startsWith("#")){
					String info[] = line.split("=");
					//如果分隔出的字符串为两个
					if(info.length==2)
						switch(info[0].trim()){
							case "ADDR_ARRAY":
								setADDR_ARRAY(info[1].trim());
								break;
							case "PORT":
								setPORT(Integer.parseInt(info[1].trim()));
								break;
							case "AUTH":
								setAUTH(info[1].trim());
								break;
							case "MAX_ACTIVE":
								setMAX_ACTIVE(Integer.parseInt(info[1].trim()));
								break;
							case "MAX_IDLE":
								setMAX_IDLE(Integer.parseInt(info[1].trim()));
								break;
							case "MAX_WAIT":
								setMAX_WAIT(Integer.parseInt(info[1].trim()));
								break;
							case "TIMEOUT":
								setTIMEOUT(Integer.parseInt(info[1].trim()));
								break;
							case "TEST_ON_BORROW":
								if(info[0].trim().equals("true")) 
									setTEST_ON_BORROW(true);
								else if(info[0].trim().equals("false"))
									setTEST_ON_BORROW(false);
								break;
						}
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	public static void setJedis(String auth) {
		RedisUtil.jedis = new Jedis(ADDR_ARRAY,PORT);
		if(null==auth ||auth.equals("")){}
		else {
			RedisUtil.jedis.auth(auth);
		}
	}

	public JedisPool getJedisPool() {
		return jedisPool;
	}

	public void setJedisPool(JedisPool jedisPool) {
		this.jedisPool = jedisPool;
	}
	
}

Redis的数据结构

/**

 * 删除所有数据

*/

jedis.flushDB();

/**
 * key的使用
 */
//当key存在时才删除。成功为1，失败为0
jedis.set("age","25");
long result1 = jedis.del("age");
long result2 = jedis.del("name");
//判断key是否存在
boolean flag = jedis.exists("name");
//设置过期时间
jedis.expire("name", 5);
jedis.expire("age", 5);
//返回key值中存储的类型
System.out.pringln("name值类型：" + jedis.type("name"));
System.out.pringln("age值类型：" + jedis.type("age"));
//修改key的名称
System.out.println("修改为：" + jedis.rename("addr", "address"));
//将key放到给定的db中
jedis.move(key, dbIndex);
//查找给定模式的key
System.out.pringln(jedis.keys("*"));



/**
 * Jedis的字符串 API
 */
jedis.set("age","25");
//给key值中存储的value添加后缀
jedis.append("name","ss");
System.out.println(jedis.getrange("address", 2, 4));
System.out.println(jedis.get("name"));
//当key不存在时，才会设置值
jedis.setnx("age","hhhh");
//key对应的value的字符长度
System.out.println("name的字符长度是："+jedis.strlen("name"));
//设置多组key/value值
jedis.mset("key1","a","key2","b","key3","3");
jedis.del("key1","key2","key3")
//获取多组value值
List<String> strs = jedis.mget("key1","key2","key3");
//给key值中存储的数字+1（如果不是int类型就报错）
jedis.incr("age");
//数字-1
jedis.decr("age");
//减去指定的值
jedis.decrBy("age", 4);



/**
 *Jedis的Hash API
 */
//hset 将哈希表 key 中的域 field 的值设为 value
	jedis.hset("person", "name", "lzl");
	jedis.hset("person", "age", "23");
	jedis.hset("person", "address", "河南");
	jedis.hset("person", "birthday", "1993-01-01");
	jedis.hset("person", "price", "2.3");
//hmset 将多个field-value(域-值)设置到hash表中 
	Map<String,String> hash = new HashMap<>();
	hash.put("name", "xxx");
	hash.put("age", "33");
	hash.put("address", "北京");
	jedis.hmset("person2", hash); 
//hget 返回哈希表 key 中给定域 field 的值。
	System.out.println(jedis.hget("person","name"));
//hdel 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。  
	jedis.hdel("hash","key");
	Assert.assertTrue(jedis.hset("hash","key","value")==1);  
	Assert.assertTrue(jedis.hget("hash","key").equals("value"));  
	Assert.assertTrue(jedis.hdel("hash","key")==1);  
	Assert.assertTrue(jedis.hget("hash","key")==null);
//hexists 查看哈希表 key 中，给定域 field 是否存在。   
    Assert.assertTrue(jedis.hexists("hash","key"));   
//hkeys 获取key中所有的属性
	System.out.println("person对象对应的属性有:"+jedis.hkeys("person"));
//hlen 获取hash表中字段的数量
    System.out.println("person对象的属性个数："+jedis.hlen("person"));
//hgetAll 获取hash表中指定key的所有字段和值（Map<String,String>）
	jedis.hgetAll("person");
	System.out.println("person对象的属性和值分别是："+jedis.hgetAll("person"));
//hincrBy 为哈希表 key 中的域 field 的值加上增量 increment。如果域 field 不存在，域的值先被初始化为 0 。
	jedis.hincrBy("person", "age", 5);
	System.out.println("整型加上增量的结果："+jedis.hincrBy("person", "age", 5));  
//hincrByFloat 同上，支持浮点数  
	jedis.hincrByFloat("hash","key",2.5);
	Assert.assertTrue(jedis.hincrByFloat("hash","key",2.5)==12.5);  
//hvals 获取hash表中的所有值
	System.out.println("hash表中的所有值："+jedis.hvals("person2"));
//hsetnx 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在。  
	Assert.assertTrue(jedis.hsetnx("hash","key","value")==1);  
	Assert.assertTrue(jedis.hsetnx("hash","key","value")==0);  
	Assert.assertTrue(jedis.del("hash")==1); 

	
	
/**
 * Jedis的Set API
 */
//Set的使用
	jedis.flushDB();
//向集合添加一个或多个成员
	jedis.sadd("skeys_1", "sval1","sval2","sval3","sval4","sval5");
	jedis.sadd("skeys_2", "sval1","sval6","sval7","sval4","sval5");
//获取集合总数
	System.out.println("获取集合的成员数:" + jedis.scard("skeys_1"));
//获取某个key的Set<String>集合
	jedis.smembers("skeys_1");
//返回两个或多个集合的差集
	System.out.println("skeys_1与skeys_2集合的差集：" + jedis.sdiff("skeys_l","skeys_2"));
//返回集合差集并存储在diff_keys中
	jedis.sdiffstore("diff_keys", "skeys_l","skeys_2");
//返回给定集合的交集
	System.out.println("两个集合的交集：" + jedis.sinter("skeys_l","skeys_2"));
//判断元素是否在集合中
	System.out.println("是否在集合中：" + jedis.sismember("skeys", "val2"));
//将元素从A集合移动到B集合中
	System.out.println("将元素从A集合移动到B集合中：" + jedis.smove("skeys_2", "skeys_l", "sval7"));
//返回给定集合的并集
	System.out.println("集合的并集：" + jedis.sunionstore("deskeys", "skeys_l","skeys_2"));

	
	
/**
 * Jedis的List API
 */
//将一个或多个值插入到列表头部
	jedis.lpush("lkeys", "val1","val2","val1","val1","val2","val3","val4","val5");
//获取list指定区域的值
	System.out.println(jedis.lrange("lkeys", 0, 20));
//当key已经存在的时候,设置新值。
	jedis.lset("lkeys", 1, "val000");
	System.out.println(jedis.lrange("lkeys", 1, 4));
//获取列表长度
	System.out.println("获取列表长度："+jedis.llen("lkeys"));
//移除列表元素,删除count个值为value的数据。count=0，删除所有值为value的数据
	System.out.println("移除列表元素："+jedis.lrem("lkeys", 0, "val1"));
//对列表进行修剪
	System.out.println("列表修剪结果："+jedis.ltrim("lkeys", 0, 5));
	
	
	
/**
 * Jedis的SortSet API
 */
	Map<Double,String> membersMap = new HashMap<>();
	membersMap.put(2D, "lzl");
	membersMap.put(3D, "hhh");
	membersMap.put(2D, "lzl");
	membersMap.put(5D, "lzl");
	membersMap.put(3D, "hhh-3");
	membersMap.put(6D, "lzl-6");
//添加或更新有序集合,有序集合的值不可以重复，但是分数是可以重复的
	jedis.zadd("zkeys", membersMap);
	Map<Double,String> membersMap_1 = new HashMap<>();
	membersMap_1.put(1D, "lzl");
	membersMap_1.put(2D, "hhh");
	membersMap_1.put(3D, "lzl");
	membersMap_1.put(4D, "lzl");
	membersMap_1.put(5D, "hhh-3");
	membersMap_1.put(6D, "lzl-6");
//添加或更新有序集合,有序集合的值不可以重复，但是分数是可以重复的
	jedis.zadd("zkeys_1", membersMap_1);
//获取有序集合的成员数
	System.out.println("有序集合的成员数："+jedis.zcard("zkeys"));
//指定成员的分数增加一定的增量
	System.out.println("指定成员的分数增加增量："+jedis.zincrby("zkeys", 4, "lzl"));
//计算交集，并将结果存储在有序集合中
	System.out.println("计算交集，并将结果存储在有序集合中："+jedis.zinterstore("deskeys", "zkeys_1","zkeys"));
//计算有序集合指定区间的分数的成员数
	System.out.println("指定区间的分数成员数量："+jedis.zcount("zkeys", 0, 5));
//返回有序集合指定区间的成员
	System.out.println("集合指定区间的成员："+jedis.zrange("zkeys", 0, 6));
//返回有序集合指定值的score值
	System.out.println("score值是："+jedis.zrank("zkeys", "lzl"));
//移除有序集合中指定元素
	System.out.println("移除元素："+jedis.zrem("zkeys_1", "lzl"));
//返回有序集合指定成员的排名
	System.out.println("有序集合排名："+jedis.zrevrank("zkeys", "hhh"));
//集合中有序成员的分数值
	System.out.println("有序集合的分数值："+jedis.zscore("zkeys", "hhh-3"));
//计算集合并集，并存储到新的key中
	System.out.println("并集："+jedis.zunionstore("unionKeys", "zkeys","zkeys_1"));

Jedis操作Redis的几种方式：

参考博客：http://blog.csdn.net/u011130752/article/details/53483388