开发者社区> java牛> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

使用JDBC获取各数据库的Meta信息——表以及对应的列

简介: 先贴代码,作为草稿: 第一个是工具类, MapUtil.java [java] view plain copy import java.util.ArrayList;   import java.
+关注继续查看

先贴代码,作为草稿:

第一个是工具类, MapUtil.java

[java] view plain copy
  1. import java.util.ArrayList;  
  2. import java.util.HashMap;  
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7. import java.util.regex.Matcher;  
  8. import java.util.regex.Pattern;  
  9.   
  10. /** 
  11.  * map转换工具 
  12.  */  
  13. public class MapUtil {  
  14.       
  15.     /** 
  16.      * 将List中的Key转换为小写 
  17.      * @param list 返回新对象 
  18.      * @return 
  19.      */  
  20.     public static List<Map<String, Object>> convertKeyList2LowerCase(List<Map<String, Object>> list){  
  21.         if(null==list) {  
  22.             return null;  
  23.         }  
  24.         List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();  
  25.         //  
  26.         Iterator<Map<String, Object>> iteratorL = list.iterator();  
  27.         while (iteratorL.hasNext()) {  
  28.             Map<String, Object> map = (Map<String, Object>) iteratorL.next();  
  29.             //  
  30.             Map<String, Object> result = convertKey2LowerCase(map);  
  31.             if(null != result){  
  32.                 resultList.add(result);  
  33.             }  
  34.         }  
  35.         //  
  36.         return resultList;  
  37.     }  
  38.     /** 
  39.      * 转换单个map,将key转换为小写.  
  40.      * @param map 返回新对象 
  41.      * @return 
  42.      */  
  43.     public static Map<String, Object> convertKey2LowerCase(Map<String, Object> map){  
  44.         if(null==map) {  
  45.             return null;  
  46.         }  
  47.         Map<String, Object> result = new HashMap<String, Object>();  
  48.         //  
  49.         Set<String> keys  = map.keySet();  
  50.         //  
  51.         Iterator<String> iteratorK = keys.iterator();  
  52.         while (iteratorK.hasNext()) {  
  53.             String key = (String) iteratorK.next();  
  54.             Object value = map.get(key);  
  55.             if(null == key){  
  56.                 continue;  
  57.             }  
  58.             //  
  59.             String keyL = key.toLowerCase();  
  60.             result.put(keyL, value);  
  61.         }  
  62.         return result;  
  63.     }  
  64.     /** 
  65.      * 将List中Map的Key转换为小写. 
  66.      * @param list 
  67.      * @return 
  68.      */  
  69.     public static List<Map<String, Object>> trimListKeyValue(List<Map<String, Object>> list){  
  70.         if(null==list) {  
  71.             return null;  
  72.         }  
  73.         List<Map<String, Object>> resultList = new ArrayList<Map<String,Object>>();  
  74.         //  
  75.         Iterator<Map<String, Object>> iteratorL = list.iterator();  
  76.         while (iteratorL.hasNext()) {  
  77.             Map<String, Object> map = (Map<String, Object>) iteratorL.next();  
  78.             //  
  79.             Map<String, Object> result = trimKeyValue(map);  
  80.             if(null != result){  
  81.                 resultList.add(result);  
  82.             }  
  83.         }  
  84.         //  
  85.         return resultList;  
  86.     }  
  87.     /** 
  88.      * 转换单个map,将key转换为小写.  
  89.      * @param map 返回新对象 
  90.      * @return 
  91.      */  
  92.     public static Map<String, Object> trimKeyValue(Map<String, Object> map){  
  93.         if(null==map) {  
  94.             return null;  
  95.         }  
  96.         Map<String, Object> result = new HashMap<String, Object>();  
  97.         //  
  98.         Set<String> keys  = map.keySet();  
  99.         //  
  100.         Iterator<String> iteratorK = keys.iterator();  
  101.         while (iteratorK.hasNext()) {  
  102.             String key = (String) iteratorK.next();  
  103.             Object value = map.get(key);  
  104.             if(null == key){  
  105.                 continue;  
  106.             }  
  107.             //  
  108.             String keyT = key.trim();  
  109.             if(value instanceof String){  
  110.                 String valueT = String.valueOf(value).trim();  
  111.                 result.put(keyT, valueT);  
  112.             } else {  
  113.                 result.put(keyT, value);  
  114.             }  
  115.         }  
  116.         return result;  
  117.     }  
  118. }  


然后是具体的实现工具类,使用了阿里巴巴的 fastjson 工具包;里面的测试类可以忽略

[java] view plain copy
  1. import java.sql.Connection;  
  2. import java.sql.DatabaseMetaData;  
  3. import java.sql.DriverManager;  
  4. import java.sql.ResultSet;  
  5. import java.sql.ResultSetMetaData;  
  6. import java.sql.SQLException;  
  7. import java.sql.Statement;  
  8. import java.util.ArrayList;  
  9. import java.util.HashMap;  
  10. import java.util.List;  
  11. import java.util.Map;  
  12. import java.util.Properties;  
  13.   
  14. import com.alibaba.fastjson.JSONArray;  
  15.   
  16. /** 
  17.  * 需要注意,想要有表字段描述信息,获取连接时需要指定某些特殊属性<br/>  
  18.  * 数据交换-工具类 
  19.  */  
  20. public class DBMSMetaUtil {  
  21.   
  22.   
  23.     /** 
  24.      * 数据库类型,枚举 
  25.      *  
  26.      */  
  27.     public static enum DATABASETYPE {  
  28.         ORACLE, MYSQL, SQLSERVER, SQLSERVER2005, DB2, INFORMIX, SYBASE, OTHER, EMPTY  
  29.     }  
  30.   
  31.     /** 
  32.      * 根据字符串,判断数据库类型 
  33.      *  
  34.      * @param databasetype 
  35.      * @return 
  36.      */  
  37.     public static DATABASETYPE parseDATABASETYPE(String databasetype) {  
  38.         // 空类型  
  39.         if (null == databasetype || databasetype.trim().length() < 1) {  
  40.             return DATABASETYPE.EMPTY;  
  41.         }  
  42.         // 截断首尾空格,转换为大写  
  43.         databasetype = databasetype.trim().toUpperCase();  
  44.         // Oracle数据库  
  45.         if (databasetype.contains("ORACLE")) {  
  46.             //  
  47.             return DATABASETYPE.ORACLE;  
  48.         }  
  49.         // MYSQL 数据库  
  50.         if (databasetype.contains("MYSQL")) {  
  51.             //  
  52.             return DATABASETYPE.MYSQL;  
  53.         }  
  54.         // SQL SERVER 数据库  
  55.         if (databasetype.contains("SQL") && databasetype.contains("SERVER")) {  
  56.             //  
  57.             if (databasetype.contains("2005") || databasetype.contains("2008") || databasetype.contains("2012")) {  
  58.   
  59.                 try {  
  60.                     Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");  
  61.                 } catch (ClassNotFoundException e) {  
  62.                     e.printStackTrace();  
  63.                 }  
  64.                   
  65.                 return DATABASETYPE.SQLSERVER2005;  
  66.             } else {  
  67.                 try {  
  68.                     // 注册 JTDS  
  69.                     Class.forName("net.sourceforge.jtds.jdbc.Driver");  
  70.                 } catch (ClassNotFoundException e) {  
  71.                     e.printStackTrace();  
  72.                 }  
  73.                 return DATABASETYPE.SQLSERVER;  
  74.             }  
  75.         }  
  76.         // 下面的这几个没有经过实践测试, 判断可能不准确  
  77.         // DB2 数据库  
  78.         if (databasetype.contains("DB2")) {  
  79.             //  
  80.             return DATABASETYPE.DB2;  
  81.         }  
  82.         // INFORMIX 数据库  
  83.         if (databasetype.contains("INFORMIX")) {  
  84.             //  
  85.             return DATABASETYPE.INFORMIX;  
  86.         }  
  87.         // SYBASE 数据库  
  88.         if (databasetype.contains("SYBASE")) {  
  89.             //  
  90.             return DATABASETYPE.SYBASE;  
  91.         }  
  92.   
  93.         // 默认,返回其他  
  94.         return DATABASETYPE.OTHER;  
  95.     }  
  96.   
  97.     /** 
  98.      * 列出数据库的所有表 
  99.      */  
  100.     // 可以参考: http://www.cnblogs.com/chinafine/articles/1847205.html  
  101.     public static List<Map<String, Object>> listTables(String databasetype, String ip, String port, String dbname,  
  102.             String username, String password) {  
  103.         // 去除首尾空格  
  104.         databasetype = trim(databasetype);  
  105.         ip = trim(ip);  
  106.         port = trim(port);  
  107.         dbname = trim(dbname);  
  108.         username = trim(username);  
  109.         password = trim(password);  
  110.         //  
  111.         DATABASETYPE dbtype = parseDATABASETYPE(databasetype);  
  112.         //  
  113.         List<Map<String, Object>> result = null;  
  114.         String url = concatDBURL(dbtype, ip, port, dbname);  
  115.         Connection conn = getConnection(url, username, password);  
  116.         // Statement stmt = null;  
  117.         ResultSet rs = null;  
  118.         //  
  119.         try {  
  120.             // 这句话我也不懂是什么意思... 好像没什么用  
  121.             conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);  
  122.             // 获取Meta信息对象  
  123.             DatabaseMetaData meta = conn.getMetaData();  
  124.             // 数据库  
  125.             String catalog = null;  
  126.             // 数据库的用户  
  127.             String schemaPattern = null;// meta.getUserName();  
  128.             // 表名  
  129.             String tableNamePattern = null;//  
  130.             // types指的是table、view  
  131.             String[] types = { "TABLE" };  
  132.             // Oracle  
  133.             if (DATABASETYPE.ORACLE.equals(dbtype)) {  
  134.                 schemaPattern = username;  
  135.                 if (null != schemaPattern) {  
  136.                     schemaPattern = schemaPattern.toUpperCase();  
  137.                 }  
  138.                 // 查询  
  139.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  140.             } else if (DATABASETYPE.MYSQL.equals(dbtype)) {  
  141.                 // Mysql查询  
  142.                 // MySQL 的 table 这一级别查询不到备注信息  
  143.                 schemaPattern = dbname;  
  144.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  145.             }  else if (DATABASETYPE.SQLSERVER.equals(dbtype) || DATABASETYPE.SQLSERVER2005.equals(dbtype)) {  
  146.                 // SqlServer  
  147.                 tableNamePattern = "%";  
  148.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  149.             }  else if (DATABASETYPE.DB2.equals(dbtype)) {  
  150.                 // DB2查询  
  151.                 schemaPattern = "jence_user";  
  152.                 tableNamePattern = "%";  
  153.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  154.             } else if (DATABASETYPE.INFORMIX.equals(dbtype)) {  
  155.                 // SqlServer  
  156.                 tableNamePattern = "%";  
  157.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  158.             } else if (DATABASETYPE.SYBASE.equals(dbtype)) {  
  159.                 // SqlServer  
  160.                 tableNamePattern = "%";  
  161.                 rs = meta.getTables(catalog, schemaPattern, tableNamePattern, types);  
  162.             }  else {  
  163.                 throw new RuntimeException("不认识的数据库类型!");  
  164.             }  
  165.             //  
  166.             result = parseResultSetToMapList(rs);  
  167.   
  168.         } catch (Exception e) {  
  169.             e.printStackTrace();  
  170.         } finally {  
  171.             close(rs);  
  172.             close(conn);  
  173.         }  
  174.         //  
  175.         return result;  
  176.     }  
  177.   
  178.     /** 
  179.      * 列出表的所有字段 
  180.      */  
  181.     public static List<Map<String, Object>> listColumns(String databasetype, String ip, String port, String dbname,  
  182.             String username, String password, String tableName) {  
  183.         // 去除首尾空格  
  184.         databasetype = trim(databasetype);  
  185.         ip = trim(ip);  
  186.         port = trim(port);  
  187.         dbname = trim(dbname);  
  188.         username = trim(username);  
  189.         password = trim(password);  
  190.         tableName = trim(tableName);  
  191.         //  
  192.         DATABASETYPE dbtype = parseDATABASETYPE(databasetype);  
  193.         //  
  194.         List<Map<String, Object>> result = null;  
  195.         String url = concatDBURL(dbtype, ip, port, dbname);  
  196.         Connection conn = getConnection(url, username, password);  
  197.         // Statement stmt = null;  
  198.         ResultSet rs = null;  
  199.         //  
  200.         try {  
  201.             // 获取Meta信息对象  
  202.             DatabaseMetaData meta = conn.getMetaData();  
  203.             // 数据库  
  204.             String catalog = null;  
  205.             // 数据库的用户  
  206.             String schemaPattern = null;// meta.getUserName();  
  207.             // 表名  
  208.             String tableNamePattern = tableName;//  
  209.             // 转换为大写  
  210.             if (null != tableNamePattern) {  
  211.                 tableNamePattern = tableNamePattern.toUpperCase();  
  212.             }  
  213.             //   
  214.             String columnNamePattern = null;  
  215.             // Oracle  
  216.             if (DATABASETYPE.ORACLE.equals(dbtype)) {  
  217.                 // 查询  
  218.                 schemaPattern = username;  
  219.                 if (null != schemaPattern) {  
  220.                     schemaPattern = schemaPattern.toUpperCase();  
  221.                 }  
  222.             } else {  
  223.                 //  
  224.             }  
  225.   
  226.             rs = meta.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);  
  227.             // TODO 获取主键列,但还没使用  
  228.             meta.getPrimaryKeys(catalog, schemaPattern, tableNamePattern);  
  229.             //  
  230.             result = parseResultSetToMapList(rs);  
  231.         } catch (Exception e) {  
  232.             e.printStackTrace();  
  233.         } finally {  
  234.             // 关闭资源  
  235.             close(rs);  
  236.             close(conn);  
  237.         }  
  238.         //  
  239.         return result;  
  240.     }  
  241.   
  242.     /** 
  243.      * 根据IP,端口,以及数据库名字,拼接Oracle连接字符串 
  244.      *  
  245.      * @param ip 
  246.      * @param port 
  247.      * @param dbname 
  248.      * @return 
  249.      */  
  250.     public static String concatDBURL(DATABASETYPE dbtype, String ip, String port, String dbname) {  
  251.         //  
  252.         String url = "";  
  253.         // Oracle数据库  
  254.         if (DATABASETYPE.ORACLE.equals(dbtype)) {  
  255.             //  
  256.             url += "jdbc:oracle:thin:@";  
  257.             url += ip.trim();  
  258.             url += ":" + port.trim();  
  259.             url += ":" + dbname;  
  260.               
  261.             // 如果需要采用 hotbackup  
  262.             String url2 = "";  
  263.             url2 = url2+"jdbc:oracle:thin:@(DESCRIPTION = (ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = "  
  264.                     + ip.trim() +")(PORT ="+ port.trim() +")))(CONNECT_DATA = (SERVICE_NAME ="+dbname+  
  265.                     ")(FAILOVER_MODE = (TYPE = SELECT)(METHOD = BASIC)(RETRIES = 180)(DELAY = 5))))";  
  266.             //  
  267.             // url = url2;  
  268.         } else if (DATABASETYPE.MYSQL.equals(dbtype)) {  
  269.             //  
  270.             url += "jdbc:mysql://";  
  271.             url += ip.trim();  
  272.             url += ":" + port.trim();  
  273.             url += "/" + dbname;  
  274.         } else if (DATABASETYPE.SQLSERVER.equals(dbtype)) {  
  275.             //  
  276.             url += "jdbc:jtds:sqlserver://";  
  277.             url += ip.trim();  
  278.             url += ":" + port.trim();  
  279.             url += "/" + dbname;  
  280.             url += ";tds=8.0;lastupdatecount=true";  
  281.         } else if (DATABASETYPE.SQLSERVER2005.equals(dbtype)) {  
  282.             //  
  283.             url += "jdbc:sqlserver://";  
  284.             url += ip.trim();  
  285.             url += ":" + port.trim();  
  286.             url += "; DatabaseName=" + dbname;  
  287.         } else if (DATABASETYPE.DB2.equals(dbtype)) {  
  288.             url += "jdbc:db2://";  
  289.             url += ip.trim();  
  290.             url += ":" + port.trim();  
  291.             url += "/" + dbname;  
  292.         } else if (DATABASETYPE.INFORMIX.equals(dbtype)) {  
  293.             // Infox mix 可能有BUG  
  294.             url += "jdbc:informix-sqli://";  
  295.             url += ip.trim();  
  296.             url += ":" + port.trim();  
  297.             url += "/" + dbname;  
  298.             // +":INFORMIXSERVER=myserver;user="+bean.getDatabaseuser()+";password="+bean.getDatabasepassword()  
  299.         } else if (DATABASETYPE.SYBASE.equals(dbtype)) {  
  300.             url += "jdbc:sybase:Tds:";  
  301.             url += ip.trim();  
  302.             url += ":" + port.trim();  
  303.             url += "/" + dbname;  
  304.         } else {  
  305.             throw new RuntimeException("不认识的数据库类型!");  
  306.         }  
  307.         //  
  308.         return url;  
  309.     }  
  310.   
  311.     /** 
  312.      * 获取JDBC连接 
  313.      *  
  314.      * @param url 
  315.      * @param username 
  316.      * @param password 
  317.      * @return 
  318.      */  
  319.     public static Connection getConnection(String url, String username, String password) {  
  320.         Connection conn = null;  
  321.         try {  
  322.             // 不需要加载Driver. Servlet 2.4规范开始容器会自动载入  
  323.             // conn = DriverManager.getConnection(url, username, password);  
  324.             //  
  325.             Properties info =new Properties();  
  326.             //  
  327.             info.put("user", username);  
  328.             info.put("password", password);  
  329.             // !!! Oracle 如果想要获取元数据 REMARKS 信息,需要加此参数  
  330.             info.put("remarksReporting","true");  
  331.             // !!! MySQL 标志位, 获取TABLE元数据 REMARKS 信息  
  332.             info.put("useInformationSchema","true");  
  333.             // 不知道SQLServer需不需要设置...  
  334.             //  
  335.             conn = DriverManager.getConnection(url, info);  
  336.         } catch (SQLException e) {  
  337.             e.printStackTrace();  
  338.         }  
  339.         return conn;  
  340.     }  
  341.   
  342.     /** 
  343.      * 将一个未处理的ResultSet解析为Map列表. 
  344.      *  
  345.      * @param rs 
  346.      * @return 
  347.      */  
  348.     public static List<Map<String, Object>> parseResultSetToMapList(ResultSet rs) {  
  349.         //  
  350.         List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();  
  351.         //  
  352.         if (null == rs) {  
  353.             return null;  
  354.         }  
  355.         //  
  356.         try {  
  357.             while (rs.next()) {  
  358.                 //   
  359.                 Map<String, Object> map = parseResultSetToMap(rs);  
  360.                 //  
  361.                 if (null != map) {  
  362.                     result.add(map);  
  363.                 }  
  364.             }  
  365.         } catch (SQLException e) {  
  366.             e.printStackTrace();  
  367.         }  
  368.         //  
  369.         return result;  
  370.     }  
  371.   
  372.     /** 
  373.      * 解析ResultSet的单条记录,不进行 ResultSet 的next移动处理 
  374.      *  
  375.      * @param rs 
  376.      * @return 
  377.      */  
  378.     private static Map<String, Object> parseResultSetToMap(ResultSet rs) {  
  379.         //  
  380.         if (null == rs) {  
  381.             return null;  
  382.         }  
  383.         //  
  384.         Map<String, Object> map = new HashMap<String, Object>();  
  385.         //  
  386.         try {  
  387.             ResultSetMetaData meta = rs.getMetaData();  
  388.             //  
  389.             int colNum = meta.getColumnCount();  
  390.             //  
  391.             for (int i = 1; i <= colNum; i++) {  
  392.                 // 列名  
  393.                 String name = meta.getColumnLabel(i); // i+1  
  394.                 Object value = rs.getObject(i);  
  395.                 // 加入属性  
  396.                 map.put(name, value);  
  397.             }  
  398.         } catch (SQLException e) {  
  399.             e.printStackTrace();  
  400.         }  
  401.         //  
  402.         return map;  
  403.     }  
  404.       
  405.     //  
  406.     public static boolean TryLink(String databasetype, String ip, String port, String dbname, String username, String password) {  
  407.         //  
  408.         DATABASETYPE dbtype = parseDATABASETYPE(databasetype);  
  409.         String url = concatDBURL(dbtype, ip, port, dbname);  
  410.         Connection conn = null;  
  411.         //  
  412.         try {  
  413.             conn = getConnection(url, username, password);  
  414.             if(null == conn){  
  415.                 return false;  
  416.             }  
  417.             DatabaseMetaData meta =  conn.getMetaData();  
  418.             //  
  419.             if(null == meta){  
  420.                 return false;  
  421.             } else {  
  422.                 // 只有这里返回true  
  423.                 return true;  
  424.             }  
  425.         } catch (Exception e) {  
  426.             e.printStackTrace();  
  427.         } finally{  
  428.             close(conn);  
  429.         }  
  430.         //  
  431.         return false;  
  432.     }  
  433.     //  
  434.     public static void close(Connection conn) {  
  435.         if(conn!=null) {  
  436.             try {  
  437.                 conn.close();  
  438.                 conn = null;  
  439.             } catch (SQLException e) {  
  440.                 e.printStackTrace();  
  441.             }  
  442.         }  
  443.     }  
  444.     //  
  445.     public static void close(Statement stmt) {  
  446.         if(stmt!=null) {  
  447.             try {  
  448.                 stmt.close();  
  449.                 stmt = null;  
  450.             } catch (SQLException e) {  
  451.                 e.printStackTrace();  
  452.             }  
  453.         }  
  454.     }  
  455.     //  
  456.     public static void close(ResultSet rs) {  
  457.         if(rs!=null) {  
  458.             try {  
  459.                 rs.close();  
  460.                 rs = null;  
  461.             } catch (SQLException e) {  
  462.                 e.printStackTrace();  
  463.             }  
  464.         }  
  465.     }  
  466.     //  
  467.     public static String trim(String str){  
  468.         if(null != str){  
  469.             str = str.trim();  
  470.         }  
  471.         return str;  
  472.     }  
  473.   
  474.     public static void main(String[] args) {  
  475.         //testLinkOracle();  
  476.         //testLinkSQLServer();  
  477.         testOracle();  
  478.         //testMySQL();  
  479.     }  
  480.   
  481.     //  
  482.     public static void testLinkOracle() {  
  483.         //  
  484.         String ip= "192.168.0.100";  
  485.         String port= "1521";   
  486.         String dbname= "orcl";   
  487.         String username= "username";   
  488.         String password= "*****pwd";  
  489.         String databasetype= "oracle";  
  490.         //  
  491.         String url = concatDBURL(parseDATABASETYPE(databasetype), ip, port, dbname);  
  492.         System.out.println("url="+url);  
  493.         //  
  494.         boolean result = TryLink(databasetype, ip, port, dbname, username, password);  
  495.         //  
  496.         System.out.println("result="+result);  
  497.     }  
  498.   
  499.     //  
  500.     public static void testLinkSQLServer() {  
  501.         //  
  502.         String ip= "192.168.0.100";  
  503.         String port= "1433";   
  504.         String dbname= "sqlserverdb1";   
  505.         String username= "sa";   
  506.         String password= "186957";  
  507.         String databasetype= "SQL Server";  
  508.         //  
  509.         String url = concatDBURL(parseDATABASETYPE(databasetype), ip, port, dbname);  
  510.         System.out.println("url="+url);  
  511.         //  
  512.         boolean result = TryLink(databasetype, ip, port, dbname, username, password);  
  513.         //  
  514.         System.out.println("result="+result);  
  515.     }  
  516.       
  517.       
  518.       
  519.     public static void testOracle() {  
  520.         //  
  521.         String ip = "192.168.0.100";  
  522.         String port = "1521";  
  523.         String dbname = "orcl";  
  524.         String username = "unixsys";  
  525.         String password = "orpass";  
  526.         //  
  527.         String databasetype = "Oracle";  
  528.         // DATABASETYPE dbtype = parseDATABASETYPE(databasetype);  
  529.         // System.out.println(DATABASETYPE.ORACLE.equals(dbtype));  
  530.         //  
  531.         String tableName = "DBMS_CODE_CHEME_NEW";  
  532.   
  533.         List<Map<String, Object>> tables = listTables(databasetype, ip, port, dbname, username, password);  
  534.         List<Map<String, Object>> columns = listColumns(databasetype, ip, port, dbname, username, password, tableName);  
  535.         //  
  536.         tables = MapUtil.convertKeyList2LowerCase(tables);  
  537.         columns = MapUtil.convertKeyList2LowerCase(columns);  
  538.         //  
  539.         String jsonT = JSONArray.toJSONString(tables, true);  
  540.         System.out.println(jsonT);  
  541.         System.out.println("tables.size()=" + tables.size());  
  542.         //  
  543.         System.out.println("-----------------------------------------" + "-----------------------------------------");  
  544.         System.out.println("-----------------------------------------" + "-----------------------------------------");  
  545.         //  
  546.         String jsonC = JSONArray.toJSONString(columns, true);  
  547.         System.out.println(jsonC);  
  548.         System.out.println("columns.size()=" + columns.size());  
  549.     }  
  550.       
  551.   
  552.     public static void testMySQL() {  
  553.         //  
  554.         String ip = "127.0.0.1";  
  555.         String port = "4050";  
  556.         String   
  557.             dbname = "cncounter";  
  558.             dbname = "eReqDlG";  
  559.         String   
  560.             username = "root";  
  561.             username = "6EhSiGpsmSMRr";  
  562.         String   
  563.             password = "eoNRNBgRk397mVy";  
  564.         //  
  565.         String databasetype = "mysql";  
  566.         // DATABASETYPE dbtype = parseDATABASETYPE(databasetype);  
  567.         // System.out.println(DATABASETYPE.ORACLE.equals(dbtype));  
  568.         //  
  569.         String tableName = "vote";  
  570.   
  571.         List<Map<String, Object>> tables = listTables(databasetype, ip, port, dbname, username, password);  
  572.         List<Map<String, Object>> columns = listColumns(databasetype, ip, port, dbname, username, password, tableName);  
  573.         //  
  574.         tables = MapUtil.convertKeyList2LowerCase(tables);  
  575.         columns = MapUtil.convertKeyList2LowerCase(columns);  
  576.         //  
  577.         String jsonT = JSONArray.toJSONString(tables, true);  
  578.         System.out.println(jsonT);  
  579.         System.out.println("tables.size()=" + tables.size());  
  580.         //  
  581.         System.out.println("-----------------------------------------" + "-----------------------------------------");  
  582.         System.out.println("-----------------------------------------" + "-----------------------------------------");  
  583.         //  
  584.         String jsonC = JSONArray.toJSONString(columns, true);  
  585.         System.out.println(jsonC);  
  586.         System.out.println("columns.size()=" + columns.size());  
  587.     }  
  588.     // 演示 DatabaseMetaData  
  589.     public static void demoDatabaseMetaData() {  
  590.         try {  
  591.             Class.forName("com.mysql.jdbc.Driver");  
  592.             Connection con = DriverManager.getConnection("jdbc:mysql://localhost/dbtest", "root", "root");  
  593.             //  
  594.             DatabaseMetaData dmd = con.getMetaData();  
  595.             System.out.println("当前数据库是:" + dmd.getDatabaseProductName());  
  596.             System.out.println("当前数据库版本:" + dmd.getDatabaseProductVersion());  
  597.             System.out.println("当前数据库驱动:" + dmd.getDriverVersion());  
  598.             System.out.println("当前数据库URL:" + dmd.getURL());  
  599.             System.out.println("当前数据库是否是只读模式?:" + dmd.isReadOnly());  
  600.             System.out.println("当前数据库是否支持批量更新?:" + dmd.supportsBatchUpdates());  
  601.             System.out.println("当前数据库是否支持结果集的双向移动(数据库数据变动不在ResultSet体现)?:"  
  602.                     + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));  
  603.             System.out.println("当前数据库是否支持结果集的双向移动(数据库数据变动会影响到ResultSet的内容)?:"  
  604.                     + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));  
  605.             System.out.println("========================================");  
  606.   
  607.             ResultSet rs = dmd.getTables(null, null, "%", null);  
  608.             System.out.println("表名" + "," + "表类型");  
  609.             while (rs.next()) {  
  610.                 System.out.println(rs.getString("TABLE_NAME") + "," + rs.getString("TABLE_TYPE"));  
  611.             }  
  612.             System.out.println("========================================");  
  613.   
  614.             rs = dmd.getPrimaryKeys(null, null, "t_student");  
  615.             while (rs.next()) {  
  616.                 System.out.println(rs.getString(3) + "表的主键是:" + rs.getString(4));  
  617.             }  
  618.             System.out.println("========================================");  
  619.   
  620.             rs = dmd.getColumns(null, null, "t_student", "%");  
  621.             System.out.println("t_student表包含的字段:");  
  622.             while (rs.next()) {  
  623.                 System.out.println(rs.getString(4) + " " + rs.getString(6) + "(" + rs.getString(7) + ");");  
  624.             }  
  625.             System.out.println("========================================");  
  626.   
  627.         } catch (Exception e) {  
  628.             System.out.println("数据库操作出现异常");  
  629.         }  
  630.     }  
  631.   
  632.     // ResultSetMetaData 使用示例  
  633.     // 此方法参考 http://blog.csdn.net/yirentianran/article/details/2950321  
  634.     public static void demoResultSetMetaData(ResultSetMetaData data) throws SQLException {  
  635.         for (int i = 1; i <= data.getColumnCount(); i++) {  
  636.             // 获得所有列的数目及实际列数  
  637.             int columnCount = data.getColumnCount();  
  638.             // 获得指定列的列名  
  639.             String columnName = data.getColumnName(i);  
  640.             // 获得指定列的列值  
  641.             // String columnValue = rs.getString(i);  
  642.             // 获得指定列的数据类型  
  643.             int columnType = data.getColumnType(i);  
  644.             // 获得指定列的数据类型名  
  645.             String columnTypeName = data.getColumnTypeName(i);  
  646.             // 所在的Catalog名字  
  647.             String catalogName = data.getCatalogName(i);  
  648.             // 对应数据类型的类  
  649.             String columnClassName = data.getColumnClassName(i);  
  650.             // 在数据库中类型的最大字符个数  
  651.             int columnDisplaySize = data.getColumnDisplaySize(i);  
  652.             // 默认的列的标题  
  653.             String columnLabel = data.getColumnLabel(i);  
  654.             // 获得列的模式  
  655.             String schemaName = data.getSchemaName(i);  
  656.             // 某列类型的精确度(类型的长度)  
  657.             int precision = data.getPrecision(i);  
  658.             // 小数点后的位数  
  659.             int scale = data.getScale(i);  
  660.             // 获取某列对应的表名  
  661.             String tableName = data.getTableName(i);  
  662.             // 是否自动递增  
  663.             boolean isAutoInctement = data.isAutoIncrement(i);  
  664.             // 在数据库中是否为货币型  
  665.             boolean isCurrency = data.isCurrency(i);  
  666.             // 是否为空  
  667.             int isNullable = data.isNullable(i);  
  668.             // 是否为只读  
  669.             boolean isReadOnly = data.isReadOnly(i);  
  670.             // 能否出现在where中  
  671.             boolean isSearchable = data.isSearchable(i);  
  672.             System.out.println(columnCount);  
  673.             System.out.println("获得列" + i + "的字段名称:" + columnName);  
  674.             // System.out.println("获得列" + i + "的字段值:" + columnValue);  
  675.             System.out.println("获得列" + i + "的类型,返回SqlType中的编号:" + columnType);  
  676.             System.out.println("获得列" + i + "的数据类型名:" + columnTypeName);  
  677.             System.out.println("获得列" + i + "所在的Catalog名字:" + catalogName);  
  678.             System.out.println("获得列" + i + "对应数据类型的类:" + columnClassName);  
  679.             System.out.println("获得列" + i + "在数据库中类型的最大字符个数:" + columnDisplaySize);  
  680.             System.out.println("获得列" + i + "的默认的列的标题:" + columnLabel);  
  681.             System.out.println("获得列" + i + "的模式:" + schemaName);  
  682.             System.out.println("获得列" + i + "类型的精确度(类型的长度):" + precision);  
  683.             System.out.println("获得列" + i + "小数点后的位数:" + scale);  
  684.             System.out.println("获得列" + i + "对应的表名:" + tableName);  
  685.             System.out.println("获得列" + i + "是否自动递增:" + isAutoInctement);  
  686.             System.out.println("获得列" + i + "在数据库中是否为货币型:" + isCurrency);  
  687.             System.out.println("获得列" + i + "是否为空:" + isNullable);  
  688.             System.out.println("获得列" + i + "是否为只读:" + isReadOnly);  
  689.             System.out.println("获得列" + i + "能否出现在where中:" + isSearchable);  
  690.         }  
  691.     }  
  692.   
  693. }  
转自http://blog.csdn.net/renfufei/article/details/39316751/


需要整理后才能发布若转载请注明出处!若有疑问,请回复交流!

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
java数据库连接池dbcp的使用
<p></p> <p style="color:rgb(75,75,75); font-family:verdana,Arial,helvetica,sans-seriff; font-size:13px; line-height:19.200000762939453px"> 近年来,随着Internet/Intranet建网技术的飞速发展和在世界范围内的迅速普及,计算机</p> <
862 0
java使用JDBC连接MySql数据库
java使用JDBC连接MySql数据库 安装MySql 导入MySql驱动jar包 导入java.sql.*; 注册JDBC驱动程序 打开一个连接 执行一个查询 从结果集中提取数据 清理环境 安装MySql MySql下载链接 下载社区版(免费) 傻瓜式安装过程。安装完成之后打开MySQL Workbench(图形操作界面)添加数据库与数据。
2693 0
RDS MySQL 5.7三节点企业版重磅发布 企业级业务云上数据库首选
10月23日15:00 多名专家联袂讲解 https://yq.aliyun.com/live/1536 随着云计算技术的逐渐普及,使用云服务的客户行业、场景的边界也在不断地被拓宽,不断提出新的需求。
2888 0
RDS MySQL 5.7三节点企业版重磅发布 企业级业务云上数据库首选
随着云计算技术的逐渐普及,使用云服务的客户行业、场景的边界也在不断地被拓宽,不断提出新的需求。
0 0
AI公开课:19.05.29 浣军-百度大数据实验室主任《AutoDL 自动化深度学习建模的算法和应用》课堂笔记以及个人感悟
AI公开课:19.05.29 浣军-百度大数据实验室主任《AutoDL 自动化深度学习建模的算法和应用》课堂笔记以及个人感悟
0 0
使用ABAP(ADBC)和Java(JDBC)连接SAP HANA数据库
在表DBCON里维护一条记录,指向HANA数据库。con_ENV里填入HANA数据库的主机名和端口号。如vmXXXX:30015
0 0
+关注
java牛
善于分享,乐于分享
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载