Redis的Java客户端jedis

redis使用jedis连接和操作redis

1 导入pom.xml依赖

		<!-- redis jar start -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.8.1</version>
		</dependency>
		<!-- redis jar end -->

2 配置spring-redis.xml文件配置

<aop:aspectj-autoproxy/>
<context:annotation-config />
<context:property-placeholder location="classpath:jedis.properties" ignore-unresolvable="true"/>
<bean id="jedisPoolConfig" class="com.antilost.redis.util.GenericObjectPoolConfigWrapper">
        <!--最大连接数-->
	<property name="maxTotal" value="${${redis.pool.maxActive}}" />
        <!--最大空闲连接数-->
	<property name="maxIdle" value="${${redis.pool.maxIdle}}" />
        <!--初始化连接数-->
	<property name="minIdle" value="${${redis.pool.minIdle}}"/>
        <!--最大等待时间-->
	<property name="maxWait" value="${${redis.pool.maxWait}}" />
        <!--对拿到的connection进行validateObject校验-->
	<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
        <!--在进行returnObject对返回的connection进行validateObject校验-->
	<property name="testOnReturn" value="${redis.pool.testOnReturn}" />
        <!--定时对线程池中空闲的链接进行validateObject校验-->
        <property name="testWhileIdle" value="true" />
</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 index="0" value="${redis.host}" />   
					<!-- 端口 -->
					<constructor-arg index="1" value="${redis.port}" />
					<!-- 超时时间--> 
					<constructor-arg index="2" value="${redis.timeout}" />  
					<!--密码--> 
					<property name="password" value="${redis.pass}" />   
				</bean>
			</list>
		</constructor-arg>
	</bean>

3 注入bean对象进行配置

/**
 *  定义接口
 */
public interface RedisDataSource {
    public abstract ShardedJedis getRedisClient();
    public void returnResource(ShardedJedis shardedJedis);
    public void returnResource(ShardedJedis shardedJedis,boolean broken);
}


/**
 *  实现接口 在类中注入ShardedJedisPool 对象拿到连接池对象
 */
@Repository("redisDataSource")
public class RedisDataSourceImpl implements RedisDataSource {

    private static final Logger log = LoggerFactory.getLogger(RedisDataSourceImpl.class);

    @Autowired
    private ShardedJedisPool    shardedJedisPool;
    /**
     * 获取客户端
     */
    @Override
    public ShardedJedis getRedisClient() {
        try {
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        } catch (Exception e) {
            log.error("getRedisClent error", e);
        }
        return null;
    }
    /**
     * 将资源返还给pool
     */
    @Override
    public void returnResource(ShardedJedis shardedJedis) {
    	shardedJedis.close();
        //shardedJedisPool.returnResource(shardedJedis);
    }
    /**
     * 出现异常后，将资源返还给pool （其实不需要第二个方法）
     */
    @Override
    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if (broken) {
        	shardedJedis.close();
        } else {
        	shardedJedis.close();
        }
    }
}

4 提供工具类（ 文件太长了 所以只有set，get需要可以找我）

@Repository("redisClientTemplate")
public class RedisClientTemplate {

    private static final Logger log = LoggerFactory.getLogger(RedisClientTemplate.class);

    @Autowired
    private RedisDataSource     redisDataSource;

    public void disconnect() {
        ShardedJedis shardedJedis = redisDataSource.getRedisClient();
        shardedJedis.disconnect();
    }

    /**
     * 设置单个值
     * 
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value) {
        String result = null;

        ShardedJedis shardedJedis = redisDataSource.getRedisClient();
        if (shardedJedis == null) {
            return result;
        }
        boolean broken = false;
        try {
            result = shardedJedis.set(key, value);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
        return result;
    }

    /**
     * 获取单个值
     * 
     * @param key
     * @return
     */
    public String get(String key) {
        String result = null;
        ShardedJedis shardedJedis = redisDataSource.getRedisClient();
        if (shardedJedis == null) {
            return result;
        }

        boolean broken = false;
        try {
            result = shardedJedis.get(key);

        } catch (Exception e) {
            log.error(e.getMessage(), e);
            broken = true;
        } finally {
            redisDataSource.returnResource(shardedJedis, broken);
        }
        return result;
    }

5 测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring.xml", "classpath:spring-mvc.xml" })
public class RedisClientTest {


    @Autowired
    private RedisClientTemplate redisClient;

    @Test
    public void testSet() {
        String returnStr = redisClient.set("redisClientTest", "hollow world");
        System.out.println(returnStr);
    }

    @Test
    public void testGet() {
        String redisReturnStr = redisClient.get("redisClientTest");
        System.out.println("获取到值 : " + redisReturnStr);
    }

}

运行testSet方法，控制台输出：

运行testGet方法，控制台输出：

测试完成没有问题

使用jedis的简单连接大概就是这样了