spring集成redis，集成redis集群

企业开发 2018-05-10 08:40:02 阅读次数: 0
1、通过spring-data-redis集成redis

pom.xml依赖包 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.chen</groupId>
	<artifactId>test_redis02</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<build />
	<properties>
		<spring.version>3.1.2.RELEASE</spring.version>
	</properties>

	<dependencies>
		<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
</dependency>
		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.8.1</version>
</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.7.1.RELEASE</version>
		</dependency>
	 	<dependency>
 	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
	<version>2.4.2</version>
</dependency> 
	</dependencies>
</project>


spring application-reids.xml配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
   	xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
    	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
    	">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
    	<property name="maxIdle" value="${redis.maxIdle}" />
    	<!-- <property name="maxActive" value="${redis.maxActive}" />
    	<property name="maxWait" value="${redis.maxWait}" />
    	<property name="testOnBorrow" value="${redis.testOnBorrow}" /> -->
    </bean>
    
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
        p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/> 
    
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
        <property name="connectionFactory"   ref="connectionFactory" />  
    </bean>       
    
</beans>


UserDaoImpl.java 

package com.chen.dao;

import java.io.Serializable;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import com.chen.pojo.User;
@Repository
public class UserDaoImpl implements UserDao {
	
	@Autowired
	private RedisTemplate<Serializable,Serializable> redisTemplate;

	public void saveUser(final User user) {
		redisTemplate.execute(new RedisCallback<Object>(){
			@Override
			public Object doInRedis(RedisConnection connection)
					throws DataAccessException {
				String str= "user.uid."+user.getId();
				byte[] key = redisTemplate.getStringSerializer().serialize(str);
				connection.set(key,redisTemplate.getStringSerializer().serialize(user.getName()));
				return null;
			}
		});
	}

	public User getUser(final long id) {
		return redisTemplate.execute(new RedisCallback<User>(){
			@Override
			public User doInRedis(RedisConnection connection) throws DataAccessException {
				byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
				if(connection.exists(key)) {
					byte[] value = connection.get(key);
					String name = redisTemplate.getStringSerializer().deserialize(value);
					User user = new User();
					user.setName(name);
					user.setId(id);
					return user;
				}
				return null;
			}
		});
	}

}


详情见附件test_spring_data_redis02.rar源码

2、通过jedis集成redis

spring applicationContext.xml配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
   	xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
    	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
    	">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    	<property name="maxIdle" value="${redis.maxIdle}" />
    	<!-- <property name="maxActive" value="${redis.maxActive}" />
    	<property name="maxWait" value="${redis.maxWait}" />
    	<property name="testOnBorrow" value="${redis.testOnBorrow}" /> -->
    </bean>
    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="singleton">
    	<constructor-arg index="0" ref="jedisPoolConfig" />
    	<constructor-arg index="1">
    		<list>
    			<bean class="redis.clients.jedis.JedisShardInfo">
    				<constructor-arg name="host" value="${redis.host}" />
    				<constructor-arg name="port" value="${redis.port}" />
    				<!-- <constructor-arg name="timeout" value="${redis.timeout}" /> -->
    			</bean>
    		</list>
    	</constructor-arg>
    </bean>
      
    
</beans>

RedisDataSourceImpl.java 
package com.chen.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Repository("redisDataSource")
public class RedisDataSourceImpl implements RedisDataSource {
	
	@Autowired
	private ShardedJedisPool shardedJedisPool;
	
	public ShardedJedis getRedisClient() {
		try{
			ShardedJedis shardJedis = shardedJedisPool.getResource();
			return shardJedis;
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}

	public void returnResource(ShardedJedis shardedJedis) {
		shardedJedisPool.returnResource(shardedJedis);
	}

	public void returnResource(ShardedJedis shardedJedis, boolean broken) {
		if(broken){
			shardedJedisPool.returnBrokenResource(shardedJedis);
		}else{
			shardedJedisPool.returnResource(shardedJedis);
		}
	}

}

RedisClientTemplate.java 
package com.chen.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.ShardedJedis;

@Repository("redisClientTemplate")
public class RedisClientTemplate {
	@Autowired
	private RedisDataSource redisDataSource;
	
	public void disconnect(){
		ShardedJedis shardedJedis = redisDataSource.getRedisClient();
		shardedJedis.disconnect();
	}
	
	public String set(String key,String val){
		String result = null ;
		ShardedJedis jedis = redisDataSource.getRedisClient();
		if(jedis ==null)return null;
		boolean broken = false;
		try{
			result = jedis.set(key, val);
		}catch(Exception e){
			e.printStackTrace();
			broken = true ;
		}finally{
			redisDataSource.returnResource(jedis,broken);
		}
		return result;
	}
	
	public String get(String key){
		String result = null;
		ShardedJedis jedis = redisDataSource.getRedisClient();
		if(jedis==null)return result;
		boolean broken = false;
		try{
			result = jedis.get(key);
		}catch(Exception e){
			e.printStackTrace();
			broken= true;
		}finally{
			redisDataSource.returnResource(jedis,broken);
		}
		return result;
	}
}


DemoTest.java 
package com.chen.demo;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.chen.redis.RedisClientTemplate;

public class DemoTest {
	private static ApplicationContext apx;
	static{
		apx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
	}
	
	@Test
	public void test1(){
		String key1 = "mykey1"; String val1 = "myvalue1";
		RedisClientTemplate template = (RedisClientTemplate) apx.getBean("redisClientTemplate");
		String result = template.set(key1, val1);
		System.out.println("result="+result);
	}
	
	@Test
	public void test2(){
		String key1 = "mykey1";
		RedisClientTemplate template = (RedisClientTemplate) apx.getBean("redisClientTemplate");
		String val1 = template.get(key1);
		System.out.println(val1);
	}
}


详情见test_spring_redis03.rar源码

3、通过jedis集成JedisCluster

spring applicationContext.xml配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
   	xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
    	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
    	">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean name="genericObjectPoolConfig" class="org.apache.commons.pool2.impl.GenericObjectPoolConfig">
    	<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
    	<property name="maxTotal" value="${redis.maxTotal}" />
    	<property name="minIdle" value="${redis.minIdle}" />
    	<property name="maxIdle" value="${redis.maxIdle}" />
    </bean>
    
    <bean id="jedisCluster" class="com.chen.redis.JedisClusterFactory">
    	<property name="addressConfig">
    		<value>classpath:connect-redis.properties</value>
    	</property>
    	<property name="addressKeyPrefix" value="address"></property>
    	<property name="timeout" value="${redis.timeout}" />
    	<property name="maxRedirections" value="${redis.maxRedirections}" />
    	<property name="genericObjectPoolConfig" ref="genericObjectPoolConfig"></property>
    </bean>
    
</beans>


集群服务器配置文件
connect-redis.properties 
address1=192.168.199.130:7001
address2=192.168.199.130:7002
address3=192.168.199.130:7003
address4=192.168.199.130:7004
address5=192.168.199.130:7005
address6=192.168.199.130:7006



JedisClusterFactory.java 
package com.chen.redis;
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;
	}

}



DemoTest.java 
package com.chen.demo;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import redis.clients.jedis.JedisCluster;

public class DemoTest {
	private static ApplicationContext apx;
	static{
		apx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
	}
	
	
	@Test
	public void test1(){
		JedisCluster jedisCluster = (JedisCluster) apx.getBean("jedisCluster");
		String key1="myname1";
		String key2="myname2";
		String key3="myname3";
		System.out.println(jedisCluster.get(key1));
		System.out.println(jedisCluster.get(key2));
		System.out.println(jedisCluster.get(key3));
		
	}
	
	@Test
	public void test2(){
		JedisCluster jedisCluster = (JedisCluster) apx.getBean("jedisCluster");
		String key1="mystring1"; String val1 = "myval1";
		String key2="mystring2"; String val2 = "myval2";
		String key3="mystring3"; String val3 = "myval3";
		System.out.println(jedisCluster.set(key1,val1));
		System.out.println(jedisCluster.set(key2,val2));
		System.out.println(jedisCluster.set(key3,val3));
		System.out.println("----------------------");
		System.out.println(jedisCluster.get(key1));
		System.out.println(jedisCluster.get(key2));
		System.out.println(jedisCluster.get(key3));
	}
}


详情见源码：test_spring_cluster_redis04.rar

猜你喜欢

转载自chentian114.iteye.com/blog/2292323
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022