Java Datasource介绍

Java 驱动的连接池提供给用户一个快速获取连接实例的途径。

连接池用法

使用类 SequoiadbDatasource 的 getConnection 方法从连接池中获取一个连接，使用 releaseConnection 方法把取出的连接放回连接池。当连接池使用的连接数到达连接上限时，下一个请求连接的操作将会等待一段时间（默认超时时间为5秒），若在规定的时间内无空闲的连接可用，将抛出异常。类 ConfigOptions 可以设置建立连接的各项参数。类 DatasourceOptions 可以设置连接池的各种参数。

注：所有使用连接池的客户机器都需要在本地配置服务端协调节点的主机名/IP地址映射关系。

详情请查看相关 Java API 介绍。

例子

  1. package com.sequoiadb.samples;
  3. import java.util.ArrayList;
  4. import org.bson.BSONObject;
  5. import org.bson.BasicBSONObject;
  6. import com.sequoiadb.base.CollectionSpace;
  7. import com.sequoiadb.base.DBCollection;
  8. import com.sequoiadb.base.DBCursor;
  9. import com.sequoiadb.base.Sequoiadb;
  10. import com.sequoiadb.base.SequoiadbDatasource;
  11. import com.sequoiadb.datasource.ConnectStrategy;
  12. import com.sequoiadb.datasource.DatasourceOptions;
  13. import com.sequoiadb.exception.BaseException;
  14. import com.sequoiadb.net.ConfigOptions;
  16. public class Datasource {
  17.     public static void main(String[] args) throws InterruptedException {
  18.         ArrayList<String> addrs = new ArrayList<String>();
  19.         String user = "";
  20.         String password = "";
  21.         ConfigOptions nwOpt = new ConfigOptions();
  22.         DatasourceOptions dsOpt = new DatasourceOptions();
  23.         SequoiadbDatasource ds = null;
  24.         // 提供coord节点地址  
  25.         addrs.add("192.168.20.165:11810");
  26.         addrs.add("192.168.20.166:11810");
  27.         addrs.add("ubuntu1504:11810");
  29.         // 设置网络参数
  30.         nwOpt.setConnectTimeout(500);                      // 建连超时时间为500ms。
  31.         nwOpt.setMaxAutoConnectRetryTime(0);               // 建连失败后重试时间为0ms。
  33.         // 设置连接池参数
  34.         dsOpt.setMaxCount(500);                            // 连接池最多能提供500个连接。
  35.         dsOpt.setDeltaIncCount(20);                        // 每次增加20个连接。
  36.         dsOpt.setMaxIdleCount(20);                         // 连接池空闲时，保留20个连接。
  37.         dsOpt.setKeepAliveTimeout(0);                      // 池中空闲连接存活时间。单位:毫秒。
  38.                                                            // 0表示不关心连接隔多长时间没有收发消息。
  39.         dsOpt.setCheckInterval(60 * 1000);                 // 每隔60秒将连接池中多于
  40.                                                            // MaxIdleCount限定的空闲连接关闭，
  41.                                                            // 并将存活时间过长（连接已停止收发
  42.                                                            // 超过keepAliveTimeout时间）的连接关闭。
  43.         dsOpt.setSyncCoordInterval(0);                     // 向catalog同步coord地址的周期。单位:毫秒。
  44.                                                            // 0表示不同步。
  45.         dsOpt.setValidateConnection(false);                // 连接出池时，是否检测连接的可用性，默认不检测。
  46.         dsOpt.setConnectStrategy(ConnectStrategy.BALANCE); // 默认使用coord地址负载均衡的策略获取连接。
  48.         // 建立连接池
  49.         ds = new SequoiadbDatasource(addrs, user, password, nwOpt, dsOpt);
  51.         // 使用连接池运行任务
  52.         runTask(ds);
  54.         // 任务结束后，关闭连接池
  55.         ds.close();
  56.     }
  58.     static void runTask(SequoiadbDatasource ds) throws InterruptedException {
  59.         String clFullName = "mycs.mycl";
  60.         // 准备任务
  61.         Thread createCLTask = new Thread(new CreateCLTask(ds, clFullName));
  62.         Thread insertTask = new Thread(new InsertTask(ds, clFullName));
  63.         Thread queryTask = new Thread(new QueryTask(ds, clFullName));
  65.         // 创建集合
  66.         createCLTask.start();
  67.         createCLTask.join();
  69.         // 往集合插记录
  70.         insertTask.start();
  71.         Thread.sleep(3000);
  73.         // 从集合中查记录
  74.         queryTask.start();
  76.         // 等待任务结束
  77.         insertTask.join();
  78.         queryTask.join();
  79.     }
  80. }
  82. class CreateCLTask implements Runnable {
  83.     private SequoiadbDatasource ds;
  84.     private String csName;
  85.     private String clName;
  87.     public CreateCLTask(SequoiadbDatasource ds, String clFullName) {
  88.         this.ds = ds;
  89.         this.csName = clFullName.split("\\.")[0];
  90.         this.clName = clFullName.split("\\.")[1];
  91.     }
  93.     @Override
  94.     public void run() {
  95.         Sequoiadb db = null;
  96.         CollectionSpace cs = null;
  97.         DBCollection cl = null;
  98.         // 从连接池获取连接池
  99.         try {
  100.             db = ds.getConnection();
  101.         } catch (BaseException e) {
  102.             e.printStackTrace();
  103.             System.exit(1);
  104.         } catch (InterruptedException e) {
  105.             e.printStackTrace();
  106.             System.exit(1);
  107.         }
  108.         // 使用连接创建集合
  109.         if (db.isCollectionSpaceExist(csName))
  110.             db.dropCollectionSpace(csName);
  111.         cs = db.createCollectionSpace(csName);
  112.         cl = cs.createCollection(clName);
  113.         // 将连接归还连接池
  114.         ds.releaseConnection(db);
  115.         System.out.println("Suceess to create collection " + csName + "." + clName);
  116.     }
  117. }
  119. class InsertTask implements Runnable {
  120.     private SequoiadbDatasource ds;
  121.     private String csName;
  122.     private String clName;
  124.     public InsertTask(SequoiadbDatasource ds, String clFullName) {
  125.         this.ds = ds;
  126.         this.csName = clFullName.split("\\.")[0];
  127.         this.clName = clFullName.split("\\.")[1];
  128.     }
  130.     @Override
  131.     public void run() {
  132.         Sequoiadb db = null;
  133.         CollectionSpace cs = null;
  134.         DBCollection cl = null;
  135.         BSONObject record = null;
  136.         // 从连接池获取连接
  137.         try {
  138.             db = ds.getConnection();
  139.         } catch (BaseException e) {
  140.             e.printStackTrace();
  141.             System.exit(1);
  142.         } catch (InterruptedException e) {
  143.             e.printStackTrace();
  144.             System.exit(1);
  145.         }
  147.         // 使用连接获取集合对象
  148.         cs = db.getCollectionSpace(csName);
  149.         cl = cs.getCollection(clName);
  150.         // 使用集合对象插入记录
  151.         record = genRecord();
  152.         cl.insert(record);
  153.         // 将连接归还连接池
  154.         ds.releaseConnection(db);
  155.         System.out.println("Suceess to insert record: " + record.toString());
  156.     }
  158.     private BSONObject genRecord() {
  159.         BSONObject obj = new BasicBSONObject();
  160.         obj.put("name", "James");
  161.         obj.put("age", 30);
  162.         return obj;
  163.     }
  164. }
  166. class QueryTask implements Runnable {
  167.     private SequoiadbDatasource ds;
  168.     private String csName;
  169.     private String clName;
  171.     public QueryTask(SequoiadbDatasource ds, String clFullName) {
  172.         this.ds = ds;
  173.         this.csName = clFullName.split("\\.")[0];
  174.         this.clName = clFullName.split("\\.")[1];
  175.     }
  177.     @Override
  178.     public void run() {
  179.         Sequoiadb db = null;
  180.         CollectionSpace cs = null;
  181.         DBCollection cl = null;
  182.         DBCursor cursor = null;
  183.         // 从连接池获取连接
  184.         try {
  185.             db = ds.getConnection();
  186.         } catch (BaseException e) {
  187.             e.printStackTrace();
  188.             System.exit(1);
  189.         } catch (InterruptedException e) {
  190.             e.printStackTrace();
  191.             System.exit(1);
  192.         }
  193.         // 使用连接获取集合对象
  194.         cs = db.getCollectionSpace(csName);
  195.         cl = cs.getCollection(clName);
  196.         // 使用集合对象查询
  197.         cursor = cl.query();
  198.         try {
  199.             while(cursor.hasNext()) {
  200.             System.out.println("The inserted record is: " + cursor.getNext())
  201.             }
  202.         } finally {
  203.            cursor.close();
  204.         }
  205.         // 将连接对象归还连接池
  206.         ds.releaseConnection(db);
  207.     }
  208. }