`
hyj_dx
  • 浏览: 101379 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

我也SHOW下JDBC底层操作工具类

阅读更多
/*  
 * JDBCUtil.java  
 *  
 * Created on November 9, 2002, 4:27 PM  
 */  
  
package com.hyj.util;   
import java.sql.Connection;   
import java.sql.DatabaseMetaData;   
import java.sql.ResultSet;   
import java.sql.SQLException;   
import java.sql.Types;   
import java.util.HashMap;   
import java.util.HashSet;   
import java.util.LinkedList;   
import java.util.List;   
import java.util.Map;   
import java.util.Set;   
  
import net.sf.hibernate.Hibernate;   
import net.sf.hibernate.type.NullableType;   
  
import org.apache.commons.logging.Log;   
import org.apache.commons.logging.LogFactory;   
  
/**  
 *  
 * @author  Administrator  
 */  
public class JDBCUtil {   
    private static final Log logger = LogFactory.getLog(JDBCUtil.class);   
    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 getCatalogs(Connection c) throws SQLException {   
        DatabaseMetaData dmd = c.getMetaData();   
        ResultSet rs = null;   
        try {   
            rs = dmd.getCatalogs();   
            List l = new LinkedList();   
            while (rs.next()) {   
                l.add(rs.getString(1));   
            }   
            return l;   
        }   
        finally {   
            if (rs != null) rs.close();   
        }   
    }   
       
    public static Map getSchemas(Connection c) throws SQLException {   
        DatabaseMetaData dmd = c.getMetaData();   
        ResultSet rs = null;   
        try {   
            rs = dmd.getSchemas();   
            Map map = new HashMap();   
            List l;   
            while (rs.next()) {   
                String schema = rs.getString(1);   
                String catalog = null;   
                if (rs.getMetaData().getColumnCount() > 1) {   
                    catalog = rs.getString(2);   
                };   
                l = (List)map.get(catalog);   
                if (l == null) {   
                    l = new LinkedList();   
                    map.put(catalog, l);   
                }   
                l.add(schema);   
            }   
            return map;   
        }   
        finally {   
            if (rs != null) rs.close();   
        }   
    }   
       
    public static List getTables(Connection c, String catalog, String schema, String tablePattern) throws SQLException {   
        logger.debug("catalog='" + catalog + "'");   
        logger.debug("schema='" + schema + "'");   
        logger.debug("table='" + tablePattern + "'");   
        DatabaseMetaData dmd = c.getMetaData();   
        ResultSet rs = null;   
        try {   
            rs = dmd.getTables(catalog, schema, tablePattern, new String[] {"TABLE", "VIEW", "SYNONYM", "ALIAS"} );   
            List l= new LinkedList();   
            while (rs.next()) {   
                l.add(rs.getString(3));   
            }   
            return l;   
        }   
        finally {   
            if (rs != null) rs.close();   
        }   
    }   
       
    public static Set getForeignKeyColumns(Connection c, String catalog, String schema, String table) throws SQLException {   
        logger.debug("catalog='" + catalog + "'");   
        logger.debug("schema='" + schema + "'");   
        logger.debug("table='" + table + "'");   
        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 {   
        logger.debug("catalog='" + catalog + "'");   
        logger.debug("schema='" + schema + "'");   
        logger.debug("table='" + table + "'");   
        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();   
        }   
    }   
       
    public static List getTableColumns(Connection c, String catalog, String schema, String table) throws SQLException  {   
        return getTableColumns(c, catalog, schema, table, null);   
    }   
       
    public static List getTableColumns(Connection c, String catalog, String schema, String table, String columnPattern) throws SQLException {   
        logger.debug("catalog='" + catalog + "'");   
        logger.debug("schema='" + schema + "'");   
        logger.debug("table='" + table + "'");   
        logger.debug("column='" + columnPattern+ "'");   
        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 NullableType getHibernateType(int sqlType, int columnSize, int decimalDigits) {   
        logger.debug("sqlType=" + sqlType);   
        logger.debug("columnSize=" + columnSize);   
        logger.debug("decimalDigits=" + 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 Class getJavaType(int sqlType, int columnSize, int decimalDigits) {   
        logger.debug("sqlType=" + sqlType);   
        logger.debug("columnSize=" + columnSize);   
        logger.debug("decimalDigits=" + 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;   
    }   
  
}  

 

分享到:
评论
7 楼 hyj_dx 2008-11-30  
piziwang,我想可能是你的jdbc的版本是低级的,请使用oracle10G的jdbc驱动,或者最新版本的。
6 楼 piziwang 2008-11-28  
请问 hyj_dx,

   我在 oracle10g 下使用 DatabaseMetaData.getColumns(....)获取表结构报错:

java.sql.SQLException:ORA-01424: missing or illegal character following the escape character

说是“ResultSet columnRs = metaData.getColumns(null,"%", "USERTABLE", "%"); ”这一行有错误

我是这样写的:
     DatabaseMetaData metaData = connection.getMetaData();    

     ResultSet columnRs = metaData.getColumns(null,"%", "USERTABLE", "%"); 
 


这个方法获取 mysql 数据库表信息没有问题,但是访问 oracle就不行了, 请你帮我看看是什么原因啊??
5 楼 lanhuhe 2008-11-18  
还 可以 啊
4 楼 yucc77 2008-11-11  
楼主没有写注释的习惯!
3 楼 litianyi520 2008-11-10  
写sql更直观
2 楼 hyj_dx 2008-11-10  
是的,我前面有篇文章就是基于这个工具来做的代码生成器,自己想怎么生成就怎么生成,只要定义好模板
1 楼 longlongriver 2008-11-10  
呵呵,我也是用类似工具来获得整个数据库模型,并结合volicity来开发的代码生成器!

相关推荐

    JDBC技术.pdf

    MySQL提供了丰富的命令行工具和图形界面工具来进行数据库管理和操作,常见的基本操作包括: - 启动MySQL服务 - 显示数据库列表:`show databases;` - 使用数据库:`use &lt;数据库名&gt;;` - 显示数据库中的表:`show ...

    ShardingJDBC5.1.1按月分库分表、读写分离、自动创表完整demo

    在Mybatis-Plus的实体类和Mapper接口中,无需关心分片规则,ShardingJDBC会在底层自动处理。 五、总结 通过本示例,我们了解了如何利用ShardingJDBC 5.1.1实现按月分库分表、读写分离以及自动创表的功能。结合...

    springboot-sharding-jdbc

    在业务代码中,使用Spring Data JPA或者MyBatis等ORM框架,直接操作数据库,Sharding-JDBC会在底层自动处理分片逻辑。 四、注意事项 1. 分片策略设计应充分考虑业务需求,避免数据倾斜。 2. 范围分片时需注意边界...

    Java openPlantV4+ API

    总的来说,Java openPlantV4+ API 是一个针对实时数据库操作的高度封装工具,它通过JNI技术提高了性能,简化了API的使用,并提供了订阅功能以适应实时数据应用场景。开发者可以通过集成这个库,更轻松地在Java应用...

    hibernate反向生成数据库表.doc

    对于手动管理库的项目,需要将Hibernate的核心库、JDBC驱动和其他必要的库文件放入项目的类路径下。 接下来,我们需要配置Hibernate的核心配置文件`hibernate.cfg.xml`。这个文件定义了数据源以及连接到数据库所需...

    我的第一个hibernate程序

    在Java开发中,Hibernate是一个非常重要的持久化框架,它简化了数据库操作,使得开发者可以更加专注于业务逻辑,而非底层的SQL语法。本教程将引导你了解并实现“我的第一个Hibernate程序”,带你入门这个强大的ORM...

    hibernate.docx

    在Hibernate出现之前,直接使用JDBC进行数据库操作时,开发者往往需要手动处理连接管理和SQL语句编写等工作,这不仅增加了代码的复杂度,也带来了许多潜在的错误。Hibernate通过封装JDBC,极大地简化了数据库操作的...

    ITjob就业培训java教材34.doc

    - **理解Hibernate的工作原理:** Hibernate是一个开源的对象关系映射工具,它为Java应用程序提供了一种简化的方式,使得开发者可以更加高效地操作数据库。Hibernate内部封装了JDBC访问数据库的操作,并提供了一个...

    hibernate和spring技术难点及其要点总结

    1. **HibernateDaoSupport与JdbcDaoSupport**:Spring提供了这些支持类来简化DAO(数据访问对象)的实现,两者分别用于Hibernate和JDBC操作。它们提供了事务管理和数据源的便捷接入。 **三、Hibernate的查询方式** ...

    JPA笔记

    总的来说,JPA是Java开发中用于数据库操作的强大工具,它简化了数据库的管理和对象关系映射,提高了开发效率,同时也保持了良好的可移植性。通过理解并熟练运用JPA,开发者可以更加专注于业务逻辑,而不是数据库细节...

    hibernate学习资料

    6. **生成DDL脚本**:使用工具类生成DDL(Data Definition Language)脚本来创建数据库表。 7. **编写客户端代码**:创建客户端代码,通过Hibernate API来执行数据的增删改查操作。 8. **调试与日志记录**:配置log4...

    spring整合hibernate

    Spring 通过提供一系列 DAO 支持机制,使得应用程序能够在统一的接口下操作数据库,无论底层的数据访问技术是 JDBC、Hibernate 还是其他 ORM 工具。这种统一性极大地方便了开发者,使他们可以更加专注于业务逻辑的...

    hibernate.cfg.xml 配置 和数据库驱动

    在Java Web开发中,Hibernate是一个非常流行的持久化框架,它简化了数据库操作,使开发者能够更专注于业务逻辑而不是底层数据存储。而`hibernate.cfg.xml`文件是Hibernate的核心配置文件,用于设置数据库连接参数、...

    struts2 与 hibernate 整合 写得非常详细 简单易懂

    整合Struts2和Hibernate可以使你在开发过程中专注于业务逻辑,而不必关心底层数据库操作的细节。这种方式提高了开发效率,同时使得代码更加模块化,易于维护和扩展。在实际项目中,还可以结合其他框架,如Spring,...

    Hibernate新手上路

    ORM框架的主要目标是消除直接的JDBC操作,通过提供一套高级API,使得开发者可以使用面向对象的方式来操作数据库,而无需关注底层的SQL语句。 在Hibernate中,各个jar文件各自扮演着关键的角色: 1. `hibernate3....

    Hibernate PPT-1

    5. **Transaction**:Transaction对象代表了数据库的原子操作单元,它可以抽象底层的JDBC、JTA或CORBA事务。一个Session可以包含多个Transaction,但事务边界管理是必不可少的。 **配置**:Hibernate的配置通常涉及...

    hibenater笔记.pdf

    7. **编写hbm2ddl工具类**:该工具类用于根据实体类自动生成对应的数据库表结构。 8. **开发客户端**:编写Java程序来调用Hibernate提供的API进行数据库操作。 为了便于查看SQL语句的执行情况,可以在`hibernate....

    Spring和openJPA集成

    Spring 和 OpenJPA 的结合提供了强大而灵活的数据访问机制,使得开发者可以专注于业务逻辑,而不是底层的数据库操作。同时,Spring 的 AOP 支持使得事务管理变得简单,提高了代码的可维护性和可扩展性。通过不断优化...

    Hibernate笔记

    - **定义**:POJO (Plain Old Java Object) 类是指普通的 JavaBean 对象,它没有继承任何特定的类,也不需要实现任何特定的接口。在 Hibernate 中,POJO 类通常用来表示数据模型。 - **特点**: - 简单易懂:POJO ...

Global site tag (gtag.js) - Google Analytics