测试连接Sequoiadb

2022-03-17 18:24:35

Java代码  测试连接Sequoiadb
  1. package com.iminido.nosql;  
  2.   
  3. import com.sequoiadb.base.CollectionSpace;  
  4. import com.sequoiadb.base.DBCollection;  
  5. import com.sequoiadb.base.DBCursor;  
  6. import com.sequoiadb.base.Sequoiadb;  
  7. import com.sequoiadb.base.SequoiadbDatasource;  
  8. import com.sequoiadb.base.SequoiadbOption;  
  9. import com.sequoiadb.exception.BaseException;  
  10. import com.sequoiadb.net.ConfigOptions;  
  11. import ist.Const;  
  12. import java.util.ArrayList;  
  13. import java.util.HashMap;  
  14. import java.util.List;  
  15. import java.util.Map;  
  16. import java.util.concurrent.Semaphore;  
  17. import java.util.function.BiConsumer;  
  18. import java.util.logging.Level;  
  19. import java.util.logging.Logger;  
  20. import org.apache.logging.log4j.LogManager;  
  21. import org.bson.BSONObject;  
  22. import org.bson.BasicBSONObject;  
  23. import org.bson.util.JSON;  
  24. import org.json.JSONObject;  
  25.   
  26. /** 
  27.  * @author Jade 
  28.  */  
  29. public class Squ {  
  30.   
  31.     private static SequoiadbDatasource sequoiadbDatasource;  
  32.     protected static final org.apache.logging.log4j.Logger log = LogManager.getLogger(Squ.class);  
  33.     private static Semaphore semaphore = new Semaphore(1);  
  34.     private static Map<String, Sequoiadb> dbs = new HashMap<String, Sequoiadb>();  
  35.   
  36.     public static void main(String[] args) {  
  37. //  
  38.         String connString = Const.SEQUOIADB_HOST + ":" + Const.SEQUOIADB_PORT;  
  39.         try {  
  40.             // 建立 SequoiaDB 数据库连接  
  41.             Sequoiadb sdb = new Sequoiadb(connString, "", "");  
  42.             // 获取所有 Collection 信息，并打印出来  
  43.             DBCursor cursor = sdb.listCollectionSpaces();  
  44.             while (cursor.hasNext()) {  
  45.                 System.out.println(cursor.getCurrent());  
  46.             }  
  47.         } catch (BaseException e) {  
  48.             System.out.println("Sequoiadb driver error, error description:" + e.getErrorType());  
  49.         }  
  50.   
  51. //        initSequoiadbDatasource();  
  52. //        getSequoiadb();  
  53. //        BSONObject dbo = new BasicBSONObject(); //添加异常处理   
  54. //        dbo.put("key_a", "value_a");  
  55. //        dbo.put("key_b", "value_b");  
  56. //  
  57. //        DBCollection dBCollection = initCollection("test");  
  58. //        dBCollection.save(dbo);  
  59. //        DBCursor dbc = dBCollection.query();  
  60. //        while (dbc.hasNext()) {  
  61. //            System.out.println("" + dbc.getNext().toString());  
  62. //        }  
  63. //        sequoiadbDatasource.close(dBCollection.getSequoiadb());  
  64.     }  
  65.   
  66.     static {  
  67.   
  68.     }  
  69.   
  70.     private static void initSequoiadbDatasource() {  
  71.         ArrayList<String> urls = new ArrayList<>();  
  72.         ConfigOptions nwOpt = new ConfigOptions();          // 定义连接选项  
  73.         SequoiadbOption dsOpt = new SequoiadbOption();      // 定义连接池选项  
  74.   
  75.         urls.add(Const.SEQUOIADB_HOST + ":" + Const.SEQUOIADB_PORT);//  
  76. //        urls.add("ubuntu-dev2:11810");  
  77. //        urls.add("ubuntu-dev3:11810");  
  78.   
  79.         nwOpt.setConnectTimeout(500);                       // 设置若连接失败，超时时间（ms）  
  80.         nwOpt.setMaxAutoConnectRetryTime(0);                // 设置若连接失败，重试次数  
  81.   
  82.         // 以下设置的都是 SequoiadbOption 的默认值  
  83.         dsOpt.setMaxConnectionNum(500);                     // 设置连接池最大连接数  
  84.         dsOpt.setInitConnectionNum(10);                     // 初始化连接池时，创建连接的数量  
  85.         dsOpt.setDeltaIncCount(10);                        // 当池中没有可用连接时，增加连接的数量  
  86.         dsOpt.setMaxIdeNum(10);                             // 周期清理多余的空闲连接时，应保留连接的数量  
  87.         dsOpt.setTimeout(5 * 1000);                         // 当已使用的连接数到达设置的最大连接数时（500），请求连接的等待时间。  
  88.         dsOpt.setAbandonTime(10 * 60 * 1000);               // 连接存活时间，当连接空闲时间超过连接存活时间，将被连接池丢弃  
  89.         dsOpt.setRecheckCyclePeriod(1 * 60 * 1000);         // 清除多余空闲连接的周期  
  90.         dsOpt.setRecaptureConnPeriod(10 * 60 * 1000);       // 检测并取回异常地址的周期  
  91.   
  92.         sequoiadbDatasource = new SequoiadbDatasource(urls, Const.SEQUOIADB_USERNAME, Const.SEQUOIADB_PASSWORD, nwOpt, dsOpt); // 创建连接池  
  93.     }  
  94.   
  95.     private static synchronized Sequoiadb getSequoiadb() {  
  96.         return getSequoiadb("zy");  
  97.     }  
  98.   
  99.     private static synchronized Sequoiadb getSequoiadb(String dbName) {  
  100. //        Sequoiadb sdb = dbs.get(dbName);  
  101.         Sequoiadb sdb = null;  
  102.         try {  
  103.             sdb = sequoiadbDatasource.getConnection();  
  104.         } catch (BaseException | InterruptedException ex) {  
  105.             Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  106.         }  
  107.   
  108. //        while (sdb == null) {  
  109. //            try {  
  110. //                semaphore.tryAcquire(1, 2, TimeUnit.SECONDS);  
  111. //            } catch (InterruptedException ex) {  
  112. //                Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  113. //            }  
  114. //            try {  
  115. //                sdb = sequoiadbDatasource.getConnection();  
  116. //            } catch (BaseException | InterruptedException ex) {  
  117. //                Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  118. //            }  
  119. //        }  
  120. //        dbs.put(dbName, sdb);  
  121.         semaphore.release();  
  122.         return sdb;  
  123.   
  124.     }  
  125.   
  126.     private static CollectionSpace initCollectionSpace(String csName) {  
  127.         try {  
  128.             Sequoiadb sdb = getSequoiadb();  
  129.             CollectionSpace cs;  
  130.             if (sdb.isCollectionSpaceExist(csName)) {  
  131.                 cs = sdb.getCollectionSpace(csName);  
  132.             } else {  
  133.                 cs = sdb.createCollectionSpace(csName);  
  134.             }  
  135.             return cs;  
  136.         } catch (BaseException ex) {  
  137.             Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  138.             return null;  
  139.         }  
  140.     }  
  141.   
  142.     private static DBCollection initCollection(String collectionName) {  
  143.         CollectionSpace cs = initCollectionSpace(Const.SEQUOIADB_DATABASE);  
  144.         DBCollection cl;  
  145.         if (cs.isCollectionExist(collectionName)) {  
  146.             cl = cs.getCollection(collectionName);  
  147.         } else {  
  148.             cl = cs.createCollection(collectionName);  
  149.         }  
  150.         return cl;  
  151.     }  
  152.   
  153.     public static void remove(String collectionName) {  
  154.         DBCollection cl = initCollection(collectionName);  
  155.         cl.delete(new BasicBSONObject());  
  156.         sequoiadbDatasource.close(cl.getSequoiadb());  
  157.     }  
  158.   
  159.     public static boolean delete(String cl, String matcher) {  
  160.         try {  
  161.             DBCollection dbc = initCollection(cl);  
  162.             dbc.delete(matcher);  
  163.             sequoiadbDatasource.close(dbc.getSequoiadb());  
  164.             return true;  
  165.         } catch (Exception e) {  
  166.             log.error("delete " + cl + "matcher=>" + matcher + "失败", e);  
  167.             return false;  
  168.         }  
  169.     }  
  170.   
  171.     public static void delete(String cl, String matcher, String hint) {  
  172.         DBCollection dbc = initCollection(cl);  
  173.         dbc.delete(matcher, hint);  
  174.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  175.     }  
  176.   
  177.     public static boolean insert(String collectionName, String... key_val) {  
  178.         String strJson = strs2json(key_val);  
  179.         if (strJson != null) {  
  180.             BSONObject dbo;  
  181.             try {  
  182.                 dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理   
  183.             } catch (Exception e) {  
  184.                 log.error("解析json字符串异常,传入的字符串为：" + strJson, e);  
  185.                 return false;  
  186.             }  
  187.   
  188.             try {  
  189.                 DBCollection dbc = initCollection(collectionName);  
  190.                 dbc.insert(dbo);  
  191.                 sequoiadbDatasource.close(dbc.getSequoiadb());  
  192.                 return true;  
  193.             } catch (Exception e) {  
  194.                 return false;  
  195.             }  
  196.         }  
  197.         return false;  
  198.     }  
  199.   
  200.     public static boolean insert(String collectionName, String strJson) {  
  201.         BSONObject dbo = null;  
  202.         try {  
  203.             dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理   
  204.         } catch (Exception e) {  
  205.             log.error("解析json字符串异常,传入的字符串为：" + strJson, e);  
  206.             return false;  
  207.         }  
  208.   
  209.         DBCollection dBCollection = initCollection(collectionName);  
  210.         dBCollection.insert(dbo);  
  211.         sequoiadbDatasource.close(dBCollection.getSequoiadb());  
  212.         return true;  
  213.     }  
  214.   
  215.     public static boolean insertNestJson(String collectionName, String strJson, String strJson2, String nameOfNest) {  
  216.         BSONObject dbo = null;  
  217.         try {  
  218.             dbo = (BasicBSONObject) JSON.parse(strJson); //添加异常处理   
  219.         } catch (Exception e) {  
  220.             log.error("解析json字符串异常,传入的字符串为：" + strJson, e);  
  221.             return false;  
  222.         }  
  223.   
  224.         BSONObject dbo2 = null;  
  225.         try {  
  226.             dbo2 = (BasicBSONObject) JSON.parse(strJson2); //添加异常处理   
  227.         } catch (Exception e) {  
  228.             log.error("解析json字符串异常,传入的字符串为：" + strJson, e);  
  229.             return false;  
  230.         }  
  231.   
  232.         dbo.put(nameOfNest, dbo2);  
  233.   
  234.         DBCollection dBCollection = initCollection(collectionName);  
  235.         Object object = dBCollection.insert(dbo);  
  236.         sequoiadbDatasource.close(dBCollection.getSequoiadb());  
  237.         return true;  
  238.     }  
  239.   
  240.     //1  
  241.     public static boolean isExist(String collectionName, String matcher) {  
  242.         if (null == queryOne(collectionName, matcher, matcher, matcher, null)) {  
  243.             return false;  
  244.         } else {  
  245.             return true;  
  246.         }  
  247.     }  
  248.   
  249.     public static BasicBSONObject str2BSONObject(String jsonString) {  
  250.         return (BasicBSONObject) JSON.parse(jsonString);  
  251.     }  
  252.   
  253.     public static List exec(String sql) {  
  254.         DBCursor c = null;  
  255.         Sequoiadb seq = null;  
  256.         try {  
  257.             seq = sequoiadbDatasource.getConnection();  
  258.             c = seq.exec(sql);  
  259.         } catch (BaseException e) {  
  260.             e.printStackTrace();  
  261.         } catch (InterruptedException ex) {  
  262.             Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  263.         }  
  264.   
  265.         if (c != null && c.hasNext()) {  
  266.             List list = new ArrayList();  
  267.             while (c.hasNext()) {  
  268.                 list.add(c.getNext());  
  269.             }  
  270.             if (seq != null) {  
  271.                 sequoiadbDatasource.close(seq);  
  272.             }  
  273.             return list;  
  274.         } else {  
  275.             if (seq != null) {  
  276.                 sequoiadbDatasource.close(seq);  
  277.             }  
  278.             return null;  
  279.         }  
  280.     }  
  281.   
  282.     public static String exeSql(String sql) {  
  283.         return list2String(exec(sql));  
  284.     }  
  285.   
  286.     public static String exe(String sql) {  
  287.         return list2String(exec(sql));  
  288.     }  
  289.   
  290.     public static boolean execUpdate(String sql) {  
  291.         Sequoiadb seq = null;  
  292.         try {  
  293.             seq = sequoiadbDatasource.getConnection();  
  294.             seq.execUpdate(sql);  
  295.             sequoiadbDatasource.close(seq);  
  296.             return true;  
  297.         } catch (BaseException e) {  
  298.             sequoiadbDatasource.close(seq);  
  299.             e.printStackTrace();  
  300.             log.warn(sql, e);  
  301.             return false;  
  302.         } catch (InterruptedException ex) {  
  303.             Logger.getLogger(Squ.class.getName()).log(Level.SEVERE, null, ex);  
  304.             return false;  
  305.         }  
  306.     }  
  307.   
  308.     private static String _query(String cl, String matcher, String selector, String orderBy, String hint, long skipRows, long returnRows) {  
  309.         DBCollection dbc = initCollection(cl);  
  310.         String jsonString = cur2jsonstr(dbc.query(matcher, selector, orderBy, hint, skipRows, returnRows));  
  311.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  312.         return jsonString;  
  313.     }  
  314.   
  315.     public static String query(String cl, String matcher, String selector, String orderBy, String hint, long skipRows, long returnRows) {  
  316.         return _query(cl, matcher, selector, orderBy, hint, skipRows, returnRows);  
  317.     }  
  318.   
  319.     //matcher test  
  320.     public static String query(String cl, String matcher) {  
  321.         return _query(cl, matcher, null, null, null, 0, 0);  
  322.     }  
  323.   
  324.     //matcher test  
  325.     public static String query(String cl, String matcher, String selector) {  
  326.         return _query(cl, matcher, selector, null, null, 0, 0);  
  327.     }  
  328.   
  329.     public static List query4roomids(String cl, String matcher, String selector) {  
  330.         DBCollection dbc = initCollection(cl);  
  331.         DBCursor dBCursor = dbc.query(matcher, selector, null, null, 0, 0);  
  332.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  333.         return cur2list(dBCursor);  
  334.     }  
  335.   
  336.     //returnRows test  
  337.     public static String query(String cl, String matcher, long returnRows) {  
  338.         return _query(cl, matcher, null, null, null, 0L, returnRows);  
  339.     }  
  340.   
  341.     // selector {filed:1}  
  342.     public static String query(String cl, String matcher, String selector, long returnRows) {  
  343.         return _query(cl, matcher, selector, null, null, 0L, returnRows);  
  344.     }  
  345.   
  346.     // selector {filed:1}  
  347.     public static String query(String cl, String matcher, String selector, long skipRows, long returnRows) {  
  348.         return _query(cl, matcher, selector, null, null, skipRows, returnRows);  
  349.     }  
  350.   
  351. //    orderBy {filed:1/-1}  
  352.     public static String query(String cl, String matcher, String selector, String orderBy, long returnRows) {  
  353.         return _query(cl, matcher, selector, orderBy, null, 0L, returnRows);  
  354.     }  
  355.   
  356.     //hint (index) {}  
  357.     public static DBCursor query(String cl, String matcher, String selector, String orderBy, String hint, long returnRows) {  
  358.         DBCollection dbc = initCollection(cl);  
  359.         DBCursor dbcu = dbc.query(matcher, selector, orderBy, hint, 0L, returnRows);  
  360.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  361.         return dbcu;  
  362.     }  
  363.   
  364.     public static List query2(String cl, String matcher, String selector, String orderBy, String hint, long returnRows, List<String> list) {  
  365.         DBCollection dbc = initCollection(cl);  
  366.         DBCursor c = dbc.query(matcher, selector, orderBy, hint, 0L, returnRows);  
  367.   
  368.         if (c != null && c.hasNext()) {  
  369.             while (c.hasNext()) {  
  370.                 String str1 = (String) c.getNext().get("acc");  
  371.                 for (int j = 0; j < list.size(); j++) {  
  372.                     String str2 = list.get(j);  
  373.                     if (str2.equals(str1)) {  
  374.                         list.remove(str1);  
  375.                     }  
  376.                 }  
  377.             }  
  378.         } else {  
  379.             sequoiadbDatasource.close(dbc.getSequoiadb());  
  380.             return list;//直接返回生成的推荐号  
  381.         }  
  382.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  383.         return list;  
  384.     }  
  385.   
  386.     public static String query(String cl, String matcher, long returnRows, long skipRows) {  
  387.         return _query(cl, matcher, null, null, null, skipRows, returnRows);  
  388.     }  
  389.   
  390.     //1  
  391.     public static BSONObject queryOne(String collectionName, String matcher, String selector, String orderBy, String hint) {  
  392.         DBCollection dBCollection = initCollection(collectionName);  
  393.         BSONObject bSONObject = dBCollection.queryOne(str2BSONObject(matcher), str2BSONObject(selector), str2BSONObject(orderBy), str2BSONObject(hint), 0);  
  394.         sequoiadbDatasource.close(dBCollection.getSequoiadb());  
  395.         return bSONObject;  
  396.     }  
  397.   
  398.     public static String query(String collectionName) {  
  399.         return _query(collectionName, null, null, null, null, 0, 0);  
  400.     }  
  401.   
  402.     public static String query(String collectionName, String matcher, String selector, String orderBy, String hint, int limitNum) {  
  403.         return _query(collectionName, matcher, selector, orderBy, hint, limitNum, limitNum);  
  404.     }  
  405.   
  406.     public static void update(String cl, String matcher, String modifier, String hint) {  
  407.         DBCollection dbc = initCollection(cl);  
  408.         dbc.update(matcher, modifier, hint);  
  409.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  410.     }  
  411.   
  412.     public static void update$insert(String cl, String matcher, String modifier, String hint) {  
  413.         DBCollection dbc = initCollection(cl);  
  414.         dbc.update(matcher, modifier, hint);  
  415.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  416.     }  
  417.   
  418.     public static void update$unsetAll(String cl, String matcher, String field, String hint) {  
  419.         DBCollection dbc = initCollection(cl);  
  420.         dbc.update(matcher, "{$unset:" + field + ":[]}", hint); // Squ.update("friend", "{}", "{$unset:{label:[]}}", "{}");  
  421.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  422.     }  
  423.   
  424.     public static void update$unset(String cl, String matcher, String modifier, String hint) {  
  425.         DBCollection dbc = initCollection(cl);  
  426.         dbc.update(matcher, "{$unset:" + modifier + "}", hint); //  Squ.update("friend", "{}", "{$unset:{label:[33,44,55]}}", "{}");  
  427.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  428.   
  429.     }  
  430.   
  431.     public static void update$addtoset(String cl, String matcher, String modifier, String hint) {  
  432.         DBCollection dbc = initCollection(cl);  
  433.         dbc.update(matcher, "{$addtoset:" + modifier + "}", hint); //    Squ.upsert("friend", "{}", "{$addtoset:{label:[33,44,55]}}", "{}");  
  434.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  435.     }  
  436.   
  437.     public static boolean update(String collectionName, String matcher, String modifier) {  
  438.         DBCollection dbc = initCollection(collectionName);  
  439.         dbc.update(matcher, modifier, null);  
  440.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  441.         return true;  
  442.     }  
  443.   
  444.     public static boolean update$set(String collectionName, String matcher, String modifier) {  
  445.         DBCollection dbc = null;  
  446.         try {  
  447.             dbc = initCollection(collectionName);  
  448.             dbc.update(matcher, "{$set:" + modifier + "}", null);  
  449.             sequoiadbDatasource.close(dbc.getSequoiadb());  
  450.         } catch (Exception e) {  
  451.             log.debug("", e);  
  452.             sequoiadbDatasource.close(dbc.getSequoiadb());  
  453.             return false;  
  454.         }  
  455.   
  456.         return true;  
  457.     }  
  458.   
  459.     /** 
  460.      * 不存在会自动插入新记录 
  461.      * 
  462.      * @param cl 
  463.      * @param matcher 
  464.      * @param modifier 
  465.      * @param hint 
  466.      */  
  467.     public static void upsert(String cl, String matcher, String modifier, String hint) {  
  468.         DBCollection dbc = initCollection(cl);  
  469.         BSONObject ma = null;  
  470.         BSONObject mo = null;  
  471.         BSONObject hi = null;  
  472.         if (matcher != null) {  
  473.             ma = (BSONObject) JSON.parse(matcher);  
  474.         }  
  475.         if (modifier != null) {  
  476.             mo = (BSONObject) JSON.parse(modifier);  
  477.         }  
  478.         if (hint != null) {  
  479.             hi = (BSONObject) JSON.parse(hint);  
  480.         }  
  481.         dbc.upsert(ma, mo, hi);  
  482.         sequoiadbDatasource.close(dbc.getSequoiadb());  
  483.   
  484.     }  
  485.   
  486.     public static String strs2json(String... key_val) {  
  487.         if (key_val.length % 2 != 0) {  
  488.   
  489.         }  
  490.         String strJson = null;  
  491.         if (key_val != null) {  
  492.             StringBuilder sb = new StringBuilder();  
  493.             sb.append("{");  
  494.             int i = 0;  
  495.             while (key_val[i] != null) {  
  496.                 sb.append(key_val[i]).append(":\"").append(key_val[++i]).append("\"");  
  497.                 if (i < key_val.length - 1) {  
  498.                     sb.append(",");  
  499.                     i++;  
  500.                 } else {  
  501.                     key_val[i] = null;  
  502.                 }  
  503.             }  
  504.             sb.append("}");  
  505.             strJson = sb.toString();  
  506.   
  507.         }  
  508.         return strJson;  
  509.     }  
  510.   
  511.     public static List cur2list(DBCursor c) {  
  512.         if (c != null && c.hasNext()) {  
  513.             List list = new ArrayList();  
  514.             while (c.hasNext()) {  
  515.                 list.add(c.getNext());  
  516.             }  
  517.   
  518.             return list;  
  519.         }  
  520.         return null;  
  521.     }  
  522.   
  523.     public static String cur2jsonstr(DBCursor c) {  
  524.         String jsonString = "";  
  525.         if (c != null && c.hasNext()) {  
  526.             while (c.hasNext()) {  
  527.                 jsonString = jsonString + (c.getNext().toString());  
  528.             }  
  529.             c.close();  
  530.             return jsonString;  
  531.         }  
  532.         return "{}";  
  533.     }  
  534.   
  535.     private static String list2String(List list) {  
  536.         if (list != null) {  
  537.             StringBuilder sb = new StringBuilder();  
  538.             list.stream().forEach((Object s) -> {  
  539.                 sb.append(s).append(",");  
  540.             });  
  541.             return sb.toString();  
  542.         } else {  
  543.             return null;  
  544.         }  
  545.   
  546.     }  
  547.   
  548.     public static List<String> queryList(String collectionName, String string, String acc1_id0, String string0, String string1, int i, int DB_SEARCH_REM_COUNT, List<String> list) {  
  549.         return query2(collectionName, string, string1, string1, string, i, list);  
  550.     }  
  551.   
  552.     public static void remove(String collectionName, String match) {  
  553.         DBCollection cl = initCollection(collectionName);  
  554.         cl.delete(parse2BasicBSONObject(match));  
  555.         sequoiadbDatasource.close(cl.getSequoiadb());  
  556.     }  
  557.   
  558.     public static JSONObject parse2JSONObject(String json) {  
  559.         return new JSONObject(json);  
  560.     }  
  561.   
  562.     static class a implements BiConsumer {  
  563.   
  564.         @Override  
  565.         public void accept(Object t, Object u) {  
  566. //            System.out.println("t=>>"+t);  
  567. //            System.out.println("u=>>"+u);  
  568.         }  
  569.     }  
  570.   
  571.     public static BasicBSONObject parse2BasicBSONObject(String json) {  
  572.         BasicBSONObject bbo = new BasicBSONObject();  
  573.         JSONObject obj = parse2JSONObject(json);  
  574. //        obj.forEach(new a() {});  
  575.         obj.entrySet().forEach(key -> {  
  576.             System.out.println("c=>>" + obj.getString(key.getKey()));  
  577.             System.out.println("c=>>" + obj.optString(key.getKey()));  
  578.         });  
  579.         return bbo;  
  580.     }  
  581.   
  582.     public static void main2(String[] args) {  
  583.         parse2BasicBSONObject("{\n"  
  584.                 + "  \"_id\":\"testuser8\",\n"  
  585.                 + "  \"UID\":\"testuser\",\n"  
  586.                 + "  \"CDATE\":\"2015-05-10 17:28:50\",\n"  
  587.                 + "  \"IDATE\":\"2015-05-10 17:28:50\",\n"  
  588.                 + "  \"CARDTL\":\"{\\\"HEADPIC\\\":\\\"\\\",\\\"NICK\\\":\\\"1\\\",\\\"name\\\":\\\"2\\\",\\\"skill\\\":\\\"3\\\"}\",\n"  
  589.                 + "  \"NICK\":\"\",\n"  
  590.                 + "  \"NID\":\"8\",\n"  
  591.                 + "  \"HEADPIC\":\"\",\n"  
  592.                 + "  \"UDATE\":{\n"  
  593.                 + "    \"$date\":\"2015-05-10T09:28:50.668Z\"\n"  
  594.                 + "  },\n"  
  595.                 + "  \"UD\":\"testuser\",\n"  
  596.                 + "  \"URID\":\"urid\",\n"  
  597.                 + "  \"ORANGE\":\"uId:个人信息标签2\"\n"  
  598.                 + "}");  
  599.     }  
  600. }  
上一篇：《JavaScript开发框架权威指南》——导读


下一篇：最新linux搭建gfs系统--iscsi+GFS实现网络存储