Redis和Spring整合

Redis在这篇里就不做介绍了~以后系统的学学，然后整理写出来。

首先是环境的搭建

通过自己引包的方式，将redis和spring-redis的包引到自己的项目中，我项目中是通过pom引进的，如下(貌似版本都是写着篇博客时最新的)：

 <dependency>

    <groupId>org.springframework.data</groupId>

    <artifactId>spring-data-redis</artifactId>

    <version>1.8.1.RELEASE</version>

</dependency>

<dependency>

    <groupId>redis.clients</groupId>

    <artifactId>jedis</artifactId>

    <version>2.9.0</version>

    <type>jar</type>

    <scope>compile</scope>

</dependency>

通过pom的依赖可以看出来，我用的Jedis作为我的Cilent。

配置Spring的配置文件

现在spring-boot框架大火，但是目前，我还是为了项目的可读性，使用配置文件的方式进行配置。以后有机会学习一下注解的方式，在总结出来。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	   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">

	<!-- 引入参数文件 -->

	<bean id="propertyConfigurer"

		  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

		<property name="location">

			<value>classpath:init.properties</value>

		</property>

	</bean>

	<!-- 使用redis缓存 -->

	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">

		<property name="maxIdle" value="${redis.maxIdle}" />

		<property name="maxTotal" value="${redis.maxActive}" />

		<property name="maxWaitMillis" value="${redis.maxWait}" />

		<property name="testOnBorrow" value="true" />

	</bean>

	<bean id="jedis.shardInfo1" 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}" />

		<constructor-arg index="3" value="${redis.default.db}" />

		<property name="password" value="${redis.pass}"></property>

	</bean>

	<bean id="jedisPool" class="redis.clients.jedis.JedisPool">

		<constructor-arg index="0" ref="jedisPoolConfig"/>

		<constructor-arg index="1" value="${redis.host}"/>

		<constructor-arg index="2" value="${redis.port}" type="int"/>

		<constructor-arg index="3" value="${redis.timeout}" type="int"/>

		<constructor-arg index="4" value="${redis.pass}"/>

	</bean>

	<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">

		<constructor-arg index="0" ref="jedisPoolConfig" />

		<constructor-arg index="1">

			<list>

				<ref bean="jedis.shardInfo1" />

			</list>

		</constructor-arg>

	</bean>

</beans>

大家可以看见，我这个配置文件写的比较奇葩...

因为我一共写了两个pool的bean，由于目前项目redis还是单机版本，所以我只是使用JedisPool这个进行之后的操作。ShardedJedisPool这个适用于分布式redis缓存的连接，但是我有一天突然发现没有flushDB的方法，我一着急，就换做了JedisPool，以后加强学习，把更加适用的方法总结出来。

RedisDataSource

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.springframework.stereotype.Repository;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.ShardedJedis;

import redis.clients.jedis.ShardedJedisPool;

@Repository("jedisDS")

public class JedisDataSourceImpl implements JedisDataSource{

    private static final Logger LOGGER = LoggerFactory.getLogger(JedisDataSourceImpl.class);

    @Autowired

    private ShardedJedisPool shardedJedisPool;

    @Autowired

    private JedisPool jedisPool;

    @Override

    public ShardedJedis getShardedRedisClient() {

        ShardedJedis shardedJedis = null;

        try{

            shardedJedis = shardedJedisPool.getResource();

            //shardedJedisPool.

            return shardedJedis;

        }catch (Exception e){

            LOGGER.error("[JedisDS] getRedisClient error: "+e.getMessage());

            if(null!=shardedJedis){

                shardedJedis.close();

            }

            return null;

        }

    }

    @Override

    public Jedis getRedisClient() {

        Jedis jedis = null;

        try{

            jedis = jedisPool.getResource();

            return jedis;

        }catch (Exception e){

            if(null!=jedis){

                jedis.close();

            }

            LOGGER.error("[JedisDS] getJedisClient error: "+e.getMessage());

        }

        return null;

    }

    @Override

    public void returnResource(ShardedJedis shardedJedis) {

        shardedJedis.close();

    }

    @Override

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {

        shardedJedis.close();

    }

    @Override

    public void returnResource(Jedis jedis, boolean broken) {

        jedis.close();

    }

}

上面的代码写了两种JedisPool和ShardedJedisPool两种方式

RedisCilentTamplate

这里整理了一些简单的方法，可以直接调用,可以直接参考一下

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

import org.springframework.stereotype.Repository;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.ShardedJedis;

@Repository("redisClientTemplate")

public class RedisClientTemplate {

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

    @Autowired

    private JedisDataSource redisDataSource;

    public void disconnect() {

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        shardedJedis.disconnect();

    }

    /**

     * 设置单个值

     *

     * @param key

     * @param value

     * @return

     */

    public String set(String key, String value) {

        String result = null;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        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.getShardedRedisClient();

        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;

    }

    public Boolean exists(String key) {

        Boolean result = false;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.exists(key);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public String type(String key) {

        String result = null;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.type(key);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    /**

     * 在某段时间后失效

     *

     * @param key

     * @param seconds

     * @return

     */

    public Long expire(String key, int seconds) {

        Long result = null;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.expire(key, seconds);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    /**

     * 在某个时间点失效

     *

     * @param key

     * @param unixTime

     * @return

     */

    public Long expireAt(String key, long unixTime) {

        Long result = null;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.expireAt(key, unixTime);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public Long ttl(String key) {

        Long result = null;

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.ttl(key);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public boolean setbit(String key, long offset, boolean value) {

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        boolean result = false;

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.setbit(key, offset, value);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public boolean getbit(String key, long offset) {

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        boolean result = false;

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.getbit(key, offset);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public long setRange(String key, long offset, String value) {

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        long result = 0;

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.setrange(key, offset, value);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public String getRange(String key, long startOffset, long endOffset) {

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        String result = null;

        if (shardedJedis == null) {

            return result;

        }

        boolean broken = false;

        try {

            result = shardedJedis.getrange(key, startOffset, endOffset);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

        }

        return result;

    }

    public boolean del(String key){

        ShardedJedis shardedJedis = redisDataSource.getShardedRedisClient();

        boolean temp = false;

        if (shardedJedis == null) {

            return false;

        }

        boolean broken = false;

        try {

            shardedJedis.del(key);

            temp = true;

        } catch (Exception e) {

            log.error(e.getMessage(), e);

            temp = false;

            broken = true;

        } finally {

            redisDataSource.returnResource(shardedJedis, broken);

            return temp;

        }

    }

    public boolean fushAll(){

        boolean temp = false;

        Jedis jedis = redisDataSource.getRedisClient();

        boolean broken = false;

        try{

            jedis.flushDB();

            return true;

        }catch (Exception e){

            log.error(e.getMessage(), e);

            temp = false;

            broken = true;

        }finally {

            redisDataSource.returnResource(jedis, broken);

            return temp;

        }

    }

}