spring整合redis与接口封装

没整合前普通java程序：

导入jar包

无连接池创建链接

public class JedisDemo {

    public static void main(String[] args) {

        // 构造jedis对象

        Jedis jedis = new Jedis("127.0.0.1", 6380);

        // 向redis中添加数据

        jedis.set("mytest", "123");

        // 从redis中读取数据

        String value = jedis.get("mytest");

        System.out.println(value);

        // 关闭连接

        jedis.close();

   }

}

-----------------------------------------------------------------------

连接池中获取连接

public class JedisPoolDemo {

    public static void main(String[] args) {

        // 构建连接池配置信息

        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        // 设置最大连接数

        jedisPoolConfig.setMaxTotal(50);

        // 构建连接池

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6380);

        // 从连接池中获取连接

        Jedis jedis = jedisPool.getResource();

        // 读取数据

        System.out.println(jedis.get("mytest"));

        // 将连接还回到连接池中

        jedisPool.returnResource(jedis);

        // 释放连接池

        jedisPool.close();

    }

}

---------------------------------------------------------------

集群式的连接池

public class ShardedJedisPoolDemo {

    public static void main(String[] args) {

        // 构建连接池配置信息

        JedisPoolConfig poolConfig = new JedisPoolConfig();

        // 设置最大连接数

        poolConfig.setMaxTotal(50);

        // 定义集群信息

        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();

        shards.add(new JedisShardInfo("127.0.0.1", 6379));

        shards.add(new JedisShardInfo("127.0.0.1", 6380));

        // 定义集群连接池

        ShardedJedisPool shardedJedisPool = new ShardedJedisPool(poolConfig, shards);

        ShardedJedis shardedJedis = null;

        try {

            // 从连接池中获取到jedis分片对象

            shardedJedis = shardedJedisPool.getResource();

            // 从redis中获取数据

            for(int i =0 ;i< 100 ;i++){

                shardedJedis.set("key"+i, "value"+i);

            }

            System.out.println("OK");

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (null != shardedJedis) {

                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态

                shardedJedis.close();

            }

        }

        // 关闭连接池

        shardedJedisPool.close();

    }

}

--------------------------------------------------------------------------

spring整合redis

① 导入依赖

<!-- redis的java客户端 -->

<dependency>

        <groupId>redis.clients</groupId>

        <artifactId>jedis</artifactId>

</dependency>

②spring配置文件

<!-- 构建连接池配置信息 -->

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

        <!-- 设置最大连接数 -->

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

</bean>

<!-- 定义集群信息 -->

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

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

            <constructor-arg index="1">

                <list>

                        <bean class="redis.clients.jedis.JedisShardInfo">

                                <constructor-arg index="0" value="${redis.host1}"/>

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

                           </bean>

                </list>

        </constructor-arg>

</bean>

接口封装

①封装回调接口

public interface Function<E,T> {

    public T callback(E e);

}

②封装实现

@Service

public class RedisServiceImpl implements RedisService {

    //required=false在使用到才注入

    @Autowired(required=false)

    private ShardedJedisPool shardedJedisPool;       

    public <T> T excute(Function<ShardedJedis, T> fun){

        ShardedJedis shardedJedis = null;

        try {

            // 从连接池中获取到jedis分片对象

            shardedJedis = shardedJedisPool.getResource();

            // 从redis中设置key数据

           return fun.callback(shardedJedis);      

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (null != shardedJedis) {

                // 关闭，检测连接是否有效，有效则放回到连接池中，无效则重置状态

                shardedJedis.close();

            }

        }

        return null;

    } 

    @Override

    public String set(final String key,final String value) {

       return this.excute(new Function<ShardedJedis, String>() {

        @Override

        public String callback(ShardedJedis e) {

            return e.set(key, value);

        }

    });

    } 

    @Override

    public String get(final String key) {

        return this.excute(new Function<ShardedJedis, String>() {

 

            @Override

            public String callback(ShardedJedis e) {

                return e.get(key);

            }

        });

    } 

    @Override

    public Long del(final String key) {

        

        return this.excute(new Function<ShardedJedis, Long>() {

 

            @Override

            public Long callback(ShardedJedis e) {

                return e.del(key);

            }

        });

    }

    @Override

    public Long expire(final String key,final Integer seconds) {

        return this.excute(new Function<ShardedJedis, Long>() {

            @Override

            public Long callback(ShardedJedis e) {

                return e.expire(key, seconds);

            }

        });

    }

    @Override

    public Long expire(final String key, final String value, final Integer seconds) {

        return this.excute(new Function<ShardedJedis, Long>() {

            @Override

            public Long callback(ShardedJedis e) {

                e.set(key, value);

                return e.expire(key, seconds);

            }

        });

    }

}

------------------------------------------------------------