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

先贴代码,作为草稿:

第一个是工具类, 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/

需要整理后才能发布