[java学习点滴]jedis的简单使用

Posted 2020-08-20 iMhager的学习小站

环境：

　　idea、jedis 2.8.0、windows 7sp1

　　引入jar包：

      <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.0</version>
        </dependency>

 

封装简单类，可以用于分布式，引入了连接池

public final class JedisUtils {
    private static ShardedJedisPool shardedJedisPool;

    private JedisUtils() {
    }

    /**
     * 单例对象
     * @return
     */
    public static ShardedJedisPool instance() {
        if (shardedJedisPool != null) return shardedJedisPool;
        else {
            shardedJedisPool = getShardedJedisPool();
            return shardedJedisPool;
        }
    }

    /**
     *
     * @return
     */
    private static ShardedJedisPool getShardedJedisPool() {
        // 生成多机连接信息列表,一般情况下，应该从配置文件或者其他地方获取，比如ZooKeeper之类的
        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
        shards.add(new JedisShardInfo("127.0.0.1", 6039));
        shards.add(new JedisShardInfo("127.0.0.1", 6040));

        // 生成连接池配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(10);// 最大空闲连接数
        config.setMaxTotal(30); // 最大连接数
        config.setMaxWaitMillis(3 * 1000);// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        config.setTestWhileIdle(true); //
        config.setTestOnBorrow(false);// 在获取连接的时候检查有效性, 默认false,性能考虑，正式环境为false
        config.setTestOnReturn(false); // 性能考虑，正式环境为false

        // 在应用初始化的时候生成连接池
        return new ShardedJedisPool(config, shards);
    }

    /**
     * 应用关闭时，释放连接池资源
     * @param pool
     */
    public void poolDestroy(ShardedJedisPool pool) {
        pool.destroy();
    }
}

 

业务场景：

public class JedisTest {

    private final static Logger logger = LoggerFactory.getLogger(Loop.class);

    public JedisTest() {
    }

    /**
     * @param key
     * @return
     */
    public String getValue(String key) {
        // 在业务操作时，从连接池获取连接
        ShardedJedis client = JedisUtils.instance().getResource();
        try {
            String value = client.get(key);
            System.out.println(String.format("get指令执行结果:%s", value));
            return value;

        } catch (Exception e) {
            // TODO: handle exception
            logger.error(this.getClass().toString(), e.getMessage());
        } finally {
            // 业务操作完成，将连接返回给连接池
            if (null != client) {
                client.close();
            }
        } // end of try block

        return "";
    }

    /**
     * @param key
     * @param value
     * @return
     */
    public boolean setValue(String key, String value) {

        // 在业务操作时，从连接池获取连接
        ShardedJedis client = JedisUtils.instance().getResource();
        try {
            String result = client.set(key, value);
            System.out.println(String.format("set指令执行结果:%s", result));

            return true;

        } catch (Exception e) {
            logger.error(this.getClass().toString(), e.getMessage());
        } finally {
            // 业务操作完成，将连接返回给连接池
            if (null != client) {
                client.close();
            }
        } // end of try block

        return false;
    }

    /**
     * 根据key，清理缓存
     * @param key
     * @return
     */
    public boolean delKey(String key){
        // 在业务操作时，从连接池获取连接
        ShardedJedis client = JedisUtils.instance().getResource();
        try {
            Long result = client.del(key);
            System.out.println(String.format("del 指令执行结果:%s", result));

            return true;

        } catch (Exception e) {
            // TODO: handle exception
            logger.error(this.getClass().toString(), e.getMessage());
        } finally {
            // 业务操作完成，将连接返回给连接池
            if (null != client) {
                client.close();
            }
        } // end of try block

        return false;
    }

 

测试用例：

public class JedisTest {

    @Test
    public void jedis_setValue_Test() {
        com.hager.javalearning.lessions.lessionjedis.JedisTest jedisTest = new com.hager.javalearning.lessions.lessionjedis.JedisTest();

        boolean result = jedisTest.setValue("test.1125", "hello world.");

        Assert.assertTrue(result);

    }

    @Test
    public void jedis_getValue_Test() {
        com.hager.javalearning.lessions.lessionjedis.JedisTest jedisTest = new com.hager.javalearning.lessions.lessionjedis.JedisTest();

        String result = jedisTest.getValue("test.1125");
        String hopeResult = "hello world.";

        Assert.assertEquals(hopeResult, result);
    }

    @Test
    public void jedis_delKey_Test(){
        com.hager.javalearning.lessions.lessionjedis.JedisTest jedisTest = new com.hager.javalearning.lessions.lessionjedis.JedisTest();

        boolean result = jedisTest.delKey("test.1125");
        Assert.assertTrue(result);

        String cacheResult=jedisTest.getValue("test.1125");
        Assert.assertNull(cacheResult);
    }

 

=========

另外，最近也在学习java基础知识，把最近两天的能记得起来的，也记录一下吧：

1、基本类型与引用类型：

　　感觉基本类型就是类似于C#中的值类型，包括 byte,short,int,long,float，double，boolean,char字符类型 8种；

　　引用类型，类，接口，数组

                              ┏数值型━┳━整数型：byte short int long
              ┏基本数据类型━━┫       ┗━浮点型：float double
              ┃              ┣字符型：char                                          
       数据类型╋              ┗布尔型：boolean              
              ┃              ┏类（class）
              ┗引用数据类型━━╋接口（interface）
                             ┗数组（array）

2、继承，关键字extends:遵循 “两同两小一大”：（李刚的 java疯狂讲义笔记）

 　　两同：方法名、形参列表相同；

　　两小：子类方法返回值类型应比父类的返回值类型小或者相等；

　　一大，指的是子类的访问权限，比父类的的访问权限更大或者相等；（说的就是private，public，protected，这几个东东）

 

 

参考：

http://aofengblog.blog.163.com/blog/static/631702120147298317919/