Redis3.0 工具类，单机，分片，集群，最全的

最新推荐文章于 2022-09-01 10:51:55 发布
最新推荐文章于 2022-09-01 10:51:55 发布
阅读量319 收藏
点赞数
分类专栏： 专题5：缓存 文章标签： rediscluster redisutils
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangchaoyi1a2b/article/details/82782519
版权

单机工具类：

package com.java.test.cache;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisManager extends CacheManager {

	private static JedisPool pool = null;
	private static final String HOST = "192.168.12.120"; // ip
	private static final int PORT = 6379; // 端口
	private static final String AUTH = "123456"; // 密码(原始默认是没有密码)
	private static int MAX_ACTIVE = 1024; // 最大连接数
	private static int MAX_IDLE = 200; // 设置最大空闲数
	private static int MAX_WAIT = 10000; // 最大连接时间
	private static int TIMEOUT = 10000; // 超时时间
	private static boolean BORROW = true; // 在borrow一个事例时是否提前进行validate操作

	static {
		GenericObjectPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(MAX_ACTIVE);
		config.setMaxIdle(MAX_IDLE);
		config.setMaxWaitMillis(MAX_WAIT);
		config.setTestOnBorrow(BORROW);

		pool = new JedisPool(config, HOST, PORT,TIMEOUT,AUTH);
//		pool = new JedisPool(config, HOST, PORT);
	}

	public static synchronized Jedis getJedis() {
		try {
			if (pool != null) {
				return pool.getResource();
			} else {
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	//
	public static void disableTime(String key, int seconds) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			if (jedis != null) {
				jedis.expire(key, seconds);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			getColse(jedis);
		}
	}

	public static boolean addObject(String key, Object obj) {
		Jedis jedis = null;
		String value = com.alibaba.fastjson.JSONObject.toJSONString(obj);
		try {
			jedis = getJedis();
			String code = jedis.set(key, value);
			if (code.equals("ok")) {
				return true;
			}
		} catch (Exception e) {
			return false;
		} finally {
			getColse(jedis);
		}
		return false;
	}

	public static boolean addValue(String key, String value) {
		Jedis jedis = null;
		try {
			jedis = getJedis();
			String code = jedis.set(key, value);
			if (code.equals("ok")) {
				return true;
			}
		} catch (Exception e) {
			return false;
		} finally {
			getColse(jedis);
		}
		return false;
	}

	public static 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;
		} finally {
			getColse(jedis);
		}
		return false;
	}

	public static void getColse(Jedis jedis) {
		try {
			if (jedis != null) {
				jedis.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static Object get(String key) {
		return getJedis().get(key);
	}

	@Override
	public String getName() {
		return CacheEnum.REDIS.getValue();
	}

	public static void main(String[] args) {
//		Jedis jedis = new Jedis("192.168.12.120", 6379);
//		System.out.println("connetion ok:" + jedis.ping());
//		// System.out.println(jedis.asking());
//		jedis.set("runkey", "www.run.com");
//		System.out.println(jedis.get("runkey"));
//		System.out.println("---------------------");
//		//
//		jedis.lpush("site", "google");
//		jedis.lpush("site", "baidu");
//		jedis.lpush("site", "ali");
//		List<String> lrange = jedis.lrange("site", 0, 2);
//		for (int i = 0; i < lrange.size(); i++) {
//			System.out.println(lrange.get(i));
//		}
//		System.out.println("---------------------");
//		//
//		Set<String> keys = jedis.keys("*");
//		Iterator<String> iterator = keys.iterator();
//		while (iterator.hasNext()) {
//			System.out.println(iterator.next());
//		}
		System.out.println(RedisManager.get("runkey"));
//		System.out.println(RedisManager.addValue("mykey", "www.run.com"));
		
		for (int i = 0; i < 1000; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(RedisManager.get("mykey"));
				}
			}).start();
		}
		for (int i = 0; i < 1000; i++) {
			
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					RedisManager.addValue("mykey",Math.abs( Math.random()*100)+"");
				}
			}).start();
		}
		
	}
}

分片工具类：

package com.java.test.cache;

import java.util.Arrays;
import java.util.List;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import redis.clients.jedis.Client;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class RedisShardedManager extends CacheManager {

	private static ShardedJedisPool pool = null;

	private static final String AUTH = ""; // 密码(原始默认是没有密码)
	private static int MAX_ACTIVE = 1024; // 最大连接数
	private static int MAX_IDLE = 200; // 设置最大空闲数
	private static int MAX_WAIT = 10000; // 最大连接时间
	private static int TIMEOUT = 10000; // 超时时间
	private static boolean BORROW = true; // 在borrow一个事例时是否提前进行validate操作
	static List<JedisShardInfo> shards;
	static {
		GenericObjectPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(MAX_ACTIVE);
		config.setMaxIdle(MAX_IDLE);
		config.setMaxWaitMillis(MAX_WAIT);
		config.setTestOnBorrow(BORROW);
		JedisShardInfo shardInfo1 = new JedisShardInfo("192.168.12.121", 6379);
		JedisShardInfo shardInfo2 = new JedisShardInfo("192.168.12.120", 6379);
		shards = Arrays.asList(shardInfo1, shardInfo2);
		pool = new ShardedJedisPool(config, shards);
	}

	public static synchronized ShardedJedis getJedis() {
		if (pool == null) {
			return null;
		} else {
			return pool.getResource();
		}
	}

	@Override
	public String getName() {
		return "ShardedJedis";
	}

	public static void main(String[] args) {
		ShardedJedis jedis = getJedis();
		jedis.set("cnblog", "cnblog");
		jedis.set("redis", "redis");
		jedis.set("test", "test");
		jedis.set("123456", "1234567");
		Client client1 = jedis.getShard("cnblog").getClient();
		Client client2 = jedis.getShard("redis").getClient();
		Client client3 = jedis.getShard("test").getClient();
		Client client4 = jedis.getShard("123456").getClient();

		 打印key在哪个server中
		System.out.println("cnblog in server:" + client1.getHost() + " and port is:" + client1.getPort());
		System.out.println("redis  in server:" + client2.getHost() + " and port is:" + client2.getPort());
		System.out.println("test   in server:" + client3.getHost() + " and port is:" + client3.getPort());
		System.out.println("123456 in server:" + client4.getHost() + " and port is:" + client4.getPort());
	}
}

集群工具类：

package com.java.test.cache;
import java.util.HashSet;
import java.util.Set;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

public class RedisClusterManager extends CacheManager {

	
	private static int MAX_ACTIVE = 1024; // 最大连接数
	private static int MAX_IDLE = 200; // 设置最大空闲数
	private static int MAX_WAIT = 10000; // 最大连接时间
	private static boolean BORROW = true; // 在borrow一个事例时是否提前进行validate操作
	private RedisClusterManager() {}
	private static class JedisClusterHandler{
		private static JedisCluster jedisCluster = null;
	}
	static {
		GenericObjectPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(MAX_ACTIVE);
		config.setMaxIdle(MAX_IDLE);
		config.setMaxWaitMillis(MAX_WAIT);
		config.setTestOnBorrow(BORROW);
		Set<HostAndPort> nodes = new HashSet<>();
		HostAndPort node1 = new HostAndPort("192.168.12.121", 3301);
		HostAndPort node2 = new HostAndPort("192.168.12.121", 3302);
		HostAndPort node3 = new HostAndPort("192.168.12.121", 3303);
		nodes.add(node1);
		nodes.add(node2);
		nodes.add(node3);
		JedisClusterHandler.jedisCluster = new JedisCluster(nodes, config);
	}

	@Override
	public String getName() {
		return "rediscluster";
	}

	public static JedisCluster getJedisCluster() {
		return JedisClusterHandler.jedisCluster;
	}
	/**
	 * 设置String数据类型
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public String set(String key, String value) {
		return getJedisCluster().set(key, value);
	}

	/**
	 * 获取String数据类型
	 * 
	 * @param key
	 * @return
	 */
	
	public String get(String key) {
		return getJedisCluster().get(key);
	}

	/**
	 * 设置hash数据类型
	 * 
	 * @param key
	 * @param item
	 * @param value
	 * @return
	 */
	
	public Long hset(String key, String item, String value) {
		return getJedisCluster().hset(key, item, value);
	}

	/**
	 * 获取hash数据类型
	 * 
	 * @param key
	 * @param item
	 * @return
	 */
	
	public String hget(String key, String item) {
		return getJedisCluster().hget(key, item);
	}

	/**
	 * 删除hash数据
	 * 
	 * @param key
	 * @param item
	 * @return
	 */
	
	public Long incr(String key) {
		return getJedisCluster().incr(key);
	}

	/**
	 * 加一操作
	 * 
	 * @param key
	 * @return
	 */
	
	public Long decr(String key) {
		return getJedisCluster().decr(key);
	}

	/**
	 * 减一操作
	 * 
	 * @param key
	 * @return
	 */
	
	public Long expire(String key, int second) {
		return getJedisCluster().expire(key, second);
	}

	/**
	 * 设置key的过期时间
	 * 
	 * @param key
	 * @param second
	 * @return
	 */
	
	public Long ttl(String key) {
		return getJedisCluster().ttl(key);
	}

	/**
	 * 判断key是否过期
	 * 
	 * @param key
	 * @return
	 */
	
	public Long hdel(String key, String item) {
		return getJedisCluster().hdel(key, item);
	}

}

 

CodeWorldofOne
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis jedis 单机、集群、分片存储连接操作redis
08-21
单机版：该类主要完成redis基础功能，若redis为单机版时，该方式即可。 但若连接redis集群时，该方式只能获取指定库的键值，表现形式为 取数据不完整。 集群版:redis集群连接. 分片存储：redis分片存储，该方式通过计算hash把数据均匀的存储在相应的redis库中，该方式只能操作通过分片存储的数据，其他单独客户端存储的数据，因hash定位 问题，无法找到键值数据。
redis3.0安装包 window 64位
最新发布
11-09
（4）集群：Redis 3.0支持集群，可以将多个Redis实例拼接成一个集群，并实现负载均衡，提高Redis的可用性。 3、总结： Redis 3.0是一款高性能的开源内存数据库，它拥有非常快速的读写性能，几乎是传统数据库的1000倍...
初学乍练redis：分片与集群
热门推荐
wzy0623的专栏
09-14 1万+
目录 一、配置集群 二、增加节点 三、分配插槽 四、获取与插槽对应的节点 五、故障恢复         大部分摘自Redis入门指南（第2版）。         即使使用哨兵，redis集群的每个数据库依然存有集群中的所有数据，从而导致集群的总数据存储受限于可用内存最小的数据库节点，形成木桶效应。由于redis中的所有数据都基于内存存储，这一问题尤为突出，特别是把redis用作持久化...
Jedis 3.0 即以上Java jedis 整合 redis
chuncui2576的博客
05-05 959
玩了一下 redis ，因此使用 jedis 。。。 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> &...
Redis-单机，哨兵主从，分片集群搭建
nxrsdh的博客
08-26 459
让我们看看redis如何部署
Jedis工具类
weixin_48296221的博客
09-01 2095
使用Jedis对redis进行操作的工具类
可能是方法最全Redis静态工具类（RedisUtils.java）
06-28
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！
Redis3.0集群
11-05
Redis 3.0 集群安装、主从复制架构、哨兵架构原理及多个哨兵配置、集群建构创建和配置详解 在本文档中，我们将详细描述 Redis 3.0 的安装、主从复制架构、哨兵架构原理及多个哨兵配置、集群建构创建和配置等内容。 ...
redis3.0.集群环境安装手册
06-12
Redis 3.0 集群环境安装手册 Redis 3.0 集群环境安装手册是指在 Linux 操作系统中安装和配置 Redis 3.0 集群的步骤指南。Redis 是一个开源、基于内存的数据结构存储系统，可以用作数据库、消息队列、缓存层等。 ...
乌鸦：Redis 3.0的快速轻量级Redis集群代理
01-31
乌鸦座 Corvus是启用了集群模式的Redis 3.0的快速轻量级Redis集群代理。为什么大多数Redis客户端实现不支持Redis集群。 我们有很多依赖Redis的服务，这些服务是用Python，Java，Go，Nodejs等编写的。在不破坏兼容性...
redis3.0.1加RedisDesktopManager
03-27
https://blog.csdn.net/qq_34719168/article/details/88849886这个博文里用的redis
redis3.0.5
12-09
linux系统下的redis,在centos环境下配置成功
Redis Java客户端Jedis 2.9.0 jar包（含common-pool2）
11-17
Redis的官方推荐Java客户端——Jedis 此Jar包为Jedis 2.9.0版（2016年7月22日发布） 支持Redis 3.0 （亲测有效） 使用方法： import redis.clients.jedis.Jedis; Jedis jedis = new Jedis("localhost"); jedis.set("foo", "bar"); String value = jedis.get("foo"); jedis.close(); System.out.println(value);
Redis数据分片处理（六）
wanghaoxin的博客
06-30 3518
Redis分片处理（twemproxy代理机制） 代理组件：twemproxy 不管你现在的电脑性能有多好，只要你运行了Redis，那么就有可能造成一种可怕的局面，你电脑的内存将立刻被占满。而且一台Redis数据库的性能终归是有限制的，那么现在如果要保证用户的执行速度快，就需要使用集群的设计。而对于集群的设计，主要的问题就是解决单实例Redis的性能瓶颈。 twemproxy代理机制 T...
jedisclient从2.9升级到3.2后redisUtil工具类方法变化
qq_34412985的博客
04-17 1366
public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) { Jedis jedis = getJedis(); Long linsert = jedis.linsert(key, wher...
redis(jedis)工具类实例：集群模式和单机模式
weixin_42315600的博客
02-13 1439
redis(jedis)工具类实例：集群模式和单机模式     在写redis工具类之前，我们首先需要知道如何读取redis配置文件，此处提供properties配置文件的读取工具类，大家可以直接使用：https://blog.csdn.net/weixin_42315600/article/details/87170735 1、集群模式工具类 package com.wonddream....
关于redis集群方案
劝君与我同风起，扶摇直上九万里
03-25 3621
最近在研究redis集群方案，看到知乎上有个朋友写的观点很好，就先收过来了。原文见：http://www.zhihu.com/question/21419897
redis３.０　redis.clients.jedis.exceptions.JedisDataException: WRONGTYPE Operation against a key holdin
架构师的方向
08-10 1万+
//同步redis数据 更新学生学习当前教师的专题集合和数量 Long　addResultSpecials=redisDao.getJedisCluster().zadd(RedisKey.rela_userFamous_specialZSet+":"+studentId+":"+teacherId,System.currentTimeMillis()/1000,String.va
redis单机版和集群版工具类
qq_42689281的博客
09-13 978
单机版集群版共同实现的接口 package com.hr.common.redis; public interface JedisClient { String set(String key ,String value); String get(String key); public Long hset(String key, String item, String value); p...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值