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

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

JDBCHibernateJavaSQLC 
阅读更多 
/*  
 * 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;   
    }   
  
}

 

分享到：
| 泛型dao架构实现,封装crud等基本操作
评论
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 ...

Magicbox
Global site tag (gtag.js) - Google Analytics