Jedis与Spring的整合

港控/mmm° 2022-07-13 07:55 154阅读 0赞

1、spring的基本配置文件bean-base.xml，用于加载properties的配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    	xmlns:aop="http://www.springframework.org/schema/aop" 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-4.0.xsd
    	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
    
    	
    	
    	
    	
    	<bean
    		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    		
    		<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
    		
    		<property name="ignoreResourceNotFound" value="true" />
    		
    		<property name="locations">
    			<list>
    				<value>classpath:redis.properties</value>
    			</list>
    		</property>
    	</bean>
    
    
    </beans>

2、Spring和redis整合的配置文件，bean-redis.xml

3、redis相关的配置，redis.properties

redis.maxTotal=50
    redis.node1.host=192.168.2.111
    redis.node1.port=6379
    redis.node1.password=123456
    
    redis.node2.host=192.168.2.116
    redis.node2.port=6380
    redis.node2.password=123456

4、log4j日志的配置文件，log4j.properties

log4j.rootLogger=DEBUG,A1
    log4j.logger.org.clients = DEBUG
    
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c]-[%p] %m%n

5、用于操作Redis数据库，简单的封装

import org.springframework.beans.factory.annotation.Autowired;
    import redis.clients.jedis.ShardedJedis;
    import redis.clients.jedis.ShardedJedisPool;
    
    public class RedisServiceSimple {
    	@Autowired(required = false)
    	private ShardedJedisPool shardedJedisPool;
    
    	public String set(String key, String value) {
    		ShardedJedis shardedJedis = null;
    		try {
    			// 从连接池中获取到jedis分片对象
    			shardedJedis = shardedJedisPool.getResource();
    			return shardedJedis.set(key, value);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (null != shardedJedis) {
    				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
    				shardedJedis.close();
    			}
    		}
    		return null;
    	}
    
    	public String get(String key) {
    		ShardedJedis shardedJedis = null;
    		try {
    			// 从连接池中获取到jedis分片对象
    			shardedJedis = shardedJedisPool.getResource();
    			return shardedJedis.get(key);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (null != shardedJedis) {
    				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
    				shardedJedis.close();
    			}
    		}
    		return null;
    	}
    }

6、使用模板方法，回调函数的方式进行处理

6.1 定义接口，用于执行具体的方法逻辑

/**
     * 
     * @param <E>
     *            代表输入
     * @param <T>
     *            代表输出
     */
    public interface Function<E, T> {
    	public T callBack(E e);
    }

6.2 Redis工具类的封装，模板方法

// 封装通用逻辑
    	private <T> T execute(Function<ShardedJedis, T> fun) {
    		ShardedJedis shardedJedis = null;
    		try {
    			// 从连接池中获取到jedis分片对象
    			shardedJedis = shardedJedisPool.getResource();
    			return fun.callBack(shardedJedis);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (null != shardedJedis) {
    				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
    				shardedJedis.close();
    			}
    		}
    		return null;
    	}

6.3 Redis工具类封装的具体实现

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import redis.clients.jedis.ShardedJedis;
    import redis.clients.jedis.ShardedJedisPool;
    
    @Service
    public class RedisService {
    	@Autowired(required = false)
    	private ShardedJedisPool shardedJedisPool;
    
    	// 封装通用逻辑
    	private <T> T execute(Function<ShardedJedis, T> fun) {
    		ShardedJedis shardedJedis = null;
    		try {
    			// 从连接池中获取到jedis分片对象
    			shardedJedis = shardedJedisPool.getResource();
    			return fun.callBack(shardedJedis);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (null != shardedJedis) {
    				// 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态
    				shardedJedis.close();
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 执行set方法
    	 * 
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	public String set(final String key, final String value) {
    		return this.execute(new Function<ShardedJedis, String>() {
    			@Override
    			public String callBack(ShardedJedis shardedJedis) {
    				return shardedJedis.set(key, value);
    			}
    		});
    	}
    
    	/**
    	 * 执行set方法，并设置生存时间
    	 * 
    	 * @param key
    	 * @param value
    	 * @param seconds
    	 *            时间，单位是秒
    	 * @return
    	 */
    	public String set(final String key, final String value,
    			final Integer seconds) {
    		return this.execute(new Function<ShardedJedis, String>() {
    			@Override
    			public String callBack(ShardedJedis shardedJedis) {
    				String str = shardedJedis.set(key, value);
    				shardedJedis.expire(key, seconds);
    				return str;
    			}
    		});
    	}
    
    	/**
    	 * 执行get方法
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public String get(final String key) {
    		return this.execute(new Function<ShardedJedis, String>() {
    			@Override
    			public String callBack(ShardedJedis shardedJedis) {
    				return shardedJedis.get(key);
    			}
    		});
    	}
    
    	/**
    	 * 删除key
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public Long del(final String key) {
    		return this.execute(new Function<ShardedJedis, Long>() {
    			@Override
    			public Long callBack(ShardedJedis shardedJedis) {
    				return shardedJedis.del(key);
    			}
    		});
    	}
    
    	/**
    	 * 设置生存时间
    	 * 
    	 * @param key
    	 * @param seconds
    	 * @return
    	 */
    	public Long expire(final String key, final int seconds) {
    		return this.execute(new Function<ShardedJedis, Long>() {
    			@Override
    			public Long callBack(ShardedJedis shardedJedis) {
    				return shardedJedis.expire(key, seconds);
    			}
    		});
    	}
    
    }

7、测试

7.1 测试代码

public class RedisSpringTest {
    
    	@Test
    	public void test01() {
    		ApplicationContext context = new ClassPathXmlApplicationContext(
    				"classpath:spring/bean-*.xml");
    		RedisService redisService = context.getBean("redisService",
    				RedisService.class);
    		for (int i = 0; i < 100; i++) {
    			redisService.set("key" + i, "value" + i);
    		}
    		System.out.println(redisService.get("key10"));
    
    	}
    }

7.2 运行结果

![20161231210132561][]

8、[源码下载][Link 1]

[20161231210132561]: /images/20220713/c60731cd60ec40c8b9cb58ded23c9e9c.png
[Link 1]: http://pan.baidu.com/s/1gfkflqr