Jedis整合spring的使用

Jedis有两个对象用来连接redis

JedisPool和JedisCluster

JedisPool是用来连接单机版的jedis

JedisCluster是用来连接集群的

下面我们就来讲讲这两个对象的用法

前提准备

在使用这两个类的时候，我们需要先导入jedis包，

我这个是maven工程，所以我在pom文件中配置、

<!-- Redis客户端 -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
                       <version>2.7.2</version>

		</dependency>

首先我们先看看jedis不整合spring的使用

不整合spring

JedisPool的使用

和其他数据库一样，先连接，再操作，最后关闭。

JedisPool维护了一个连接池，所以我们每次使用完连接池的对象就要将其关闭，不然连接池没法回收。

具体步骤如下

1.创建一个连接池

2.从连接池中取jedis对象

3.使用jedis对象操作redis中的数据

4，关闭jedis

public void testJedisPool() throws Exception {
		//创建一个数据库连接池对象（单例），需要指定服务的ip和端口号
		JedisPool jedisPool = new JedisPool("192.168.2.100", 6379);
		//从连接池中获得连接
		Jedis jedis = jedisPool.getResource();
		//使用Jedis操作数据库（方法级别使用）
		String result = jedis.get("jedis-key");
		System.out.println(result);
		//一定要关闭Jedis连接
		jedis.close();
		//系统关闭前关闭连接池
		jedisPool.close();
	}

JedisCluster的使用

创建JedisCliuster对象的时候需要给他一组含有ip和端口号的对象HostAndPort

剩下的和JedisPool一样

1.创建一组含有HostAndPort

2.创建JedisCluster

3.使用jedisCluster对象直接操作数据库

4.关闭数据库

public void testJedisCluster() throws Exception {
		//创建一个JedisCluster对象，构造参数Set类型，集合中每个元素是HostAndPort类型
		Set<HostAndPort> nodes = new HashSet<>();
		//向集合中添加节点
		nodes.add(new HostAndPort("192.168.2.100", 7001));
		nodes.add(new HostAndPort("192.168.2.100", 7002));
		nodes.add(new HostAndPort("192.168.2.100", 7003));
		nodes.add(new HostAndPort("192.168.2.100", 7004));
		nodes.add(new HostAndPort("192.168.2.100", 7005));
		nodes.add(new HostAndPort("192.168.2.100", 7006));
		JedisCluster jedisCluster = new JedisCluster(nodes);
		//直接使用JedisCluster操作redis，自带连接池。jedisCluster对象可以是单例 的。
		jedisCluster.set("cluster-test", "hello jedis cluster");
		String string = jedisCluster.get("cluster-test");
		System.out.println(string);
		//系统关闭前关闭JedisCluster
		jedisCluster.close();
	}

自己封装一个同时适合单机版和集群版的工具类

由于在开发过程中我们常常使用单机版，而项目中真正运行的时候是需要使用集群版的，而这两个版本的使用方法还不相同，那么我们怎么才能让单机版和就集群版完美切换呢？

答案是，使用策略模式

什么是策略模式呢？

策略定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化

也就是说我们需要定义一个接口，让单机版和集群版的类来实现这个接口，使用者只需要依赖这个接口，调用接口里的方法就行。

下面我们来实现一下

接口

首先我们需要一个接口，里面包含jedis常使用的方法

package com.art.jedis;

public interface JedisClient {

	String set(String key, String value);
	String get(String key);
	Boolean exists(String key);
	Long expire(String key, int seconds);
	Long ttl(String key);
	Long incr(String key);
	Long hset(String key, String field, String value);
	String hget(String key, String field);
	Long hdel(String key, String... field);
}

然后我们需要让单机版和集群版来实现这个接口

实现类

单机版

package com.art.jedis;

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class JedisClientPool implements JedisClient {
	//创建JedisPool来操作单机版的数据库
	@Autowired
	private JedisPool jedisPool;

	@Override
	public String set(String key, String value) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.set(key, value);
		jedis.close();
		return result;
	}

	@Override
	public String get(String key) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.get(key);
		jedis.close();
		return result;
	}

	@Override
	public Boolean exists(String key) {
		Jedis jedis = jedisPool.getResource();
		Boolean result = jedis.exists(key);
		jedis.close();
		return result;
	}

	@Override
	public Long expire(String key, int seconds) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.expire(key, seconds);
		jedis.close();
		return result;
	}

	@Override
	public Long ttl(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.ttl(key);
		jedis.close();
		return result;
	}

	@Override
	public Long incr(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.incr(key);
		jedis.close();
		return result;
	}

	@Override
	public Long hset(String key, String field, String value) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hset(key, field, value);
		jedis.close();
		return result;
	}

	@Override
	public String hget(String key, String field) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.hget(key, field);
		jedis.close();
		return result;
	}

	@Override
	public Long hdel(String key, String... field) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hdel(key, field);
		jedis.close();
		return result;
	}

}

集群版

package com.art.jedis;

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

import redis.clients.jedis.JedisCluster;

public class JedisClientCluster implements JedisClient {
	//创建JedisCluster来创建集群版数据库
	@Autowired
	private JedisCluster jedisCluster;

	@Override
	public String set(String key, String value) {
		return jedisCluster.set(key, value);
	}

	@Override
	public String get(String key) {
		return jedisCluster.get(key);
	}

	@Override
	public Boolean exists(String key) {
		return jedisCluster.exists(key);
	}

	@Override
	public Long expire(String key, int seconds) {
		return jedisCluster.expire(key, seconds);
	}

	@Override
	public Long ttl(String key) {
		return jedisCluster.ttl(key);
	}

	@Override
	public Long incr(String key) {
		return jedisCluster.incr(key);
	}

	@Override
	public Long hset(String key, String field, String value) {
		return jedisCluster.hset(key, field, value);
	}

	@Override
	public String hget(String key, String field) {
		return jedisCluster.hget(key, field);
	}

	@Override
	public Long hdel(String key, String... field) {
		return jedisCluster.hdel(key, field);
	}

}

这样我们就创建完可以切换集群版和单机版的工具类了

下面我们来看看我们在开发时候怎么使用这个工具类

Jedis整合Spring

编写applicationContext-redis.xml文件

因为端口号我们有可能会改动，所以把他放到xml里方便后期维护

首先我们在applicationContext-redis.xml里创建四个bean,jedisClientCluster，JedisCluster，JedisPool，JedisClientPool

   <!-- 开启注解 -->
	<context:annotation-config/>
	<!-- redis单机版 -->
	<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="host" value="192.168.25.153"/>	
		<constructor-arg name="port" value="6379"/>	
	</bean>
	<bean id="jedisClientPool" class="com.taotao.jedis.JedisClientPool"/>
	<!-- redis集群 -->
	<!-- <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
		<constructor-arg>
			<set>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7001"/>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7002"/>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7003"/>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7004"/>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7005"/>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"/>
					<constructor-arg name="port" value="7006"/>
				</bean>
			</set>
		</constructor-arg>
	</bean>
	<bean id="jedisClientCluster" class="com.art.jedis.JedisClientCluster"/> -->

使用JedisClient进行测试

public void testJedisClientPool() throws Exception {
		//初始化spring容器
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-redis.xml");
		//从容器中获得JedisClient对象
		JedisClient jedisClient = applicationContext.getBean(JedisClient.class);
		//使用JedisClient对象操作redis
		jedisClient.set("jedisclient", "mytest");
		String result = jedisClient.get("jedisclient");
		System.out.println(result);
	}