redis集群

最新推荐文章于 2024-08-12 17:53:56 发布
最新推荐文章于 2024-08-12 17:53:56 发布
阅读量187 收藏
点赞数
分类专栏： redis 文章标签： redis集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_jiaping/article/details/79536244
版权

Redis简介

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库

Redis 与其他 key - value 缓存产品有以下三个特点：

  • Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用
  • Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
  • Redis支持数据的备份，即master-slave模式的数据备份。

Redis优势

  • 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 
  • 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作
  • 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
  • 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性

Redis集群服务器搭建

Spring集成JedisCluster

  • maven依赖：
	<dependency>
		<groupId>redis.clients</groupId>
		<artifactId>jedis</artifactId>
		<version>2.9.0</version>
	</dependency>
  • 增加spring配置
	<bean name="genericObjectPoolConfig" class="org.apache.commons.pool2.impl.GenericObjectPoolConfig">  //对象池
		<property name="maxWaitMillis" value="-1" />  //默认为-1
		<property name="maxTotal" value="1000" />     //最大连接
		<property name="minIdle" value="8" />         //最小空闲对象
		<property name="maxIdle" value="100" />       //最大空闲对象
	</bean>

	<bean id="jedisCluster" class="xxx.xxx.xxxxxx.infrastructure.util.redis.JedisClusterFactory">
		<property name="addressConfig">
			<value>file:/web/profile/beautiful/connect-redis.properties</value>  //配置文件
		</property>
		<property name="addressKeyPrefix" value="address" />   //属性文件里 key的前缀

		<property name="timeout" value="300000" />
		<property name="maxRedirections" value="6" />
		<property name="genericObjectPoolConfig" ref="genericObjectPoolConfig" />
	</bean>
  • connect-redis.properties配置文件（6个节点）
address1=192.168.21.101:7000
address2=192.168.21.101:7001
address3=192.168.21.102:7002
address4=192.168.21.102:7003
address5=192.168.21.103:7004
address6=192.168.21.103:7005
  • 增加JedisClusterFactory类
import java.util.HashSet;  
import java.util.Properties;  
import java.util.Set;  
import java.util.regex.Pattern;  
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;  
import org.springframework.beans.factory.FactoryBean;  
import org.springframework.beans.factory.InitializingBean;  
import org.springframework.core.io.Resource;  
import redis.clients.jedis.HostAndPort;  
import redis.clients.jedis.JedisCluster;  
  
public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean {  
  
    private Resource addressConfig;  
    private String addressKeyPrefix ;  
  
    private JedisCluster jedisCluster;  
    private Integer timeout;  
    private Integer maxRedirections;  
    private GenericObjectPoolConfig genericObjectPoolConfig;  
      
    private Pattern p = Pattern.compile("^.+[:]\\d{1,5}\\s*$");  
  
    @Override  
    public JedisCluster getObject() throws Exception {  
        return jedisCluster;  
    }  
  
    @Override  
    public Class<? extends JedisCluster> getObjectType() {  
        return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);  
    }  
  
    @Override  
    public boolean isSingleton() {  
        return true;  
    }  
  
    private Set<HostAndPort> parseHostAndPort() throws Exception {  
        try {  
            Properties prop = new Properties();  
            prop.load(this.addressConfig.getInputStream());  
  
            Set<HostAndPort> haps = new HashSet<HostAndPort>();  
            for (Object key : prop.keySet()) {  
  
                if (!((String) key).startsWith(addressKeyPrefix)) {  
                    continue;  
                }  
  
                String val = (String) prop.get(key);  
  
                boolean isIpPort = p.matcher(val).matches();  
  
                if (!isIpPort) {  
                    throw new IllegalArgumentException("ip 或 port 不合法");  
                }  
                String[] ipAndPort = val.split(":");  
  
                HostAndPort hap = new HostAndPort(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
                haps.add(hap);  
            }  
  
            return haps;  
        } catch (IllegalArgumentException ex) {  
            throw ex;  
        } catch (Exception ex) {  
            throw new Exception("解析 jedis 配置文件失败", ex);  
        }  
    }  
      
    @Override  
    public void afterPropertiesSet() throws Exception {  
        Set<HostAndPort> haps = this.parseHostAndPort();  
          
        jedisCluster = new JedisCluster(haps, timeout, maxRedirections,genericObjectPoolConfig);  
          
    }  
    public void setAddressConfig(Resource addressConfig) {  
        this.addressConfig = addressConfig;  
    }  
  
    public void setTimeout(int timeout) {  
        this.timeout = timeout;  
    }  
  
    public void setMaxRedirections(int maxRedirections) {  
        this.maxRedirections = maxRedirections;  
    }  
  
    public void setAddressKeyPrefix(String addressKeyPrefix) {  
        this.addressKeyPrefix = addressKeyPrefix;  
    }  
  
    public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) {  
        this.genericObjectPoolConfig = genericObjectPoolConfig;  
    }  
  
}
  • 编写redis工具类
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.util.JedisClusterCRC16;
import com.google.common.collect.Maps;

@Component("redisTool")
public class RedisTool {
	
	private static Logger logger = LoggerFactory.getLogger(RedisTool.class);
	/**
	 * 集群客户端
	 */
	private static JedisCluster jedisCluster;
	/**
	 * redis哈希槽和ip:port的映射
	 */
	private static TreeMap<Long, String> treeMap;
	
	private static Map<String, JedisPool> jedisMap;
	
	/**
	 * 根据key获取对应的jedis实例
	 * @param key
	 * @return
	 */
	public static Jedis getJedis(String key)
	{
		if(key == null) return null;
		if(treeMap == null)
		{
			synchronized (RedisTool.class) {
				if(treeMap == null){
					parseAllSlotAndIport();
				}
			}
		}
		//槽
		int slot = JedisClusterCRC16.getSlot(key);
		//槽-端口映射
		Entry<Long, String> entry = treeMap.lowerEntry(Long.valueOf(slot));
		//槽对应的jedis
		Jedis jedis = jedisMap.get(entry.getValue()).getResource();
		return jedis;
	}
	
	private static void parseAllSlotAndIport()
	{
		logger.info("redis开始哈希槽到ipport的映射");
		
		jedisMap = jedisCluster.getClusterNodes();
		treeMap = Maps.newTreeMap();
		
		for(Entry<String, JedisPool> entry : jedisMap.entrySet()){
			String ipAndPort = entry.getKey();
			logger.info("redis服务器:" + ipAndPort + "哈希槽位映射");
			TreeMap<Long, String> tree = parseSlotAndIport(ipAndPort);
			if(tree == null || tree.size() <= 0){
				logger.info("redis服务器:" + ipAndPort + "哈希槽位映射异常，信息为空");
				continue;
			}
			treeMap.putAll(tree);
		}
		logger.info("redis完成哈希槽到ipport的映射");
	}
	
	private static TreeMap<Long, String> parseSlotAndIport(String ipAndPort)
	{
		TreeMap<Long, String> tree = new TreeMap<Long, String>();  
	    String parts[] = ipAndPort.split(":");  
	    HostAndPort anyHostAndPort = new HostAndPort(parts[0], Integer.parseInt(parts[1]));  
	    Jedis jedis = null;  
	    try{  
	        jedis = new Jedis(anyHostAndPort.getHost(), anyHostAndPort.getPort());  
	        List<Object> list = jedis.clusterSlots();  
	        for (Object object : list) {  
	            List<Object> list1 = (List<Object>) object;  
	            List<Object> master = (List<Object>) list1.get(2);  
	            String hostAndPort = new String((byte[]) master.get(0)) + ":" + master.get(1);  
	            tree.put((Long) list1.get(0), hostAndPort);  
	            tree.put((Long) list1.get(1), hostAndPort);  
	        }  
	    }catch(Exception e){  
	        logger.error("getSlotHostMap error",e);  
	    }  
	    return tree;
	}
	
	public static void returnJedis(Jedis jedis)
	{
		jedis.close();
	}
@Autowiredpublic void setJedisCluster(JedisCluster jedisCluster){this.jedisCluster = jedisCluster;} 
	public static JedisCluster getJedis()
	{
		return jedisCluster;
	}
} 
 

 

  • redis入库操作
 

 
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import com.ecpss.beautifulperson.domain.utils.Pager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.stereotype.Component;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;
import com.ecpss.beautifulperson.domain.utils.StringUtils;
import com.ecpss.beautifulperson.infrastructure.util.redis.RedisTool;
import com.google.common.collect.Maps;

@Component("redisUtil")
public class RedisUtil {
	private static final Charset UTF_8 = Charset.forName("utf-8");

	private static Logger logger = LoggerFactory.getLogger(RedisUtil.class);
	
	/*************     STRING 操作       **************/
	
	public boolean addString(String key, String value) {
		if (StringUtils.isBlank(key))
			return false;
		logger.info("redis入库string, key:" + key + ",value:" + value);
		Jedis jedis = RedisTool.getJedis(key);
		String result = jedis.set(key, value);
		RedisTool.returnJedis(jedis);
		return "OK".equals(result);
	}
	public boolean addStringExipre(String key, String value, int second) {
		if (StringUtils.isBlank(key))
			return false;
		logger.info("redis入库string, key:" + key + ",value:" + value);
		Jedis jedis = RedisTool.getJedis(key);
		String result = jedis.setex(key, second, value);
		RedisTool.returnJedis(jedis);
		return "OK".equals(result);
	}

	public String getString(String key) {
		if (StringUtils.isBlank(key))
			return null;

		Jedis jedis = RedisTool.getJedis(key);
		String result = jedis.get(key);
		RedisTool.returnJedis(jedis);
		return result;
	}

	public Long increaseString(String key, int count) {
		if (StringUtils.isBlank(key)) {
			return null;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.incrBy(key, count);
		RedisTool.returnJedis(jedis);
		return result;
	}

	/*****************   KEY操作  **************/
	public boolean delKey(String key) {
		if (StringUtils.isBlank(key))
			return true;
		logger.info("redis删除key, key:" + key );
		Jedis jedis = RedisTool.getJedis(key);
		jedis.del(key);
		RedisTool.returnJedis(jedis);
		return true;
	}

	public boolean expire(String key, int second) {
		if (StringUtils.isBlank(key)) {
			return false;
		}
		logger.info("redis设置超时时间, key:" + key + ",second:" + second);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.expire(key, second);
		RedisTool.returnJedis(jedis);
		return true;
	}
	public Set<String> keys(String pattern) {
		if (StringUtils.isBlank(pattern)) {
			return null;
		}
		Jedis jedis = RedisTool.getJedis(pattern);
		Set<String> set = jedis.keys(pattern);
		RedisTool.returnJedis(jedis);
		return set;
	}
	
	/******************    MAP 操作     ********************/
	
	public void addMap(String key, Map<String, String> map) {
		if (StringUtils.isBlank(key) || map == null)
			return;
		logger.info("redis入库map, key:" + key + ",value:" + map);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.hmset(key, map);
		RedisTool.returnJedis(jedis);
	}

	public boolean addMapVal(String key, String field, String value) {
		if (StringUtils.isBlank(key) || StringUtils.isBlank(key)
				|| StringUtils.isBlank(key))
			return false;
		logger.info("redis入库map单项值, key:" + key + ",field:" + field + ",value:" + value);
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.hsetnx(key, field, value);
		RedisTool.returnJedis(jedis);
		return result.intValue() ==1;
	}
	
	public boolean updateMapVal(String key, String field, String value){
		if (StringUtils.isBlank(key) || StringUtils.isBlank(key)
				|| StringUtils.isBlank(key))
			return false;
		logger.info("redis更库map, key:" + key + ",field:" + field + ",value:" + value);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.hset(key, field, value);
		RedisTool.returnJedis(jedis);
		return true;
	}

	public Map<String, String> getMap(String key) {
		if (StringUtils.isBlank(key))
			return null;
		Jedis jedis = RedisTool.getJedis(key);
		Map<String, String> map = jedis.hgetAll(key);
		RedisTool.returnJedis(jedis);
		return map;
	}
	
	public String getMapField(String key, String field)
	{
		if(StringUtils.isBlank(key) || StringUtils.isBlank(field)) return null;
		Jedis jedis = RedisTool.getJedis(key);
		String result = jedis.hget(key, field);
		RedisTool.returnJedis(jedis);
		return result;
	}
	
	public List<String> getMapFields(String key, String... fields){
		if(StringUtils.isBlank(key) || fields == null) return null;
		Jedis jedis = RedisTool.getJedis(key);
		List<String> result = jedis.hmget(key, fields);
		RedisTool.returnJedis(jedis);
		return result;
	}
	
	public Map<String, Map<String, String>> fetchGetMap(RedisKeyType keyType, String ...key)
	{
		if(key == null || keyType == null) return null;
		logger.info("redis管道入库map, key:" + key + ",keyType:" + keyType);
		Map<String, Response<Map<String, String>>> map = Maps.newHashMap();
		Map<String, Map<String, String>> result = Maps.newHashMap();
		
		Jedis jedis = RedisTool.getJedis(keyType.getText());
		//管道批量操作
		Pipeline pipeline = jedis.pipelined();
		for (String string : key) {
			map.put(string, pipeline.hgetAll(RedisKeyUtil.getKeyByType(string, keyType)));
		}
		pipeline.sync();
		for (Entry<String, Response<Map<String, String>>> entry : map.entrySet()) {
			result.put(entry.getKey(), entry.getValue().get());
		}
		RedisTool.returnJedis(jedis);
		return result;
	}
	
	/***************     LIST 操作   ******************/

	public void addList(String key, String... values) {
		if (StringUtils.isBlank(key) || values == null) {
			return;
		}
		logger.info("redis入库list, key:" + key + ",values:" + values);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.rpush(key, values);
		RedisTool.returnJedis(jedis);
	}

	public List<String> getListVals(String key, int start, int end) {
		if (StringUtils.isBlank(key))
			return null;

		Jedis jedis = RedisTool.getJedis(key);
		List<String> rtnList = jedis.lrange(key, start, end);
		RedisTool.returnJedis(jedis);
		return rtnList;
	}
	
	/*******************    SET 操作     *********************/
	
	public void addSet(String key, String... values) {
		if (StringUtils.isBlank(key) || values == null) {
			return;
		}
		logger.info("redis入库set, key:" + key + ",values:" + values);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.sadd(key, values);
		RedisTool.returnJedis(jedis);
	}

	public void delSetVal(String key, String... fields) {
		if (StringUtils.isBlank(key)) {
			return;
		}
		logger.info("redis删除set, key:" + key + ",values:" + fields);
		Jedis jedis = RedisTool.getJedis(key);
		jedis.srem(key, fields);
		RedisTool.returnJedis(jedis);
	}

	public Set<String> getSetVals(String key) {
		if (StringUtils.isBlank(key)) {
			return null;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Set<String> rtnSet = jedis.smembers(key);
		RedisTool.returnJedis(jedis);
		return rtnSet;
	}

	public boolean isSetContain(String key, String field) {
		if (StringUtils.isBlank(key) || StringUtils.isBlank(field)) {
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		boolean isContain = jedis.sismember(key, field);
		RedisTool.returnJedis(jedis);
		return isContain;
	}

	public Long getSetLength(String key) {
		if (null == key) {
			return 0L;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long length = jedis.scard(key);
		RedisTool.returnJedis(jedis);
		return length;
	}
	
	/********************* SORT SET 操作    *************************/
	public static boolean addSortSet(String key, String member){
		return addSortSet(key, System.currentTimeMillis(), member);
	}
	public static boolean addSortSet(String key, double score, String member)
	{
		if(StringUtils.isBlank(key) || StringUtils.isBlank(member)){
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.zadd(key, score, member);
		RedisTool.returnJedis(jedis);
		if(result == null) return false;
		return result.intValue() > 0;
	}
	
	public boolean delSortSet(String key, String... member){
		if(StringUtils.isBlank(key) || member == null){
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.zrem(key, member);
		RedisTool.returnJedis(jedis);
		if(result == null) return false;
		return result.intValue() > 0;
	}

	public boolean delSortSetByScore(String key, Double score){
		if(StringUtils.isBlank(key) || score == null){
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.zremrangeByScore(key, score, score);
		RedisTool.returnJedis(jedis);
		if(result == null) return false;
		return result.intValue() > 0;
	}

	public boolean delSortSetAll(String key) {
		if (StringUtils.isBlank(key)) {
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.zremrangeByRank(key, 0, -1);
		RedisTool.returnJedis(jedis);
		if(result == null) return false;
		return result.intValue() > 0;
	}
	
	public boolean isSortSetContain(String key, String member)
	{
		if(StringUtils.isBlank(key) || StringUtils.isBlank(member)) return false;
		Jedis jedis = RedisTool.getJedis(key);
		Long result = jedis.zrank(key, member);
		RedisTool.returnJedis(jedis);
		if(result == null) return false;
		return result.intValue() >= 0;
	}
	
	public List<String> getSortSetValAsc(String key, int start, int end)
	{
		if(StringUtils.isBlank(key)) return null;
		Jedis jedis = RedisTool.getJedis(key);
		Set<String> sets = jedis.zrange(key, start, end);
		RedisTool.returnJedis(jedis);
		if(sets == null || sets.size() <= 0) return null;
		
		return new ArrayList<String>(sets);
	}
	public List<String> getSortSetValDesc(String key, int start, int end)
	{
		if(StringUtils.isBlank(key)) return null;
		Jedis jedis = RedisTool.getJedis(key);
		Set<String> sets = jedis.zrevrange(key, start, end);
		RedisTool.returnJedis(jedis);
		if(sets == null || sets.size() <= 0) return null;

		return new ArrayList<String>(sets);
	}

	/**
	 *  根据score区间,获取分页String集合
	 * @param key
	 * @param beginScore
	 * @param endScore
	 * @param pager pager为null则不分页
	 * @return
	 */
	public Long getSortSetCountByScore(String key, Double beginScore,Double endScore) {

		Set<String> sets;
		if(StringUtils.isBlank(key))
		{
			return null;
		}
		Jedis jedis = RedisTool.getJedis(key);
		RedisTool.returnJedis(jedis);
		 return	jedis.zcount(key, beginScore, endScore);
	}


	/**
	 *  根据score区间,获取分页String集合
	 * @param key
	 * @param beginScore
	 * @param endScore
	 * @param pager pager为null则不分页
	 * @return
	 */
	public List<String> getSortSetValByScore(String key, Double beginScore,Double endScore,Pager pager)
	{
		Set<String> sets;
		if(StringUtils.isBlank(key))
		{
			return null;
		}
		Jedis jedis = RedisTool.getJedis(key);
		if(pager==null)
		{
			 sets = jedis.zrangeByScore(key, beginScore, endScore)  ;
		}
		else
		{
		 sets =jedis.zrangeByScore(key, beginScore, endScore, (pager.getPageNumber() - 1) * pager.getLimit(), pager.getLimit());
		}
		RedisTool.returnJedis(jedis);
		if(sets == null || sets.size() <= 0)
		{
			return null;
		}

		return new ArrayList<String>(sets);
	}
	/**
	 *  根据score区间,获取分页String倒序集合
	 * @param key
	 * @param beginScore
	 * @param endScore
	 * @param pager pager为null则不分页
	 * @return
	 */
	public List<String> getSortSetValByScoreDesc(String key, Double beginScore,Double endScore,Pager pager)
	{
		Set<String> sets;
		if(StringUtils.isBlank(key))
		{
			return null;
		}
		Jedis jedis = RedisTool.getJedis(key);
		if(pager==null)
		{
			sets = jedis.zrevrangeByScore(key, endScore, beginScore)  ;
		}
		else
		{
			sets =jedis.zrevrangeByScore(key,  endScore, beginScore,(pager.getPageNumber() - 1) * pager.getLimit(), pager.getLimit());
		}
		RedisTool.returnJedis(jedis);
		if(sets == null || sets.size() <= 0)
		{
			return null;
		}

		return new ArrayList<String>(sets);
	}

	public static Long getSortSetLength(String key)
	{
		if(StringUtils.isBlank(key)) return 0l;
		Jedis jedis = RedisTool.getJedis(key);
//		Long result = jedis.zcount(key, "-inf", "+inf");
		Long result = jedis.zcard(key);
		RedisTool.returnJedis(jedis);
		return result;
	}

	public boolean increaseSortSetScore(String key, double score, String member) {
		if (StringUtils.isBlank(key)) {
			return false;
		}
		Jedis jedis = RedisTool.getJedis(key);
		jedis.zincrby(key, score, member);
		RedisTool.returnJedis(jedis);
		return true;
	}
	
	
	/********************* JSON 操作  弃用 ************************/
	public boolean addObejct(String key, Object obj)
	{
		if(StringUtils.isBlank(key) || obj == null){
			return false;
		}
		logger.info("redis入库object, key:" + key + ",Object:" + obj);
//		String objString = gson.toJson(obj);
		Map map = convertMap(obj);
		Jedis jedis = RedisTool.getJedis(key);
//		String result = jedis.set(key, objString);
		String result = jedis.hmset(key, map);
		RedisTool.returnJedis(jedis);
		return "OK".equals(result);
	}
	
	private Map convertMap(Object obj)
	{
		if(obj == null) return null;
		Map map = Maps.newHashMap();
		BeanMap beanMap = BeanMap.create(obj);
		for(Object key : beanMap.keySet()){
			Object value = beanMap.get(key);
			if(value == null) continue;
			map.put(key + "", value.toString());
		}
		return map;
	}
	
	
	public <T> T getObject(String key, Class<T> clazz){
		if(StringUtils.isBlank(key) || clazz == null) return null;
		logger.info("redis获取object, key:" + key + ",clazz:" + clazz);
		Jedis jedis = RedisTool.getJedis(key);
//		String result = jedis.get(key);
		Map<String, String> map = jedis.hgetAll(key);
		RedisTool.returnJedis(jedis);
		
		if(map == null) return null;
//		T obj = gson.fromJson(result, clazz);
		try {
			T t = clazz.newInstance();
			BeanMap beanMap = BeanMap.create(t);
			beanMap.putAll(beanMap);
			return t;
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	/******************      序列化操作      *************************/
	/**
	 * 禁止返回HIBERNATE对象
	 * @param key
	 * @param tClass
	 * @return
	 */
	public <T>T  getObjectByKey(String key, Class<T> tClass)
    {
		Jedis jedis = RedisTool.getJedis(key);
        byte[] byt=jedis.get(key.getBytes());
        Object obj= unserizlize(byt);
        RedisTool.returnJedis(jedis);
        if(obj!=null && obj.getClass().getName()==tClass.getName()){
            return (T)obj;
        }
        return null;
    }
	public void saveObject(String key,Object Obj)
    {
		Jedis jedis = RedisTool.getJedis(key);
        jedis.set(key.getBytes(), serialize(Obj));
        RedisTool.returnJedis(jedis);
    }


    //序列化
    private static byte [] serialize(Object obj){
        ObjectOutputStream obi=null;
        ByteArrayOutputStream bai=null;
        try {
            bai=new ByteArrayOutputStream();
            obi=new ObjectOutputStream(bai);
            obi.writeObject(obj);
            byte[] byt=bai.toByteArray();
            return byt;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    //反序列化
    private static Object unserizlize(byte[] byt){
        ObjectInputStream oii=null;
        ByteArrayInputStream bis=null;
        bis=new ByteArrayInputStream(byt);
        try {
            oii=new ObjectInputStream(bis);
            Object obj=oii.readObject();
            return obj;
        } catch (Exception e) {

            e.printStackTrace();
        }


        return null;
    }

}
 

 

Redis集群初始化、slot(槽)的分配
 

 
 
  • 集群初始化： 在JedisClusterFactory类中它实现了InitializingBean接口，重写了afterPropertiesSet()方法，当JedisClusterFactory Bean被注册之后，此方法被调用，它里面调用parseHostAndPort()方法
  • slot的分配：  Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 取模，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 

 
 
 

 


                

        

        

    

  


    

      

        

            

              
                
                  MrPings
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Redis集群弱/空密码问题整改

				
			

			

				

					11-15
				

			

		

		

			
				
使用redis安装用户，在命令行连接上redis集群后，执行命令：config set requirepass 【自定义的强密码】，如： config set requirepass mypassword@#75@~ 然后执行 config rewrite 将配置密码持久化到redis配置文件...

			
		

	



                

              
                



	

		

			

				
					
redis集群批量插入

				
			

			

				

					11-23
				

			

		

		

			
				
本文将详细讨论如何在Java环境下连接Redis集群并实现批量插入String类型的数据。  首先，我们需要理解Redis集群的基本概念。Redis集群是通过分片（Sharding）技术来分散数据到多个节点，每个节点存储一部分数据。在...

			
		

	



                


  
              

                


	

		

			

				
					
jedis连接redis

				
			

			

				

					Jeffery的博客
				

				

					08-18
					
					477
					
				

			

		

		

			
				
1 pom引用


   org.springframework
   spring-aop
   4.3.7.RELEASE


   redis.clients
   jedis
   2.9.0


   cglib
   cglib
   3.2.5



   org.aspectj
   aspectjrt
   1.8.10


   org.aspectj
   aspectj

			
		

	





	

		

			

				
					
Java中Pattern.compile函数的用法

				
			

			

				

					huangjhai的博客
				

				

					01-28
					
					7万+
					
				

			

		

		

			
				
除了Pattern Pattern.compile(String regex),Pattern类的compile()方法还有另一个版本：
Pattern Pattern.complie(String regex,int flag)，它接受一个标记参数flag，以调整匹配的行为。
flag来自以下Pattern类中的常量：




编译标记
效果




Pattern.CANON_EQ
两个字符当...

			
		

	



		

			
		



	

		

			

				
					
SSM+redis整合(mybatis整合redis做二级缓存)

				
			

			

				

					u012045045的博客
				

				

					01-08
					
					271
					
				

			

		

		

			
				
SSM：是Spring+Struts+Mybatis ，另外还使用了PageHelper

　　

前言:

　　这里主要是利用redis去做mybatis的二级缓存，mybaits映射文件中所有的select都会刷新已有缓存，如果不存在就会新建缓存，所有的insert，update操作都会更新缓存。(这里需要明白对于注解写的SQL语句不会操作缓存，我的增加方法是注解写的就没有清空缓存，后来改为X...

			
		

	





	

		

			

				
					
java Pattern正则表达式的自我理解

				
			

			

				

					记录技术点点之路
				

				

					05-20
					
					403
					
				

			

		

		

			
				
Pattern pattern=Pattern.compile(".*java");  //所有以java结尾的字符

pattern=Pattern.compile("^[\\d]*$");  //匹配所有长度的数字

pattern=Pattern.compile("^[\\d]{2}$"); //匹配2个长度的数字

pattern=Pattern.compile("^[\\d]...

			
		

	





	

		

			

				
					
Pattern用法(正则表达式)

				
			

			

				

					杰哥的专栏
				

				

					08-11
					
					10万+
					
				

			

		

		

			
				
1. 正则表达式的应用

       在给用户发送消息时通常情况会有相同的消息模板，但其中部分信息跟用户相关，因此需要对消息模板中的变量部分进行替换。而对于一个系统而言可能有很多套完全不同的模板。因此需要一个通用的根据实际信息替换消息模板中变量的方法。
publicstatic  String replacePlaceHolderWithMapValue(String msg,Map pl

			
		

	





	

		

			

				
					
Redis集群详解

					
热门推荐

				
			

			

				

					变成习惯
				

				

					05-10
					
					22万+
					
				

			

		

		

			
				
Redis集群详解
Redis有三种集群模式，分别是：
* 主从模式

* Sentinel模式

* Cluster模式

三种集群模式各有特点，关于Redis介绍可以参考这里：NoSQL（二)——Redis
Redis官网：https://redis.io/ ，最新版本5.0.4

主从模式
主从模式介绍
主从模式是三种模式中最简单的，在主从复制中，数据库分为两类：主数据库(master)和从...

			
		

	





	

		

			

				
					
Redis 集群方式

				
			

			

				

					qq_51678989的博客
				

				

					08-12
					
					1812
					
				

			

		

		

			
				
集群，即 Redis cluster， 是 Redis 3.0开始引入的分布式存储方案。集群由多个节点(Node)组成，Redis 的数据分布在这些节点中。集群中的节点分为主节点和从节点;只有主节点负责读写请求和集群信息的维护;从节点只进行主节点数据和状态信息的复制。

			
		

	





	

		

			

				
					
Redis集群

				
			

			

				

					Drw_Dcm的博客
				

				

					10-02
					
					9688
					
				

			

		

		

			
				
Redis集群

			
		

	





	

		

			

				
					
Redis集群原理详解

				
			

			

				

					张维鹏的博客
				

				

					02-16
					
					5万+
					
				

			

		

		

			
				
一、redis cluster 介绍：

1、单实例的Redis架构：

最开始的一主N从加上读写分离，Redis作为缓存单实例貌似也还不错，并且有Sentinel哨兵机制，可以实现主从故障迁移。



单实例Redis本质上只有一台Master作为存储，就算机器为128GB的内存，一般建议使用率也不要超过70%-80%，所以最多使用100GB数据就已经很多了，实际中50%就不错了，因为数据量太大也会降低服务的稳定性，而且数据量太大意味着持久化成本高，可能严重阻塞服务，甚至最终切主。所以，单实例还存在以下几

			
		

	





	

		

			

				
					
Redis集群数据迁移操作文档

				
			

			

				

					06-29
				

			

		

		

			
				
《Redis集群数据迁移实战指南》  在IT领域，数据迁移是一项关键任务，特别是在使用Redis这样的高性能内存数据库时。本文将详细介绍如何进行Redis集群的数据迁移，包括全量和增量数据迁移，以及离线迁移的方法，主要...

			
		

	





	

		

			

				
					
Redis集群下过期key监听的实现代码

				
			

			

				

					09-09
				

			

		

		

			
				
在讨论Redis集群下过期key监听的实现代码之前，首先需要明确几个核心概念和组件：  Redis集群是Redis的一种高可用性解决方案，它通过将数据分布在不同的Redis节点上，并提供一定机制保证数据的复制和高可用性。集群...

			
		

	





	

		

			

				
					
阿里云公网redis集群搭建以及java访问redis集群

				
			

			

				

					04-20
				

			

		

		

			
				
阿里云公网Redis集群搭建及Java访问教程  在云计算日益普及的今天，阿里云提供了便捷的公共服务，如Redis缓存服务，帮助企业或个人快速构建高效、可靠的分布式应用。本教程将详细讲解如何在阿里云上搭建公网Redis...

			
		

	





	

		

			

				
					
Pattern p = Pattern.compile("(?s).*\\s+RC=(\\S*)\\s+.*");的意思

				
			

			

				

					dahuzi的专栏
				

				

					03-20
					
					5327
					
				

			

		

		

			
				
("(?s).*\\s+RC=(\\S*)\\s+.*");

?为某个字符或无字符，s为原样
.为某个字符
*为多个,含0个
\\s为个空格
\\S为非空格字符
+为至少一个
RC=为原样
(\\S*)为多个非空格字符
\\s+为至少一个空格
.为某个字符
*为多个,含0个
注意\\s与\\S的区别(大小写不一致)

			
		

	





	

		

			

				
					
基于微信小程序的新生报到系统设计与实现.docx

				
			

			

				

					09-13
				

			

		

		

			
				
基于微信小程序的新生报到系统设计与实现.docx

			
		

	





	

		

			

				
					
基于java的电商平台的设计与实现.docx

				
			

			

				

					09-13
				

			

		

		

			
				
基于java的电商平台的设计与实现.docx

			
		

	





	

		

			

				
					
基于java的大学生智能消费记账系统的设计与实现.docx

				
			

			

				

					09-13
				

			

		

		

			
				
基于java的大学生智能消费记账系统的设计与实现.docx

			
		

	





	

		

			

				
					
基于java的植物健康系统设计与实现.docx

					
最新发布

				
			

			

				

					09-13
				

			

		

		

			
				
基于java的植物健康系统设计与实现.docx

			
		

	





	

		

			

				
					
Redis集群搭建与扩展教程

				
			

			

				

					
				

			

		

		

			
				
"Redis集群教程"  在深入了解Redis集群之前，我们先理解一下集群的基本概念。集群是一种分布式系统架构，通过将多个独立的服务器节点连接在一起，形成一个整体，以提供高可用性、扩展性和容错性。Redis集群是Redis...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值