先贴代码,作为草稿:

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

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

需要整理后才能发布

使用JDBC获取各数据库的Meta信息——表以及对应的列的更多相关文章

  1. C#获取Access数据库中的所有表名和列名

    //C#获取Access数据库中的所有表名和列名    string ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;" ...

  2. Java连接MySQL数据库。编写一个应用程序，在主类Test_4类中，通过JDBC访问stu数据库，显示t_student表中的内容（表结构见表1），显示效果自己设计。

    题目2:编写一个应用程序,在主类Test_4类中,通过JDBC访问stu数据库,显示t_student表中的内容(表结构见表1),显示效果自己设计.之后,可根据显示的内容进行某条记录的删除(以id为条 ...

  3. servlet+jsp+jdbc实现从数据库查询用户信息到页面

    工程创建这里就不在累述了,直接从显示User信息列表开始. 备注:我用的是servlet3的注解功能实现的,所以不需要配置web.xml 这是我的工程目录: 首先我们创建实体类: public cla ...

  4. 获取ORACLE数据库的构建信息

    首先连接到数据库,获取ORACLE数据库的基本信息: C:\USERS\ADMINISTRATOR>SQLPLUS/NOLOG SQL*PLUS: RELEASE 10.2.0.3.0 - PR ...

  5. java数据库 JDBC操作MySQL数据库常用API 部门表和员工表 创建表 添加数据 查询数据

    package com.swift.department; import java.sql.Connection; import java.sql.PreparedStatement; import ...

  6. SQLSERVER如何获取一个数据库中的所有表的名称、一个表中所有字段的名称

    1.查询数据库中的所有数据库名: SELECT Name FROM Master..SysDatabases ORDER BY Name 2.查询某个数据库中所有的表名: SELECT Name FR ...

  7. [转]SQLSERVER如何获取一个数据库中的所有表的名称、一个表中所有字段的名称

    1.查询数据库中的所有数据库名: SELECT Name FROM Master..SysDatabases ORDER BY Name 2.查询某个数据库中所有的表名: SELECT Name FR ...

  8. jsp页面显示数据库的数据信息表

    在日常jsp开发中:最基本的一个操作之一是把之前添加到数据库中的信息在jsp页面中显示出来,也就是增删改查中的查找的一部分: 下面是以上部分的开发步骤及分析. 1.在jsp页面: <thead& ...

  9. python MySQL 获取全部数据库(DATABASE)名、表(TABLE)名

    import MySQLdb #connect try: conn = MySQLdb.connect( host = "localhost", user = "root ...

随机推荐

  1. express的session函数

    key:这个表示session返回来的cookie的键值, 我们整理一下哈: 这个是我们没有清缓存然后刷新了一下哈,对比的结果,发现session保存的数据中,只是expires这个改变了 { &qu ...

  2. [USACO2005][POJ2454]Jersey Politics（随机化）

    题目:http://poj.org/problem?id=2454 题意:给你3*k(k<=60)个数,你要将它们分成3个长度为k的序列,使得其中至少有两个序列的和大于k*500 分析:以为有高 ...

  3. 20.C#LINQ基础和简单使用(十一章11.1-11.2)

    终于看到了第11章,之前虽然也有看过,但没有太仔细,在工作中也偶尔会使用,但不明白其中的原理,那现在就来讲讲LINQ,做一做书虫~~ 首先先了解下LINQ的三个要点: LINQ不能把非常复杂的查询表达 ...

  4. rational rose USE CASE

  5. Ibatis学习总结4--SQL Map XML 映射文件扩展

    SQL Map XML 映射文件除了上文提到的属性还有一些其他重要的属性,下文将详细介绍这些属性. 缓存 Mapped Statement 结果集 通过在查询 statement 中指定 cacheM ...

  6. win10 1607 安装密钥 GVLK

    Core=YTMG3-N6DKC-DKB77-7M9GH-8HVX7 Professional=VK7JG-NPHTM-C97JM-9MPGT-3V66T Enterprise=XGVPP-NMH47 ...

  7. CoreOS Architecture Learning

    目录 . CoreOS简介 . CoreOS部署.安装.使用 . CoreOS命令使用 1. CoreOS简介 0x1: CoreOS和Docker的关系 我们先来看一张Docker的架构图

  8. 系​统​吞​吐​量​(​T​P​S​)​、​用​户​并​发​量​、​性​能​测​试、IO负载学习

    目录 . 如何评价一个系统的性能 . 系统吞度量 . 网络上下行数据量 . 客户端-服务端TCP同时长连接数量 . 系统性能的指标计算 . 系统IO负载 1. 如何评价一个系统的性能 在文章的开始,我 ...

  9. hihocoder 1154 Spring Outing

    传送门 #1154 : Spring Outing 时间限制:20000ms 单点时限:1000ms 内存限制:256MB 描述 You class are planning for a spring ...

  10. 一个完整的编译器前端-A.1 源语言

    这个语言的一个程序由一个块组成,该块中包含可选的声明和语句.语法符号basic表示基本类型. program –> block block   –> { decls stmts } dec ...