Jedis的使用

转载自:http://blog.csdn.net/jesting1988/article/details/55803915


一:导入依赖

         <dependency>

               <groupId>Redis.clients</groupId>

               <artifactId>jedis</artifactId>

               <version>2.6.0</version>

         </dependency>

二:简单示例

public class JedisDemo{

        public static void main(String [ ] args){

             //创建jedis对象

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

            //向redis中添加数据

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

            //从redis中读取数据

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

           //关闭连接

           jedis.close();

        }

}

三:连接池的使用

public class JedisPoolDemo{

        public static void main(String [] args){

              //构建连接池配置信息

             JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();

             //设置最大连接数

             jedisPoolConfig.setMaxTotal(50);

            //从连接池中获取连接

            Jedis jedis=jedisPool.getResource();

            //从redis中读取数据

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

             //将连接还到连接池中

            jedisPool.returnResource(jedis);

            //释放连接池

            jedisPool.close();

        }

}

四:分片式集群的使用

1.1.1.  分片式集群的使用

publicclass ShardedJedisPoolDemo {

 

    publicstaticvoid main(String[]args) {

        // 构建连接池配置信息

        JedisPoolConfig poolConfig =new JedisPoolConfig();

        // 设置最大连接数

        poolConfig.setMaxTotal(50);

 

        // 定义集群信息

        List<JedisShardInfo> shards =newArrayList<JedisShardInfo>();

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

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

 

        // 定义集群连接池

        ShardedJedisPool shardedJedisPool =new ShardedJedisPool(poolConfig,shards);

        ShardedJedis shardedJedis =null;

        try {

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

            shardedJedis = shardedJedisPool.getResource();

           

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

//               shardedJedis.set("key_" + i, "value_" + i);

//           }

 

           System.out.println(shardedJedis.get("key_49"));

            System.out.println(shardedJedis.get("key_7"));

 

        catch (Exceptione) {

            e.printStackTrace();

        finally {

            if (null !=shardedJedis) {

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

               shardedJedis.close();

            }

        }

 

        // 关闭连接池

        shardedJedisPool.close();

 

    }

}

五:将jedis集成到项目中

(一)添加依赖

<dependency>

               <groupId>redis.clients</groupId>

               <artifactId>jedis</artifactId>

               <version>2.6.0</version>

         </dependency>

(二)spring和jedis的整合

<!—连接池的配置-->

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

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

         <propertyname=”maxTotal” value=”${redis.maxTotal}”/>

<!--分片式连接池-->

<bean class=”redis.clients.jedis.ShardedJedisPool”>

<constructor-argindex=”0” ref=”jedisPoolConfig”/>

         <constructor-argindex=”1”>

                   <list>

                            <beanclass=”redis.clients.jedis.JedisSharedInfo”>

                                     <constructor-argindex=”0” value=”${redis.node1.ip}”/>

                                     <constructor-argindex=”1” value=”${redis.node1.port}”/>

                            </bean>

                   </list>

         </constructor-arg>

</bean>

 (三)封装redisService

1.1.1.  封装RedisService

package com.taotao.manage.service;

 

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

import org.springframework.stereotype.Service;

 

import redis.clients.jedis.ShardedJedis;

import redis.clients.jedis.ShardedJedisPool;

 

@Service

publicclass RedisService {

 

    @Autowired

    private ShardedJedisPoolshardedJedisPool;

 

    /**

     执行set操作

     *

     @param key

     @param value

     @return

     */

    public String set(Stringkey, String value) {

        ShardedJedis shardedJedis =null;

        try {

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

            shardedJedis = shardedJedisPool.getResource();

            returnshardedJedis.set(key,value);

        finally {

            if (null !=shardedJedis) {

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

               shardedJedis.close();

            }

        }

    }

 

    /**

     执行get操作

     *

     @param key

     @return

     */

    public String get(Stringkey) {

        ShardedJedis shardedJedis =null;

        try {

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

            shardedJedis = shardedJedisPool.getResource();

            returnshardedJedis.get(key);

        finally {

            if (null !=shardedJedis) {

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

               shardedJedis.close();

            }

        }

    }

 

}

(四)优化redisservice

定义接口

public interface Function<T,E>{

      public T callback(E,e);

}

RedisService的实现:

 

package com.taotao.manage.service;

 

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

import org.springframework.stereotype.Service;

 

import redis.clients.jedis.ShardedJedis;

import redis.clients.jedis.ShardedJedisPool;

 

@Service

publicclass RedisService {

 

    @Autowired

    private ShardedJedisPoolshardedJedisPool;

 

    private <T> Texecute(Function<T, ShardedJedis>fun) {

        ShardedJedis shardedJedis =null;

        try {

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

            shardedJedis = shardedJedisPool.getResource();

            returnfun.callback(shardedJedis);

        finally {

            if (null !=shardedJedis) {

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

               shardedJedis.close();

            }

        }

    }

 

    /**

     执行set操作

     *

     @param key

     @param value

     @return

     */

    public String set(final String keyfinal Stringvalue) {

        returnthis.execute(new Function<String, ShardedJedis>() {

            @Override

            public String callback(ShardedJedise) {

               returne.set(key,value);

            }

        });

    }

 

    /**

     执行get操作

     *

     @param key

     @return

     */

    public String get(final String key) {

        returnthis.execute(new Function<String, ShardedJedis>() {

            @Override

            public String callback(ShardedJedise) {

               returne.get(key);

            }

        });

    }

 

    /**

     执行删除操作

     *

     @param key

     @return

     */

    public Long del(final String key) {

        returnthis.execute(new Function<Long, ShardedJedis>() {

            @Override

            public Long callback(ShardedJedise) {

               returne.del(key);

            }

        });

    }

 

    /**

     设置生存时间,单位为:秒

     *

     @param key

     @param seconds

     @return

     */

    public Long expire(final String keyfinal Integerseconds) {

        returnthis.execute(new Function<Long, ShardedJedis>() {

            @Override

            public Long callback(ShardedJedise) {

               returne.expire(key,seconds);

            }

        });

    }

 

    /**

     执行set操作并且设置生存时间,单位为:秒

     *

     @param key

     @param value

     @return

     */

    public String set(final String keyfinal Stringvaluefinal Integerseconds) {

        returnthis.execute(new Function<String, ShardedJedis>() {

            @Override

            public String callback(ShardedJedise) {

               String str = e.set(key,value);

               e.expire(key,seconds);

               returnstr;

            }

        });

    }

}

 

(五)实现缓存逻辑

1.先从缓存中命中,命中则返回

2.没有命中则把结果放入缓存中

public ItemCatResult queryItemCatList(){

      //从缓存中命中

       String key=“REDIS_KEY”;

       String cacheData=this.redisService.get(key);

       if(StringUtils.isNotEmpty(cacheData)){

            try{

             return MAPPER.readValue(cacheData,ItemCatResult.class);

            }cache(Exception e){

                  e.printStatckTrace();

            }

      }

     //如果没有命中,则从数据库中查找,并把结果写入缓存中

    try{

          //将结果集写入到缓存中

         this.redisService.set(REDIS_KEY,MAPPER.writerValueAsString(result),REDIS_TIME);

    }cache(Exception e){

       e,printStatckTrace();

     }

}


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值