Redis 和数据库连接池

一、先来搞清楚两个问题：Redis 到底是什么，数据库连接池又是怎么一回事？

  1. Redis 是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

    Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

    Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。从盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

   2. 数据库连接池：

       数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

‍二、 redis_java操作‍

Jedis 客户端实现

Maven pom文件 加入依赖

<dependencies>  
  <dependency>  
    <groupId>redis.clients</groupId>  
    <artifactId>jedis</artifactId>  
    <version>2.1.0</version>  
  </dependency>  
    
  <dependency>  
    <groupId>junit</groupId>  
    <artifactId>junit</artifactId>  
    <version>4.8.2</version>  
    <scope>test</scope>  
  </dependency>  
</dependencies>

Jedis 简单使用

/* 
 * JedisTest.java 
 */  
package com.x.java2000_wl;  
  
import org.junit.Before;  
import org.junit.Test;  
  
import redis.clients.jedis.Jedis;  
  
/** 
 * jedis 简单使用 
 * @author http://blog.csdn.net/java2000_wl 
 * @version <b>1.0</b> 
 */  
public class JedisSimpleTest {  
  
    private Jedis jedis;  
      
    /** 
     * 初始化连接 
     * <br>------------------------------<br> 
     */  
    @Before  
    public void beforeClass() {  
        jedis = new Jedis("127.0.0.1");  
        jedis.auth("java2000_wl");  
    }  
      
    /** 
     * set 新增 
     * <br>------------------------------<br> 
     */  
    @Test  
    public void testSet() {  
        jedis.set("blog", "java2000_wl");  
    }  
      
    /** 
     *  获取 
     * <br>------------------------------<br> 
     */  
    @Test  
    public void testGet() {  
        System.out.println(jedis.get("blog"));  
    }  
      
    /** 
     * 修改key 
     * <br>------------------------------<br> 
     */  
    @Test  
    public void testRenameKey() {  
        jedis.rename("blog", "blog_new");  
    }  
      
    /** 
     * 按key删除 
     * <br>------------------------------<br> 
     */  
    @Test  
    public void testDel() {  
        jedis.del("blog_new");  
    }  
      
    /** 
     * 获取所有的key  
     * <br>------------------------------<br> 
     */  
    @Test  
    public void testKeys() {  
        System.out.println(jedis.keys("*"));  
    }  
}

使用commons-pool连接池

/* 
 * JedisPoolTest.java 
 */  
package com.x.java2000_wl;  
  
import java.util.ResourceBundle;  
  
import org.junit.Assert;  
import org.junit.BeforeClass;  
import org.junit.Test;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  
  
/** 
 * jedis Pool 操作 
 * @author http://blog.csdn.net/java2000_wl 
 * @version <b>1.0</b> 
 */  
public class JedisPoolTest {  
  
    private static JedisPool jedisPool;  
      
    /** 
     * initPoolConfig 
     * <br>------------------------------<br> 
     * @return 
     */  
    private static JedisPoolConfig initPoolConfig() {  
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();  
        // 控制一个pool最多有多少个可用的的jedis实例  
        jedisPoolConfig.setMaxActive(1000);   
        // 最大能够保持空闲状态的对象数  
        jedisPoolConfig.setMaxIdle(300);  
        // 超时时间  
        jedisPoolConfig.setMaxWait(1000);  
        // 在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；  
        jedisPoolConfig.setTestOnBorrow(true);   
        // 在还会给pool时，是否提前进行validate操作  
        jedisPoolConfig.setTestOnReturn(true);  
        return jedisPoolConfig;  
    }  
      
    /** 
     * 初始化jedis连接池 
     * <br>------------------------------<br> 
     */  
    @BeforeClass  
    public static void before() {  
        JedisPoolConfig jedisPoolConfig = initPoolConfig();    
        // 属性文件读取参数信息  
        ResourceBundle bundle = ResourceBundle.getBundle("redis_config");  
        String host = bundle.getString("redis.host");  
        int port = Integer.valueOf(bundle.getString("redis.port"));  
        int timeout = Integer.valueOf(bundle.getString("redis.timeout"));  
        String password = bundle.getString("redis.password");  
        // 构造连接池  
        jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);  
    }  
  
    @Test  
    public void testSet() {  
        Jedis jedis = null;   
        // 从池中获取一个jedis实例  
        try {  
            jedis = jedisPool.getResource();  
            jedis.set("blog_pool", "java2000_wl");  
        } catch (Exception e) {  
            // 销毁对象  
            jedisPool.returnBrokenResource(jedis);  
            Assert.fail(e.getMessage());  
        } finally {  
            // 还会到连接池  
            jedisPool.returnResource(jedis);  
        }  
    }         
      
    @Test  
    public void testGet() {  
        Jedis jedis = null;   
        try {  
            // 从池中获取一个jedis实例  
            jedis = jedisPool.getResource();  
            System.out.println(jedis.get("blog_pool"));  
        } catch (Exception e) {  
            // 销毁对象  
            jedisPool.returnBrokenResource(jedis);  
            Assert.fail(e.getMessage());  
        } finally {  
            // 还会到连接池  
            jedisPool.returnResource(jedis);  
        }  
    }  
}