import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import org.hibernate.Hibernate;
import org.hibernate.type.NullableType;
public class JDBCUtil {
public static class Column {
public String name;
public int sqlType;
public int sqlColumnLength;
public int sqlDecimalLength;
public boolean sqlNotNull;
public boolean sqlReadOnly;
public NullableType hibernateType;
public Class javaType;
public String sqlTypeName;
public String defalutValue;
public boolean equals(Object o) {
boolean rv = false;
if (o != null && o instanceof JDBCUtil.Column) {
rv = (name.equals(((JDBCUtil.Column)o).name));
}
return rv;
}
public int hashCode() {
return (name != null) ? name.hashCode() : 0;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public NullableType getHibernateType() {
return hibernateType;
}
public void setHibernateType(NullableType hibernateType) {
this.hibernateType = hibernateType;
}
public Class getJavaType() {
return javaType;
}
public void setJavaType(Class javaType) {
this.javaType = javaType;
}
public int getSqlColumnLength() {
return sqlColumnLength;
}
public void setSqlColumnLength(int sqlColumnLength) {
this.sqlColumnLength = sqlColumnLength;
}
public int getSqlDecimalLength() {
return sqlDecimalLength;
}
public void setSqlDecimalLength(int sqlDecimalLength) {
this.sqlDecimalLength = sqlDecimalLength;
}
public boolean isSqlNotNull() {
return sqlNotNull;
}
public void setSqlNotNull(boolean sqlNotNull) {
this.sqlNotNull = sqlNotNull;
}
public boolean isSqlReadOnly() {
return sqlReadOnly;
}
public void setSqlReadOnly(boolean sqlReadOnly) {
this.sqlReadOnly = sqlReadOnly;
}
public int getSqlType() {
return sqlType;
}
public void setSqlType(int sqlType) {
this.sqlType = sqlType;
}
public String getSqlTypeName() {
return sqlTypeName;
}
public void setSqlTypeName(String sqlTypeName) {
this.sqlTypeName = sqlTypeName;
}
public String getDefalutValue() {
return defalutValue;
}
public void setDefalutValue(String defalutValue) {
this.defalutValue = defalutValue;
}
};
public static List getTableColumns(Connection c, String catalog, String schema, String table, String columnPattern) throws SQLException {
DatabaseMetaData dmd = c.getMetaData();
ResultSet rs = null;
try {
rs = dmd.getColumns(catalog, schema, table, columnPattern);
List columns = new LinkedList();
while (rs.next()) {
JDBCUtil.Column aCol = new JDBCUtil.Column();
aCol.sqlTypeName = rs.getString(6);
aCol.defalutValue = rs.getString(13);
aCol.name = rs.getString(4);
aCol.sqlType = rs.getShort(5);
aCol.sqlColumnLength=rs.getInt(7);
aCol.sqlDecimalLength=rs.getInt(9);
aCol.sqlNotNull = ("NO".equals(rs.getString(18)));
aCol.hibernateType = getHibernateType(
aCol.sqlType,
aCol.sqlColumnLength,
aCol.sqlDecimalLength
);
aCol.javaType = getJavaType(
aCol.sqlType,
aCol.sqlColumnLength,
aCol.sqlDecimalLength
);
columns.add(aCol);
}
return columns;
}
finally {
if (rs != null) rs.close();
}
}
public static Class getJavaType(int sqlType, int columnSize, int decimalDigits) {
Class rv=String.class;
if (sqlType == Types.CHAR || sqlType == Types.VARCHAR) {
rv = String.class;
}
else if (sqlType == Types.FLOAT || sqlType == Types.REAL) {
rv = Float.class;
}
else if (sqlType == Types.INTEGER) {
rv = Integer.class;
}
else if (sqlType == Types.DOUBLE) {
rv = Double.class;
}
else if (sqlType == Types.DATE) {
//rv = java.util.Date.class;
rv = String.class;
}
else if (sqlType == Types.TIMESTAMP) {
//rv = java.util.Date.class;
rv = String.class;
}
else if (sqlType == Types.TIME) {
//rv = java.util.Date.class;
rv = String.class;
}
// commented to support JDK version < 1.4
/* else if (sqlType == Types.BOOLEAN) {
rv = Boolean.class;
} */
else if (sqlType == Types.SMALLINT) {
rv = Short.class;
}
else if (sqlType == Types.BIT) {
// rv = Byte.class;
rv = Integer.class;
}
else if (sqlType == Types.BIGINT) {
rv = Long.class;
}
else if (sqlType == Types.NUMERIC || sqlType == Types.DECIMAL) {
if (decimalDigits == 0) {
if (columnSize == 1) {
// rv = Byte.class;
rv= Integer.class;
}
else if (columnSize < 5) {
rv = Short.class;
}
else if (columnSize < 10) {
rv = Integer.class;
}
else {
rv = Long.class;
}
}
else {
if (columnSize < 9) {
rv = Float.class;
}
else {
rv = Double.class;
}
}
}
return rv;
}
public static NullableType getHibernateType(int sqlType, int columnSize, int decimalDigits) {
NullableType rv=Hibernate.SERIALIZABLE;
if (sqlType == Types.CHAR || sqlType == Types.VARCHAR) {
rv = Hibernate.STRING;
}
else if (sqlType == Types.FLOAT || sqlType == Types.REAL) {
rv = Hibernate.FLOAT;
}
else if (sqlType == Types.INTEGER) {
rv = Hibernate.INTEGER;
}
else if (sqlType == Types.DOUBLE) {
rv = Hibernate.DOUBLE;
}
else if (sqlType == Types.DATE) {
rv = Hibernate.DATE;
}
else if (sqlType == Types.TIMESTAMP) {
rv = Hibernate.TIMESTAMP;
}
else if (sqlType == Types.TIME) {
rv = Hibernate.TIME;
}
// commented to support JDK version < 1.4
/* else if (sqlType == Types.BOOLEAN) {
rv = Hibernate.BOOLEAN;
. } */
else if (sqlType == Types.SMALLINT) {
rv = Hibernate.SHORT;
}
else if (sqlType == Types.BIT) {
rv = Hibernate.BYTE;
}
else if (sqlType == Types.BIGINT) {
rv = Hibernate.LONG;
}
else if (sqlType == Types.NUMERIC || sqlType == Types.DECIMAL) {
if (decimalDigits == 0) {
if (columnSize == 1) {
rv = Hibernate.BYTE;
}
else if (columnSize < 5) {
rv = Hibernate.SHORT;
}
else if (columnSize < 10) {
rv = Hibernate.INTEGER;
}
else {
rv = Hibernate.LONG;
}
}
else {
if (columnSize < 9) {
rv = Hibernate.FLOAT;
}
else {
rv = Hibernate.DOUBLE;
}
}
}
return rv;
}
public static List getTableColumns(Connection c, String catalog, String schema, String table) throws SQLException {
return getTableColumns(c, catalog, schema, table, null);
}
public static Set getForeignKeyColumns(Connection c, String catalog, String schema, String table) throws SQLException {
DatabaseMetaData dmd = c.getMetaData();
ResultSet rs = null;
try {
rs = dmd.getImportedKeys(catalog, schema, table);
HashSet columns = new HashSet();
while (rs.next()) {
columns.add(rs.getString(8));
}
return columns;
}
finally {
if (rs != null) rs.close();
}
}
public static List getPrimaryKeyColumns(Connection c, String catalog, String schema, String table) throws SQLException {
DatabaseMetaData dmd = c.getMetaData();
ResultSet rs = null;
try {
rs = dmd.getPrimaryKeys(catalog, schema, table);
List pkColumns = new LinkedList();;
while (rs.next()) {
List tmp = getTableColumns(c, catalog, schema, table, rs.getString(4));
Column pkColumn = (Column)tmp.get(0);
pkColumns.add(pkColumn);
}
return pkColumns;
}
finally {
if (rs != null) rs.close();
}
}
获取主键是没问题的。。但外键就拿不到了。。
那个获取外键的。。我怎么弄也是查不出来。。又不报错。。甚至连我表名打错也没报错~麻烦大家能不能帮我找下原因。。
添加评论
关注(0)
相关推荐
请注意，这只是一个基本示例，实际的`JdbcUtil`类通常会包含更复杂的功能，如异常处理、连接池的使用等。 连接池是一种优化数据库连接管理的技术，它可以复用已建立的数据库连接，减少频繁创建和销毁连接的开销。...
JdbcUtil是一个常见的工具类，它封装了JDBC的基本操作，以简化数据库的访问，减少代码量，并提高代码的可维护性。下面将详细阐述JdbcUtil中的主要知识点及其重要性。 1. **连接管理**：JdbcUtil通常包含建立和关闭...
【标题】"自己写的jdbcUtil"揭示了这个项目的核心是一个自定义实现的Java数据库连接工具类，即JDBC Utility。JDBC（Java Database Connectivity）是Java语言中用来规范客户端程序如何访问数据库的应用程序接口，提供...
`JdbcUtil`通常是一个工具类，用于封装JDBC的常用操作，以简化数据库访问流程，提高代码的可复用性和可维护性。 `JdbcUtil`类的基本结构通常包括以下几个部分： 1. **数据库连接的建立和关闭**：使用`...
JdbcUtil是一个常见的实用类，用于封装数据库连接、查询、更新等基本操作，以提高代码的可读性和可维护性，避免资源泄露。在给定的"JdbcUtil.rar_jdbcUtil_jdbcut"压缩包中，包含的文件"JdbcUtil"可能是这个工具类的...
`JDBCUtil`通常是指一个实用工具类，它封装了与数据库交互的常见操作，如建立连接、执行SQL语句、处理结果集等。这个`JDBCUtil.rar_jdbcUtil`压缩包可能包含了实现这些功能的代码示例。接下来，我们将深入探讨JDBC...
将java开发过程中连接数据库的过程...本工具主要遵循"既有默认规则，又可灵活配置"的原则，通过编写通用的basedao，实现通用的数据库连接过程，通过配置文件实现连接指定的数据库，继而实现可让用户灵活配置的原则。
`JdbcUtil.java` 是一个Java类，用于简化使用JDBC（Java Database Connectivity）操作数据库的过程。这个类主要包含了四个静态方法：`getConnection()`, `close()`, `toInt()` 和 `printRs()`。 1. **静态初始化块*...
* 一。JDBC流程 * * 1.加载类文件： 类文件只需要加载到内存一次即可 * 2.建立连接通道 * 3.建立交通工具 * 4.推送命令并得到处理结果 * 5.销毁相关资源 连接通道建立 交通工具创建 推送sql命令并带回处理...
JdbcUtil.java
首先，`BaseDAO`是一个设计模式，用于封装数据库的基本操作，如增、删、改、查。它的出现是为了减少代码的重复性，提高代码的可复用性和可维护性。`BaseDAO`通常会定义一些通用的方法，比如获取单个对象、获取集合、...
总之，Java JDBC AutoClose的JDBCUtil是一个实用的工具，它整合了自动资源关闭和数据库操作的最佳实践，为Java开发者提供了更便捷、安全的数据库访问方式，尤其适用于频繁的数据库操作场景。在实际项目中，类似的...
`JdbcUtil_2.rar_jdbcut` 指的可能是一个包含简化了JDBC操作的实用工具类，它的目的是为了简化数据库连接和操作的过程，使得开发者可以更快速、便捷地完成数据库交互任务。 在描述中提到的“用jdbc连接数据库的小...
基于反射的JDBCUtil的工具类，通过配置文件加载数据库连接资源，实现简单的CRUD操作
`JdbcUtil`类是开发者为了简化JDBC操作而自定义的一个工具类，它封装了JDBC的一些常用功能，以便更方便、高效地进行数据库交互。下面我们将详细探讨JDBC的基础知识，以及`JdbcUtil`类的设计思想和实现方法。 首先，...
JDBCUtil.class