Java中DatabaseMetaData 元数据信息

今天药忘吃喽~ 2022-06-17 02:13 173阅读 0赞

DatabaseMetaData的用法

一   、得到这个对象的实例

Connection con ;

con = DriverManager.getConnection(url,userName,password);

DatabaseMetaData dbmd = con.getMetaData();

二、方法getTables的用法

原型：

ResultSet DatabaseMetaData.getTables(String catalog,String schema,String tableName,String \[\]type)

此方法可返回结果集合ResultSet ，结果集中有5列， 超出会报越界异常

功能描述：得到指定参数的表信息

参数说明：

参数:catalog:目录名称，一般都为空.

参数：schema:[数据库][Link 1]名，对于[Oracle][]来说就用户名

参数：tablename:表名称

参数：type :表的类型(TABLE | VIEW)

注意：在使用过程中，参数名称必须使用大写的。否则得到什么东西。

三、方法getColumns的用法

功能描述：得到指定表的列信息。

原型：

ResultSet DatabaseMetaData getColumns(String catalog,String schema,String tableName,String columnName)

参数说明：

参数catalog : 类别名称

参数schema : 用户方案名称

参数tableName : 数据库表名称

参数columnName : 列名称

四、方法getPrimaryKeys的用法

功能描述：得到指定表的主键信息。

原型：

ResultSet DatabaseMetaData getPrimaryKeys(String catalog,String schema,String tableName)

参数说明：

参数catalog : 类别名称

参数schema : 用户方案名称

参数tableName : 数据库表名称

备注：一定要指定表名称，否则返回值将是什么都没有。

五、方法.getTypeInfo()的用法

功能描述：得到当前数据库的数据类型信息。

六、方法getExportedKeys的用法

功能描述：得到指定表的外键信息。

参数描述：

参数catalog : 类别名称

参数schema : 用户方案名称

参数tableName : 数据库表名称

DatabaseMetaData对象提供的是关于数据库的各种信息，这些信息包括：

1、数据库与用户，数据库标识符以及函数与存储过程。

2、数据库限制。

3、数据库支持不支持的功能。

4、[架构][Link 2]、编目、表、列和视图等。

通过调用DatabaseMetaData的各种方法，程序可以动态的了解一个数据库。由于这个类中的方法非常的多那么就介绍几个常用的方法来给大家参考。

DatabaseMetaData实例的获取方法是，通过连接来获得的

Connection conn = //创建的连接。

DatabaseMetaData dbmd = Conn.getMetaData();

创建了这个实例，就可以使用他的方法来获取数据库得信息。首先是数据库中用户标识符的信息的获得，主要使用如下的方法：

getDatabaseProductName()用以获得当前数据库是什么数据库。比如oracle，access等。返回的是字符串。

getDatabaseProductVersion()获得数据库的版本。返回的字符串。

getDriverVersion()获得驱动程序的版本。返回字符串。

supportsResultSetType(ResultSet.resultype)是判定是否支持这种结果集的类型。比如参数如果是Result.TYPE\_FORWARD\_ONLY,那就是判定是否支持，只能先前移动结果集的指针。返回值为boolean，true表示支持。

上面介绍的只是几个常用的方法，这个类中还有很多方法，可以到jdk的帮助文档中去查看类[Java][].sql.DatabaseMetaData。

这个类中还有一个比较常用的方法就是获得表的信息。使用的方法是：

getTables（String catalog,String schema,String tableName,String\[\] types），

这个方法带有四个参数，他们表示的含义如下：

String catalog——要获得表所在的编目。串“”””意味着没有任何编目，Null表示所有编目。

String schema——要获得表所在的模式。串“”””意味着没有任何模式，Null表示所有模式。该参数可以包含单字符的通配符（“\_”）,也可以包含多字符的通配符（“%”）。

String tableName——指出要返回表名与该参数匹配的那些表，该参数可以包含单字符的通配符（“\_”）,也可以包含多字符的通配符（“%”）。

String types——一个指出返回何种表的数组。可能的数组项是：”TABLE”，”VIEW”，”SYSTEM TABLE”，”GLOBAL TEMPORARY”，”LOCAL TEMPORARY”，”ALIAS”，“SYSNONYM”。

通过getTables（）方法返回一个表的信息的结果集。这个结果集包括字段有：TABLE\_CAT表所在的编目。TABLE\_SCHEM表所在的模式，TABLE\_NAME表的名称。TABLE\_TYPE标的类型。REMARKS一段解释性的备注。通过这些字段可以完成表的信息的获取。

还有两个方法一个是获得列getColumns(String catalog,String schama,String tablename,String columnPattern)一个是获得关键字的方法getPrimaryKeys(String?catalog, String?schema, String?table)这两个方法中的参数的含义和上面的介绍的是相同的。凡是pattern的都是可以用通配符匹配的。getColums()返回的是结果集，这个结果集包括了列的所有信息，类型，名称，可否为空等。getPrimaryKey（）则是返回了某个表的关键字的结果集。

通过getTables（），getColumns（），getPrimaryKeys（）就可以完成表的反向设计了。主要步骤如下：

1、通过getTables()获得数据库中表的信息。

2、对于每个表使用，getColumns(),getPrimaryKeys()获得相应的列名，类型，限制条件，关键字等。

3、通过1，2获得信息可以生成相应的建表的SQL语句。

通过上述三步完成反向设计表的过程。

获取[数据库][Link 3]的相关信息：

1.获得数据库的一些相关信息

2.获得该用户下面的所有表

3.获得该用户下面的所有视图

4.获得数据库中所有方案名称

5.获得表或视图中的所有列信息

6. 获得一个表的索引信息

7.获得一个表的主键信息

8.获得一个表的外键信息

**\[java\]**  [view plain][]  [copy][view plain]

1.  **package** com.zsw.test;  
2.    
3.    
4.  **import** java.sql.Connection;  
5.  **import** java.sql.DatabaseMetaData;  
6.  **import** java.sql.DriverManager;  
7.  **import** java.sql.ResultSet;  
8.  **import** java.sql.SQLException;  
9.    
10.   
11. **public** **class** DatabaseMetaDateApplication \{  
12.   
13.   
14.     **private** DatabaseMetaData dbMetaData = **null**;  
15.     **private** Connection con = **null**;  
16.   
17.   
18.     **public** DatabaseMetaDateApplication() \{  
19.         **this**.getDatabaseMetaData();  
20.     \}  
21.   
22.   
23.     **private** **void** getDatabaseMetaData() \{  
24.         **try** \{  
25.             **if** (dbMetaData == **null**) \{  
26.                 Class.forName("com.mysql.jdbc.Driver");  
27.                 String url = "jdbc:mysql://localhost:3306/creation\_cms";  
28.                 String user = "root";  
29.                 String password = "root";  
30.                 con = DriverManager.getConnection(url, user, password);  
31.                 dbMetaData = con.getMetaData();  
32.             \}  
33.         \} **catch** (ClassNotFoundException e) \{  
34.             e.printStackTrace();  
35.         \} **catch** (SQLException e) \{  
36.             e.printStackTrace();  
37.         \}  
38.     \}  
39.   
40.   
41.     /\*\* 
42.      \* 获得数据库的一些相关信息 
43.      \*/  
44.     **public** **void** getDataBaseInformations() \{  
45.         **try** \{             
46.             System.out.println("数据库已知的用户: "\+ dbMetaData.getUserName());    
47.             System.out.println("数据库的系统函数的逗号分隔列表: "\+ dbMetaData.getSystemFunctions());    
48.             System.out.println("数据库的时间和日期函数的逗号分隔列表: "\+ dbMetaData.getTimeDateFunctions());    
49.             System.out.println("数据库的字符串函数的逗号分隔列表: "\+ dbMetaData.getStringFunctions());    
50.             System.out.println("数据库供应商用于 'schema' 的首选术语: "\+ dbMetaData.getSchemaTerm());    
51.             System.out.println("数据库URL: " + dbMetaData.getURL());    
52.             System.out.println("是否允许只读:" + dbMetaData.isReadOnly());    
53.             System.out.println("数据库的产品名称:" + dbMetaData.getDatabaseProductName());    
54.             System.out.println("数据库的版本:" + dbMetaData.getDatabaseProductVersion());    
55.             System.out.println("驱动程序的名称:" + dbMetaData.getDriverName());    
56.             System.out.println("驱动程序的版本:" + dbMetaData.getDriverVersion());   
57.   
58.   
59.             System.out.println();    
60.             System.out.println("数据库中使用的表类型");    
61.             ResultSet rs = dbMetaData.getTableTypes();    
62.             **while** (rs.next()) \{    
63.                 System.out.println(rs.getString(1));    
64.             \}    
65.             rs.close();                
66.             System.out.println();  
67.         \} **catch** (SQLException e) \{  
68.             e.printStackTrace();  
69.         \}  
70.     \}  
71.   
72.   
73.     /\*\* 
74.      \* 获得该用户下面的所有表 
75.      \*/  
76.     **public** **void** getAllTableList(String schemaName) \{  
77.         **try** \{  
78.             // table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".  
79.             String\[\] types = \{ "TABLE" \};  
80.             ResultSet rs = dbMetaData.getTables(**null**, schemaName, "%", types);  
81.             **while** (rs.next()) \{  
82.                 String tableName = rs.getString("TABLE\_NAME");  //表名  
83.                 String tableType = rs.getString("TABLE\_TYPE");  //表类型  
84.                 String remarks = rs.getString("REMARKS");       //表备注  
85.                 System.out.println(tableName + "-" + tableType + "-" + remarks);  
86.             \}  
87.         \} **catch** (SQLException e) \{  
88.             e.printStackTrace();  
89.         \}  
90.     \}  
91.   
92.   
93.     /\*\* 
94.      \* 获得该用户下面的所有视图 
95.      \*/  
96.     **public** **void** getAllViewList(String schemaName) \{  
97.          **try**\{    
98.              String\[\] types = \{ "VIEW" \};                 
99.              ResultSet rs = dbMetaData.getTables(**null**, schemaName, "%", types);  
100.              **while** (rs.next())\{  
101.                  String viewName = rs.getString("TABLE\_NAME"); //视图名  
102.                  String viewType = rs.getString("TABLE\_TYPE"); //视图类型  
103.                  String remarks = rs.getString("REMARKS");      //视图备注  
104.                  System.out.println(viewName + "-" + viewType + "-" + remarks);  
105.              \}  
106.          \} **catch** (SQLException e) \{  
107.              e.printStackTrace();  
108.          \}  
109.     \}  
110.       
111.      /\*\*   
112.      \* 获得数据库中所有方案名称   
113.      \*/    
114.     **public** **void** getAllSchemas()\{  
115.         **try**\{  
116.             ResultSet rs = dbMetaData.getSchemas();   
117.             **while** (rs.next())\{     
118.                 String tableSchem = rs.getString("TABLE\_SCHEM");     
119.                 System.out.println(tableSchem);     
120.             \}     
121.         \} **catch** (SQLException e)\{  
122.             e.printStackTrace();     
123.         \}     
124.     \}     
125.   
126.   
127.     /\*\* 
128.      \* 获得表或视图中的所有列信息 
129.      \*/  
130.     **public** **void** getTableColumns(String schemaName, String tableName) \{  
131.            
132.         **try**\{     
133.                   
134.             ResultSet rs = dbMetaData.getColumns(**null**, schemaName, tableName, "%");              
135.             **while** (rs.next())\{  
136.                     String tableCat = rs.getString("TABLE\_CAT");//表目录（可能为空）                  
137.                     String tableSchemaName = rs.getString("TABLE\_SCHEM");//表的架构（可能为空）     
138.                     String tableName\_ = rs.getString("TABLE\_NAME");//表名  
139.                     String columnName = rs.getString("COLUMN\_NAME");//列名  
140.                     **int** dataType = rs.getInt("DATA\_TYPE"); //对应的java.sql.Types类型     
141.                     String dataTypeName = rs.getString("TYPE\_NAME");//java.sql.Types类型   名称  
142.                     **int** columnSize = rs.getInt("COLUMN\_SIZE");//列大小  
143.                     **int** decimalDigits = rs.getInt("DECIMAL\_DIGITS");//小数位数  
144.                     **int** numPrecRadix = rs.getInt("NUM\_PREC\_RADIX");//基数（通常是10或2）  
145.                     **int** nullAble = rs.getInt("NULLABLE");//是否允许为null  
146.                     String remarks = rs.getString("REMARKS");//列描述  
147.                     String columnDef = rs.getString("COLUMN\_DEF");//默认值  
148.                     **int** sqlDataType = rs.getInt("SQL\_DATA\_TYPE");//sql数据类型  
149.                     **int** sqlDatetimeSub = rs.getInt("SQL\_DATETIME\_SUB");   //SQL日期时间分?  
150.                     **int** charOctetLength = rs.getInt("CHAR\_OCTET\_LENGTH");   //char类型的列中的最大字节数  
151.                     **int** ordinalPosition = rs.getInt("ORDINAL\_POSITION");  //表中列的索引（从1开始）  
152.                       
153.                     /\*\* 
154.                      \* ISO规则用来确定某一列的为空性。 
155.                      \* 是---如果该参数可以包括空值; 
156.                      \* 无---如果参数不能包含空值 
157.                      \* 空字符串---如果参数为空性是未知的 
158.                      \*/  
159.                     String isNullAble = rs.getString("IS\_NULLABLE");  
160.                       
161.                     /\*\* 
162.                      \* 指示此列是否是自动递增 
163.                      \* 是---如果该列是自动递增 
164.                      \* 无---如果不是自动递增列 
165.                      \* 空字串---如果不能确定它是否 
166.                      \* 列是自动递增的参数是未知 
167.                      \*/  
168.                     String isAutoincrement = rs.getString("IS\_AUTOINCREMENT");     
169.                       
170.                     System.out.println(tableCat + "-" + tableSchemaName + "-" + tableName\_ + "-" + columnName + "-"    
171.                             + dataType + "-" + dataTypeName + "-" + columnSize + "-" + decimalDigits + "-" + numPrecRadix     
172.                             + "-" + nullAble + "-" + remarks + "-" + columnDef + "-" + sqlDataType + "-" + sqlDatetimeSub     
173.                             + charOctetLength + "-" + ordinalPosition + "-" + isNullAble + "-" + isAutoincrement + "-");     
174.                 \}     
175.             \} **catch** (SQLException e)\{  
176.                 e.printStackTrace();     
177.             \}  
178.     \}  
179.   
180.   
181.     /\*\* 
182.      \* 获得一个表的索引信息 
183.      \*/  
184.     **public** **void** getIndexInfo(String schemaName, String tableName) \{  
185.         **try**\{  
186.             ResultSet rs = dbMetaData.getIndexInfo(**null**, schemaName, tableName, **true**, **true**);  
187.             **while** (rs.next())\{  
188.                 **boolean** nonUnique = rs.getBoolean("NON\_UNIQUE");//非唯一索引(Can index values be non-unique. false when TYPE is  tableIndexStatistic   )  
189.                 String indexQualifier = rs.getString("INDEX\_QUALIFIER");//索引目录（可能为空）  
190.                 String indexName = rs.getString("INDEX\_NAME");//索引的名称  
191.                 **short** type = rs.getShort("TYPE");//索引类型  
192.                 **short** ordinalPosition = rs.getShort("ORDINAL\_POSITION");//在索引列顺序号  
193.                 String columnName = rs.getString("COLUMN\_NAME");//列名  
194.                 String ascOrDesc = rs.getString("ASC\_OR\_DESC");//列排序顺序:升序还是降序  
195.                 **int** cardinality = rs.getInt("CARDINALITY");   //基数  
196.                 System.out.println(nonUnique + "-" + indexQualifier + "-" + indexName + "-" + type + "-" + ordinalPosition + "-" + columnName + "-" + ascOrDesc + "-" + cardinality);     
197.             \}     
198.         \} **catch** (SQLException e)\{  
199.             e.printStackTrace();     
200.         \}   
201.     \}  
202.   
203.   
204.     /\*\* 
205.      \* 获得一个表的主键信息 
206.      \*/  
207.     **public** **void** getAllPrimaryKeys(String schemaName, String tableName) \{  
208.         **try**\{  
209.             ResultSet rs = dbMetaData.getPrimaryKeys(**null**, schemaName, tableName);  
210.             **while** (rs.next())\{  
211.                 String columnName = rs.getString("COLUMN\_NAME");//列名  
212.                 **short** keySeq = rs.getShort("KEY\_SEQ");//序列号(主键内值1表示第一列的主键，值2代表主键内的第二列)  
213.                 String pkName = rs.getString("PK\_NAME"); //主键名称    
214.                 System.out.println(columnName + "-" + keySeq + "-" + pkName);     
215.             \}  
216.         \}**catch** (SQLException e)\{  
217.             e.printStackTrace();  
218.         \}  
219.     \}  
220.   
221.   
222.     /\*\* 
223.      \* 获得一个表的外键信息 
224.      \*/  
225.     **public** **void** getAllExportedKeys(String schemaName, String tableName) \{  
226.           
227.         **try**\{  
228.             ResultSet rs = dbMetaData.getExportedKeys(**null**, schemaName, tableName);  
229.             **while** (rs.next())\{  
230.                 String pkTableCat = rs.getString("PKTABLE\_CAT");//主键表的目录（可能为空）  
231.                 String pkTableSchem = rs.getString("PKTABLE\_SCHEM");//主键表的架构（可能为空）  
232.                 String pkTableName = rs.getString("PKTABLE\_NAME");//主键表名   
233.                 String pkColumnName = rs.getString("PKCOLUMN\_NAME");//主键列名    
234.                 String fkTableCat = rs.getString("FKTABLE\_CAT");//外键的表的目录（可能为空）出口（可能为null）  
235.                 String fkTableSchem = rs.getString("FKTABLE\_SCHEM");//外键表的架构（可能为空）出口（可能为空）  
236.                 String fkTableName = rs.getString("FKTABLE\_NAME");//外键表名  
237.                 String fkColumnName = rs.getString("FKCOLUMN\_NAME"); //外键列名                  
238.                 **short** keySeq = rs.getShort("KEY\_SEQ");//序列号（外键内值1表示第一列的外键，值2代表在第二列的外键）。  
239.                   
240.                 /\*\* 
241.                  \* hat happens to foreign key when primary is updated:  
242.                  \* importedNoAction - do not allow update of primary key if it has been imported 
243.                  \* importedKeyCascade - change imported key to agree with primary key update  
244.                  \* importedKeySetNull - change imported key to NULL if its primary key has been updated 
245.                  \* importedKeySetDefault - change imported key to default values if its primary key has been updated 
246.                  \* importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x compatibility)    
247.                  \*/  
248.                 **short** updateRule = rs.getShort("UPDATE\_RULE");  
249.                   
250.                 /\*\* 
251.                  \* What happens to the foreign key when primary is deleted. 
252.                  \* importedKeyNoAction - do not allow delete of primary key if it has been imported 
253.                  \* importedKeyCascade - delete rows that import a deleted key  
254.                  \* importedKeySetNull - change imported key to NULL if its primary key has been deleted  
255.                  \* importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x compatibility) 
256.                  \* importedKeySetDefault - change imported key to default if its primary key has been deleted    
257.                  \*/  
258.                 **short** delRule = rs.getShort("DELETE\_RULE");  
259.                 String fkName = rs.getString("FK\_NAME");//外键的名称（可能为空）  
260.                 String pkName = rs.getString("PK\_NAME");//主键的名称（可能为空）  
261.                   
262.                 /\*\* 
263.                  \* can the evaluation of foreign key constraints be deferred until commit 
264.                  \* importedKeyInitiallyDeferred - see SQL92 for definition 
265.                  \* importedKeyInitiallyImmediate - see SQL92 for definition  
266.                  \* importedKeyNotDeferrable - see SQL92 for definition    
267.                  \*/  
268.                 **short** deferRability = rs.getShort("DEFERRABILITY");  
269.                   
270.                 System.out.println(pkTableCat + "-" + pkTableSchem + "-" + pkTableName + "-" + pkColumnName + "-"    
271.                         + fkTableCat + "-" + fkTableSchem + "-" + fkTableName + "-" + fkColumnName + "-" + keySeq + "-"    
272.                         + updateRule + "-" + delRule + "-" + fkName + "-" + pkName + "-" + deferRability);     
273.             \}  
274.         \} **catch** (SQLException e)\{  
275.             e.printStackTrace();     
276.         \}  
277.     \}  
278.   
279.   
280.     **public** **void** colseCon() \{  
281.         **try** \{  
282.             **if** (con != **null**) \{  
283.                 con.close();  
284.             \}  
285.         \} **catch** (SQLException e) \{  
286.             e.printStackTrace();  
287.         \}  
288.     \}  
289.   
290.   
291.     **public** **static** **void** main(String\[\] args) \{  
292.         DatabaseMetaDateApplication metaData = **new** DatabaseMetaDateApplication();  
293. //      metaData.getDataBaseInformations();  
294. //      metaData.getAllTableList(null);  
295. //      metaData.getAllViewList(null);  
296. //      metaData.getAllSchemas();  
297. //      metaData.getTableColumns(null, "zsc\_admin");  
298. //      metaData.getIndexInfo(null, "zsc\_admin");  
299. //      metaData.getAllPrimaryKeys(null, "zsc\_admin");  
300.         metaData.getAllExportedKeys(**null**, "zsc\_admin");  
301.           
302.           
303.     \}  
304.   
305.   
306. \}

[Link 1]: http://lib.csdn.net/base/mysql
[Oracle]: http://lib.csdn.net/base/oracle
[Link 2]: http://lib.csdn.net/base/architecture
[Java]: http://lib.csdn.net/base/javase
[Link 3]: http://lib.csdn.net/base/14
[view plain]: http://blog.csdn.net/sz_bdqn/article/details/7424080#