spring集成redis（xml的方式）

最新推荐文章于 2023-05-26 13:14:12 发布
最新推荐文章于 2023-05-26 13:14:12 发布
阅读量340 收藏 1
点赞数
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22041375/article/details/99762466
版权

spring配置redis

<!-- 集群版的配置 -->  
    <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">  
        <constructor-arg>  
            <set>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7001"></constructor-arg>  
                </bean>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7002"></constructor-arg>  
                </bean>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7003"></constructor-arg>  
                </bean>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7004"></constructor-arg>  
                </bean>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7005"></constructor-arg>  
                </bean>  
                <bean class="redis.clients.jedis.HostAndPort">  
                    <constructor-arg name="host" value="127.0.0.1"></constructor-arg>  
                    <constructor-arg name="port" value="7006"></constructor-arg>  
                </bean>  
            </set>  
        </constructor-arg>  
    </bean>  
    <bean id="jedisClientCluster" class="com.demo.jedis.JedisClientCluster"/>

JedisClusterClient


/**
 * 集群方式redis客户端操作
 * @author jimmywu
 *
 */
@Service
public class JedisClusterClient implements IJedisClient {
 
	private   Logger logger = LoggerFactory.getLogger(JedisClusterClient.class);
	
 
	@Autowired
	private  JedisCluster jedisCluster ;
//	public   final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#get(java.lang.String)
	 */
	
	@Override
	public  String get(String key) {
		String value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.get(key);
				value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
				logger.debug("get {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("get {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getObject(java.lang.String)
	 */
	@Override
	public   Object getObject(String key) {
		Object value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = toObject(jedisCluster.get(getBytesKey(key)));
				logger.debug("getObject {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObject {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
//			try {
//				jedisCluster.close();
//			} catch (IOException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#set(java.lang.String, java.lang.String, int)
	 */
	@Override
	public   String set(String key, String value, int cacheSeconds) {
		String result = null;
	
		try {
		
			result = jedisCluster.set(key, value);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("set {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("set {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setObject(java.lang.String, java.lang.Object, int)
	 */
	@Override
	public   String setObject(String key, Object value, int cacheSeconds) {
		String result = null;
		
		try {
			result = jedisCluster.set(getBytesKey(key), toBytes(value));
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObject {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObject {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getList(java.lang.String)
	 */
	@Override
	public   List<String> getList(String key) {
		List<String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.lrange(key, 0, -1);
				logger.debug("getList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getObjectList(java.lang.String)
	 */
	@Override
	public   List<Object> getObjectList(String key) {
		List<Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				List<byte[]> list = jedisCluster.lrange(getBytesKey(key), 0, -1);
				value = Lists.newArrayList();
				for (byte[] bs : list){
					value.add(toObject(bs));
				}
				logger.debug("getObjectList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setList(java.lang.String, java.util.List, int)
	 */
	@Override
	public   long setList(String key, List<String> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.rpush(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setObjectList(java.lang.String, java.util.List, int)
	 */
	@Override
	public   long setObjectList(String key, List<Object> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])list.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectList {} = {}", key, value, e);
		} finally {
			//returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#listAdd(java.lang.String, java.lang.String)
	 */
	@Override
	public   long listAdd(String key, String... value) {
		long result = 0;
		try {
			result = jedisCluster.rpush(key, value);
			logger.debug("listAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listAdd {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#listObjectAdd(java.lang.String, java.lang.Object)
	 */
	@Override
	public   long listObjectAdd(String key, Object... value) {
		long result = 0;
		try {
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])list.toArray());
			logger.debug("listObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listObjectAdd {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
 
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getSet(java.lang.String)
	 */
	@Override
	public   Set<String> getSet(String key) {
		Set<String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.smembers(key);
				logger.debug("getSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getSet {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getObjectSet(java.lang.String)
	 */
	@Override
	public   Set<Object> getObjectSet(String key) {
		Set<Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = Sets.newHashSet();
				Set<byte[]> set = jedisCluster.smembers(getBytesKey(key));
				for (byte[] bs : set){
					value.add(toObject(bs));
				}
				logger.debug("getObjectSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectSet {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setSet(java.lang.String, java.util.Set, int)
	 */
	@Override
	public   long setSet(String key, Set<String> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.sadd(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSet {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setObjectSet(java.lang.String, java.util.Set, int)
	 */
	@Override
	public   long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedisCluster.sadd(getBytesKey(key), (byte[][])set.toArray());
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectSet {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setSetAdd(java.lang.String, java.lang.String)
	 */
	@Override
	public   long setSetAdd(String key, String... value) {
		long result = 0;
		try {
			result = jedisCluster.sadd(key, value);
			logger.debug("setSetAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetAdd {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
 
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setSetObjectAdd(java.lang.String, java.lang.Object)
	 */
	@Override
	public   long setSetObjectAdd(String key, Object... value) {
		long result = 0;
		try {
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedisCluster.rpush(getBytesKey(key), (byte[][])set.toArray());
			logger.debug("setSetObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetObjectAdd {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getMap(java.lang.String)
	 */
	@Override
	public   Map<String, String> getMap(String key) {
		Map<String, String> value = null;
		try {
			if (jedisCluster.exists(key)) {
				value = jedisCluster.hgetAll(key);
				logger.debug("getMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getMap {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#getObjectMap(java.lang.String)
	 */
	@Override
	public   Map<String, Object> getObjectMap(String key) {
		Map<String, Object> value = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				value = Maps.newHashMap();
				Map<byte[], byte[]> map = jedisCluster.hgetAll(getBytesKey(key));
				for (Map.Entry<byte[], byte[]> e : map.entrySet()){
					value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
				}
				logger.debug("getObjectMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectMap {} = {}", key, value, e);
		} finally {
		}
		return value;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setMap(java.lang.String, java.util.Map, int)
	 */
	@Override
	public   String setMap(String key, Map<String, String> value, int cacheSeconds) {
		String result = null;
		try {
			if (jedisCluster.exists(key)) {
				jedisCluster.del(key);
			}
			result = jedisCluster.hmset(key, value);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setMap {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#setObjectMap(java.lang.String, java.util.Map, int)
	 */
	@Override
	public   String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
		String result = null;
		try {
			if (jedisCluster.exists(getBytesKey(key))) {
				jedisCluster.del(key);
			}
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedisCluster.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			if (cacheSeconds != 0) {
				jedisCluster.expire(key, cacheSeconds);
			}
			logger.debug("setObjectMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectMap {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapPut(java.lang.String, java.util.Map)
	 */
	@Override
	public   String mapPut(String key, Map<String, String> value) {
		String result = null;
		try {
			result = jedisCluster.hmset(key, value);
			logger.debug("mapPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapPut {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapObjectPut(java.lang.String, java.util.Map)
	 */
	@Override
	public   String mapObjectPut(String key, Map<String, Object> value) {
		String result = null;
		try {
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedisCluster.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			logger.debug("mapObjectPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapObjectPut {} = {}", key, value, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapRemove(java.lang.String, java.lang.String)
	 */
	@Override
	public   long mapRemove(String key, String mapKey) {
		long result = 0;
		try {
			result = jedisCluster.hdel(key, mapKey);
			logger.debug("mapRemove {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapRemove {}  {}", key, mapKey, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapObjectRemove(java.lang.String, java.lang.String)
	 */
	@Override
	public   long mapObjectRemove(String key, String mapKey) {
		long result = 0;
		try {
			result = jedisCluster.hdel(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectRemove {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectRemove {}  {}", key, mapKey, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapExists(java.lang.String, java.lang.String)
	 */
	@Override
	public   boolean mapExists(String key, String mapKey) {
		boolean result = false;
		try {
			result = jedisCluster.hexists(key, mapKey);
			logger.debug("mapExists {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapExists {}  {}", key, mapKey, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#mapObjectExists(java.lang.String, java.lang.String)
	 */
	@Override
	public   boolean mapObjectExists(String key, String mapKey) {
		boolean result = false;
		try {
			result = jedisCluster.hexists(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectExists {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectExists {}  {}", key, mapKey, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#del(java.lang.String)
	 */
	@Override
	public   long del(String key) {
		long result = 0;
		try {
			if (jedisCluster.exists(key)){
				result = jedisCluster.del(key);
				logger.debug("del {}", key);
			}else{
				logger.debug("del {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("del {}", key, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
 
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#delObject(java.lang.String)
	 */
	@Override
	public   long delObject(String key) {
		long result = 0;
		try {
			if (jedisCluster.exists(getBytesKey(key))){
				result = jedisCluster.del(getBytesKey(key));
				logger.debug("delObject {}", key);
			}else{
				logger.debug("delObject {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("delObject {}", key, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#exists(java.lang.String)
	 */
	@Override
	public   boolean exists(String key) {
		boolean result = false;
		try {
			result = jedisCluster.exists(key);
			logger.debug("exists {}", key);
		} catch (Exception e) {
			logger.warn("exists {}", key, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
	
	/* (non-Javadoc)
	 * @see com.jeeplus.common.redis.IJedisClient#existsObject(java.lang.String)
	 */
	@Override
	public   boolean existsObject(String key) {
		boolean result = false;
		try {
			result = jedisCluster.exists(getBytesKey(key));
			logger.debug("existsObject {}", key);
		} catch (Exception e) {
			logger.warn("existsObject {}", key, e);
		} finally {
//			returnResource(jedis);
		}
		return result;
	}
 
	
	/**
	 * 获取byte[]类型Key
	 * @param key
	 * @return
	 */
	public static  byte[] getBytesKey(Object object){
		if(object instanceof String){
    		return StringUtils.getBytes((String)object);
    	}else{
    		return ObjectUtils.serialize(object);
    	}
	}
	
	/**
	 * Object转换byte[]类型
	 * @param key
	 * @return
	 */
	public static  byte[] toBytes(Object object){
    	return ObjectUtils.serialize(object);
	}
 
	/**
	 * byte[]型转换Object
	 * @param key
	 * @return
	 */
	public static Object toObject(byte[] bytes){
		return ObjectUtils.unserialize(bytes);
	}
 	}

StringUtils ObjectUtils

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

  /**
   * 反序列化对象
   * @param bytes
   * @return 
   */
  public static Object unserialize(byte[] bytes) {
    ByteArrayInputStream bais = null;
    try {
      if (bytes != null && bytes.length > 0){
        bais = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bais);
        return ois.readObject();
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return null;
  }

jimmywu911
jimmywu911
2楼 2016/12/18 22:35
/**
* 转换为字节数组
* @param str
* @return 
*/
public static String toString(byte[] bytes){
  try {
      return new String(bytes, CHARSET_NAME);
    } catch (UnsupportedEncodingException e) {
      return EMPTY;
    }
}

/**
* 转换为字节数组
* @param str
* @return 
*/
public static byte[] getBytes(String str){
  if (str != null){
    try {
        return str.getBytes(CHARSET_NAME);
      } catch (UnsupportedEncodingException e) {
        return null;
      }
  }else{
    return null;
  }
}

参考文章：使用jedis连接单机和集群redis的两种方式

java项目中配置redis-cluster集群的两种方式

方方园园
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-redis.xml配置文件
weixin_46138891的博客
01-03 2015
redis-config.properties redis.host=192.168.106.102 redis.port=6379 redis.pass=root redis.database=0 redis.maxIdle=300 redis.maxWait=3000 redis.testOnBorrow=true spring-redis.xml（配置） <?xml version="...
Spring整合Redis入门详解及基础练习
杨大仙
11-17 1037
Spring整合Redis入门详解及基础练习。 Redis因其性能比较高，所以经常在项目中用于缓存数据，因此将Redis和Spring以及项目进行整合。
spring-redis.xml
最帅程序猿的博客
12-14 462
<?xml version="1.0" encoding="UTF-8"?> <!-- redis sentinel 配置 客户端Redis--> <bean id="redisSentinelForClient" class="org.springframework.data.redis.connection.RedisSentinelC...
Spring通过xml集成Redis数据库
LAOSAN41的博客
04-02 1069
Spring通过xml集成Redis数据库 前台list的属性由于数据量较大，而且在后台是递归获取的，所以前端展示的页面就比较慢，所以想集成一下redis，加快数据的查询。 Spring集成Redis的主流方式大致有以下两种（以单机为例） 基于xml集成Redis 基于注解实现Redis 今天我们讲讲利用xml集成Redis数据库 导入相关依赖 <dependency> <groupId>redis.clients</groupId> &l
spring-redis.xml文件配置
m0_71837135的博客
05-26 438
spring-redis.xml文件配置
分布式架构中使用redis缓存实现session共享
Dark_AK44的博客
03-05 1014
dubbo分布式实现session共享
Spring集成Redis详解代码示例
08-28
Spring集成Redis详解代码示例 本文主要讲解了Spring集成Redis的详细代码示例，包括Eclipse工程结构、POM依赖、Spring配置、Redis配置信息和Java代码等相关内容。 一、Eclipse工程结构 Eclipse工程结构如下图所示，...
spring 集成redis
03-14
以上就是Spring集成Redis的基本流程。通过这个集成，你可以充分利用Redis的高性能特性，提高应用程序的响应速度和处理能力。同时，Spring Data Redis提供的高级功能，如事务支持、Key的过期策略、lua脚本执行等，都...
spring集成redis
06-26
本文将详细介绍如何在Spring项目中集成Redis，并通过提供的压缩包文件进行快速集成。 首先，我们来了解**Redis配置**。在Spring项目中，我们需要在`application.properties`或`application.yml`文件中添加Redis的...
spring集成redis的使用demo
05-28
本教程将探讨如何在Spring MVC项目中集成Redis，实现数据的存储和删除操作。 首先，我们要在项目中添加Redis的相关依赖。在`pom.xml`文件中，我们需要引入Spring Data Redis和Jedis库，如下所示： ```xml ...
spring boot 集成redis代码
最新发布
10-26
在本文中，我们将深入探讨如何在Spring Boot应用中集成Redis，以便利用其高效的数据存储和检索功能。Redis是一个开源的、内存数据结构存储系统，它可以用作数据库、缓存和消息代理。Spring Boot是Spring框架的一个轻...
19、Spring-redis.xml
u010724583的专栏
06-03 2132
http://www.springframework.org/schema/beans"        xmlns:util="http://www.springframework.org/schema/util"        xmlns:aop="http://www.springframework.org/schema/aop"        xmlns:xsi="http
springmvc集成Redis Cluster集群
最初的节奏
12-22 2234
springmvc集成Redis Cluster集群 点关注不迷路，欢迎再访！ 目录springmvc集成Redis Cluster集群引入依赖配置redis.properties配置redis.xml文件 cluster相对于哨兵模式是去中心化的，它的每个节点都存储了其它集群的信息，因此每个节点都可以做为集群的中心，容错能力强，具有更高的可用性和在线扩容能力。 引入依赖 <de...
分布式缓存技术redis学习系列（七）——spring整合jediscluster
热门推荐
javaloveiphone的专栏
11-16 1万+
1、maven依赖<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.7.2</version> </dependency>2、spring配置JedisCluster<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="
Redis集群：使用Spring和jedisCluster操作Redis集群
琦彦
12-13 6433
  jedisCluster   非Spring和jedisCluster操作Redis集群 jar包 &lt;!-- 指定版本号 --&gt; &lt;properties&gt; &lt;!-- JEDIS --&gt; &lt;jedis.version&gt;2.7.1&lt;/jedis.version&gt; &lt;/properties&gt; &lt;...
SpringMVC集成redis cluster集群模式
小赵的博客
01-05 1802
（亲测有效）SpringMVC集成redis cluster 集群模式
Java Spring代码方式和XML配置文件方式配置Redis
偉ing的博客
03-17 1978
1、pom.xml配置 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>org.springframework.data</group
spring 5.x 系列第7篇 —— 整合Redis客户端 Jedis和Redisson (xml配置方式)
很多时候犯错都是在不知情的情况下发生的
08-16 1172
版权声明：本文为博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/m0_37809146/article/details/86678847 文章目录 一、说明 1.1 Redis 客户端说明 1.2 Redis可视化软件 1.3 项目结构说明 1.3 依赖说明 二、spring 整合 jedis 2.1 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值