从数据连接获取表信息

最新推荐文章于 2024-08-15 13:27:56 发布
最新推荐文章于 2024-08-15 13:27:56 发布
阅读量253 收藏 1
点赞数
分类专栏： java 文章标签： 数据库 oracle mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ningxuezhu/article/details/119928263
版权

从数据连接获取表信息

适配所有的数据库，如：oracle、mysql等。里面用到的异常请删除即可。

需要引入hutool jar 包

  			<dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.5.5</version>
            </dependency>


import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.dingxuan.sky.data.database.entity.ColumnInfo;
import com.dingxuan.sky.data.database.entity.TableInfo;
import com.dingxuan.sky.data.enums.SkyDataErrorCodeEnum;
import com.dingxuan.sky.data.exception.SkyDataRuntimeException;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;

public class TableInfoFactory extends AbstractDatabase {

    private static final Logger logger = LoggerFactory.getLogger(TableInfoFactory.class);

    protected TableInfoFactory(SqlSessionTemplate sqlSessionTemplate){
        super(sqlSessionTemplate);
    }

    public static TableInfoFactory instance() {
        return TableInfoFactory.TableInfoFactoryEnum.SINGLETON.getInstance();
    }

    private enum TableInfoFactoryEnum {

                                      /**
                                       * 单例
                                       */
                                      SINGLETON;

        /**
         *
         */
        private final TableInfoFactory instances;

        /**
         * 构造器
         */
        TableInfoFactoryEnum(){
            instances = new TableInfoFactory(SpringUtil.getBean(SqlSessionTemplate.class));
        }

        private TableInfoFactory getInstance() {
            return instances;
        }
    }

    public List<TableInfo> getTables() {
        return getTables(null);
    }

    /**
     * 获取当前链接的 catalog、schema对应的 表信息
     * 
     * @return 所有表的集合
     */
    public List<TableInfo> getTables(String schema) {
        List<TableInfo> tableInfos = new ArrayList<>();
        Connection connection;
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rs = metaData.getTables(catalog, schema, null, new String[] { "TABLE" });
            while (rs.next()) {
                TableInfo tableInfo = new TableInfo();
                tableInfo.setTableCat(catalog);
                tableInfo.setTableName(rs.getString("TABLE_NAME"));
                tableInfo.setTableType(rs.getString("TABLE_TYPE"));
                tableInfo.setTableSchema(schema);
                tableInfo.setRemarks(rs.getString("REMARKS"));
                tableInfo.setTableNameCamel(StrUtil.toCamelCase(rs.getString("TABLE_NAME")));
                tableInfos.add(tableInfo);
            }
        } catch (Exception e) {
            logger.error("从METADATA获取所有表信息失败", e);
        } finally {
            super.closeSqlSession(sqlSession);
        }
        return tableInfos;
    }

    public TableInfo getTable(String tableName) {
        return getTable(tableName, null);
    }

    public TableInfo getTable(String tableName, String schema) {
        TableInfo tableInfo = new TableInfo();
        Connection connection;
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rs = metaData.getTables(catalog, schema, tableName, new String[] { "TABLE" });
            while (rs.next()) {
                tableInfo.setTableCat(catalog);
                tableInfo.setTableName(rs.getString("TABLE_NAME"));
                tableInfo.setTableType(rs.getString("TABLE_TYPE"));
                tableInfo.setTableSchema(schema);
                tableInfo.setRemarks(rs.getString("REMARKS"));
                tableInfo.setTableNameCamel(StrUtil.toCamelCase(rs.getString("TABLE_NAME")));
            }
        } catch (Exception e) {
            logger.error("从METADATA获取所有表信息失败", e);
        } finally {
            super.closeSqlSession(sqlSession);
        }
        return tableInfo;
    }

    public List<ColumnInfo> getColumns(String tableName) {
        return getColumns(tableName, null);
    }

    /**
     * 获取当前链接的 catalog、schema对应的 表的列的信息
     *
     * @return 所有表的集合
     */
    public List<ColumnInfo> getColumns(String tableName, String schema) {
        List<ColumnInfo> columnInfos = new ArrayList<>();
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            Connection connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rs = metaData.getColumns(catalog, schema, tableName, null);
            while (rs.next()) {
                ColumnInfo columnInfo = new ColumnInfo();
                columnInfo.setColumnName(rs.getString("COLUMN_NAME"));
                columnInfo.setDataType(rs.getString("DATA_TYPE"));
                columnInfo.setTypeName(rs.getString("TYPE_NAME"));
                columnInfo.setColumnSize(rs.getString("COLUMN_SIZE"));
                columnInfo.setColumnNameCamel(StrUtil.toCamelCase(rs.getString("COLUMN_NAME")));
                columnInfo.setIsNullable(rs.getString("IS_NULLABLE"));
                columnInfo.setRemarks(rs.getString("REMARKS"));
                columnInfo.setCharOctetLength(rs.getString("CHAR_OCTET_LENGTH"));
                columnInfos.add(columnInfo);
            }
        } catch (Exception e) {
            logger.error("从METADATA获取表的所有列信息失败", e);
  
        } finally {
            super.closeSqlSession(sqlSession);
        }
        return columnInfos;
    }

    public ColumnInfo getColumn(String tableName, String columnName) {
        return getColumn(tableName, columnName, null);
    }

    public ColumnInfo getColumn(String tableName, String columnName, String schema) {
        ColumnInfo columnInfo = new ColumnInfo();
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            Connection connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rs = metaData.getColumns(catalog, schema, tableName, columnName);
            while (rs.next()) {
                columnInfo.setColumnName(rs.getString("COLUMN_NAME"));
                columnInfo.setDataType(rs.getString("DATA_TYPE"));
                columnInfo.setTypeName(rs.getString("TYPE_NAME"));
                columnInfo.setColumnSize(rs.getString("COLUMN_SIZE"));
                columnInfo.setColumnNameCamel(StrUtil.toCamelCase(rs.getString("COLUMN_NAME")));
                columnInfo.setIsNullable(rs.getString("IS_NULLABLE"));
                columnInfo.setRemarks(rs.getString("REMARKS"));
                columnInfo.setCharOctetLength(rs.getString("CHAR_OCTET_LENGTH"));
            }
        } catch (Exception e) {
            logger.error("从METADATA获取表的所有列信息失败", e);

        } finally {
            super.closeSqlSession(sqlSession);
        }
        return columnInfo;
    }

    public List<TableInfo> getTableColumns() {
        return getTableColumns(null);
    }

    /**
     * 获取当前链接的 catalog、schema对应的 所有表的列的信息
     *
     * @return 所有表的集合
     */
    public List<TableInfo> getTableColumns(String schema) {
        List<TableInfo> tableInfos = new ArrayList<>();
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            Connection connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rsTable = metaData.getTables(catalog, schema, null, new String[] { "TABLE" });
            while (rsTable.next()) {
                TableInfo tableInfo = new TableInfo();
                tableInfo.setTableCat(catalog);
                tableInfo.setTableName(rsTable.getString("TABLE_NAME"));
                tableInfo.setTableType(rsTable.getString("TABLE_TYPE"));
                tableInfo.setTableSchema(schema);
                tableInfo.setRemarks(rsTable.getString("REMARKS"));
                tableInfo.setTableNameCamel(StrUtil.toCamelCase(rsTable.getString("TABLE_NAME")));
                tableInfos.add(tableInfo);

            }
            if (CollectionUtil.isNotEmpty(tableInfos)) {
                for (TableInfo tableInfo : tableInfos) {
                    ResultSet rsColumn = metaData.getColumns(catalog, schema, tableInfo.getTableName(), null);
                    List<ColumnInfo> columnInfos = new ArrayList<>();
                    while (rsColumn.next()) {
                        ColumnInfo columnInfo = new ColumnInfo();
                        columnInfo.setColumnName(rsColumn.getString("COLUMN_NAME"));
                        columnInfo.setDataType(rsColumn.getString("DATA_TYPE"));
                        columnInfo.setTypeName(rsColumn.getString("TYPE_NAME"));
                        columnInfo.setColumnSize(rsColumn.getString("COLUMN_SIZE"));
                        columnInfo.setColumnNameCamel(StrUtil.toCamelCase(rsColumn.getString("COLUMN_NAME")));
                        columnInfo.setIsNullable(rsColumn.getString("IS_NULLABLE"));
                        columnInfo.setRemarks(rsColumn.getString("REMARKS"));
                        columnInfo.setCharOctetLength(rsColumn.getString("CHAR_OCTET_LENGTH"));
                        columnInfos.add(columnInfo);
                    }
                    tableInfo.setColumnInfoList(columnInfos);
                }
            }
        } catch (Exception e) {
            logger.error("从METADATA获取表的所有列信息失败", e);
        } finally {
            super.closeSqlSession(sqlSession);
        }
        return tableInfos;
    }

    public TableInfo getTableColumn(String tableName) {
        return getTableColumn(tableName, null);
    }

    public TableInfo getTableColumn(String tableName, String schema) {
        TableInfo tableInfo = new TableInfo();
        SqlSession sqlSession = null;
        try {
            sqlSession = super.sqlSession();
            Connection connection = sqlSession.getConnection();
            DatabaseMetaData metaData = connection.getMetaData();
            String catalog = connection.getCatalog();
            if (StringUtils.isBlank(schema)) {
                schema = connection.getSchema();
                schema = StringUtils.isNotBlank(schema) ? schema : catalog;
            }
            ResultSet rsTable = metaData.getTables(catalog, schema, tableName, new String[] { "TABLE" });
            while (rsTable.next()) {
                tableInfo.setTableCat(catalog);
                tableInfo.setTableName(rsTable.getString("TABLE_NAME"));
                tableInfo.setTableType(rsTable.getString("TABLE_TYPE"));
                tableInfo.setTableSchema(schema);
                tableInfo.setRemarks(rsTable.getString("REMARKS"));
                tableInfo.setTableNameCamel(StrUtil.toCamelCase(rsTable.getString("TABLE_NAME")));
                ResultSet rsColumn = metaData.getColumns(catalog, schema, tableInfo.getTableName(), null);
                List<ColumnInfo> columnInfos = new ArrayList<>();
                while (rsColumn.next()) {
                    ColumnInfo columnInfo = new ColumnInfo();
                    columnInfo.setColumnName(rsColumn.getString("COLUMN_NAME"));
                    columnInfo.setDataType(rsColumn.getString("DATA_TYPE"));
                    columnInfo.setTypeName(rsColumn.getString("TYPE_NAME"));
                    columnInfo.setColumnSize(rsColumn.getString("COLUMN_SIZE"));
                    columnInfo.setColumnNameCamel(StrUtil.toCamelCase(rsColumn.getString("COLUMN_NAME")));
                    columnInfo.setIsNullable(rsColumn.getString("IS_NULLABLE"));
                    columnInfo.setRemarks(rsColumn.getString("REMARKS"));
                    columnInfo.setCharOctetLength(rsColumn.getString("CHAR_OCTET_LENGTH"));
                    columnInfos.add(columnInfo);
                }
                tableInfo.setColumnInfoList(columnInfos);
            }
        } catch (Exception e) {
            logger.error("从METADATA获取表的所有列信息失败", e);
        } finally {
            super.closeSqlSession(sqlSession);
        }
        return tableInfo;
    }


import java.sql.PreparedStatement;
import java.util.Properties;

import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.SqlSessionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.druid.pool.DruidDataSource;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.extra.spring.SpringUtil;

/**
 * @author xin
 * @version Created by xin on 2021/8/23 2:10 下午
 */
public abstract class AbstractDatabase {

    private static final Logger  logger = LoggerFactory.getLogger(AbstractDatabase.class);
    protected SqlSessionTemplate sqlSessionTemplate;

    protected AbstractDatabase(SqlSessionTemplate sqlSessionTemplate){
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    public boolean execute(String sql) {
        SqlSession sqlSession = null;
        try {
            sqlSession = sqlSession();
            PreparedStatement pst = sqlSession.getConnection().prepareStatement(sql);
            pst.execute();
        } catch (Exception e) {
            logger.error("执行sql失败{}", sql, e);
            return false;
        } finally {
            if (ObjectUtil.isNotNull(sqlSession)) {
                closeSqlSession(sqlSession);
            }
        }
        return true;
    }

    protected SqlSession sqlSession() {
        Properties properties = new Properties();
        properties.setProperty("remarks", "true");
        properties.setProperty("useInformationSchema", "true");
        DruidDataSource druidDataSource = SpringUtil.getBean(DruidDataSource.class);
        if (ObjectUtil.isNotEmpty(druidDataSource)) {
            druidDataSource.setConnectProperties(properties);
        }
        return SqlSessionUtils.getSqlSession(this.sqlSessionTemplate.getSqlSessionFactory(),
            this.sqlSessionTemplate.getExecutorType(),
            this.sqlSessionTemplate.getPersistenceExceptionTranslator());
    }

    /**
     * 关闭sqlSession
     *
     * @param session SqlSession
     */
    protected void closeSqlSession(SqlSession session) {
        SqlSessionUtils.closeSqlSession(session, this.sqlSessionTemplate.getSqlSessionFactory());
    }
}
永远少年1024
关注
专栏目录
springboot + mybatis-plus + oracle + 多数据源 + redis + hutool
04-06
springboot + mybatis-plus + database+ 多数据源 + redis + hutool 框架干净，没有其他冗余的成分； 配置了MP的代码生成器，意见生成代码，节省开发时间！ 可用于各种定时任务处理，各种夸库操作， 多数据源支持Oracle、Mysql、Sql Server 等数据库夸库操作，使用 @DS 切换数据源。， 可设置多主多从 、纯粹多库（记得设置primary） 、混合配置等； Hutool工具类库，降低相关API的学习成本，提高工作效率；
使用连接池的方式连接数据库：使用DBUtil连接ORACLE数据库
SYL269794967的博客
07-28 282
================== DBUtil.java: ================== package blog.util; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; ...
Hutool：Java开发者的全能工具箱与效率提升利器
最新发布
拥有必珍惜
08-15 854
Hutool是一个小而全的Java工具类库，它通过静态方法封装，降低了相关API的学习成本，提高了工作效率，使Java开发变得更加高效和愉快。轻量级：Hutool体积小巧，不会给项目带来额外的负担。功能强大：Hutool涵盖了Java开发的方方面面，提供了丰富的工具类和方法。易于使用：Hutool通过静态方法封装，降低了学习成本，提高了开发效率。社区支持：Hutool拥有活跃的社区支持，开发者可以方便地获取帮助和分享经验。“笑对人生，智慧同行！博客新文出炉，微信订阅号更新更实时，等你笑纳~”
Hutool--Java工具类库
闲走天涯的博客
07-22 735
????简介 Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。 Hutool中的工具方法来自每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当； Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务，同时可以最大限度的避免封装不完善带来的bug。 ??
Hutool连接数据库方法
qq_42287535的博客
10-20 3419
Springboot项目打包后，获取jar包外配置文件数据库信息，连接数据库方法。
使用hutool工具类一行代码快速实现连接数据库查询【原创】
qq_35757427的博客
09-20 1159
【代码】使用hutool工具类一行代码实现连接数据库查询。
JDK 17 踩坑记录
weixin_42277430的博客
01-30 911
详见IssueOracle JDK 17.0.10 已修复。
mysql jdbc 存储过程工具类
qq_42830346的博客
07-06 491
mysql 原生jdbc 实现的存储过程相关操作工具类
【Java】以纯Java驱动方式（JDBC）连接Oracle数据库
CHIxFight的专栏
06-20 872
在Eclipse工程下创建目录lib，把Oracle安装目录下的jdbc\lib\classes12.jar复制到这里，然后右击工程名，选择”Build Path“ – “Libraries” -“Add  JARs”，浏览到工程\lib目录中选择刚才添加的jar包，确定就把该jar包加进来了，这样就可以使用这些类库了。这种方式使用的是相对路径方式添加jar比绝对的Add Extern
通过hive元数据表获取hive分区表的相关信息
耀哥的博客
10-18 2087
通过hive元数据表获取hive分区表的元数据信息 通过hive元数据表获取hive分区表的元数据信息 项目中需要获取hive所有分区表的分区信息并显示到页面 如图 方案：通过JDBC连接hive源数据库，sql语句实现 编写sql语句： SELECT main.*,b.numRows,b.totalSize FROM ( SELECT main.TBL_ID AS metaObjectId ,main.TBL_NAME AS tabName ,b.PART_ID AS partId ,b.
Spring Boot进阶(14)：Spring Boot高级应用：手把手教你连接数据库并获取指定表结构！
**My Coding Family**
03-09 6553
springboot系列教程，从零到一，讲解非常详细，等你来学！
echarts从数据库获取数据实现
11-13
第一使用csdn分享资源，略激动大笑，本系统使用servlet+mysql+echarts 技术实现六种图表（柱状图、饼状图、折线图、散点图、雷达图、仪表盘）的静态和异步交互，使用的开发工具是eclipse。别的不多说了，需要的下载...
详解python websocket获取实时数据的几种常见链接方式
01-01
第一种, 使用create_connection链接，需要pip install websocket-client (此方法不建议使用，链接不稳定，容易断，并且连接很耗时) import time from websocket import create_connection url = 'wss://i.cg.net/...
java获取hive元数据信息_Hive SQL 元数据血缘管理
weixin_31977649的博客
03-02 1319
模板概述基于 Antlr4 编译 hive 相关 xxx.g 文件生成对应的模板，如 hive 源码中：image.png编译完成生成对应 *.java 文件，Antlr4 详见：Antlr4解析流程Parserimage.png重点：获取SELECT操作中的表和列的相关操作。其他操作这判断到字段级别。实现思路：对AST深度优先遍历，遇到操作的token则判断当前的操作，遇到子句则压栈当前处理，处...
连接到oracle,连接到Oracle
weixin_42345731的博客
04-03 747
1.描述介绍如何连接到Oracle数据库。注意连接Oracle数据库前，需要用户先配置Oracle，配置完成才能连接Oracle。具体步骤见下面的“配置Oracle”。为了活字格连接外连数据库后能正确地工作，您需要给目标数据表中设置唯一、不为空的主键(至少一个)。在选择主键时，请不要选择以下数据类型的字段：text、ntext、Binary、Varbinary、image、hierarchyid、...
基于Hutool包对数据库的增删改查操作
诗和远方，任重道远
07-04 1万+
这里就不介绍数据库的配置了，请参考 上一篇-如何正确使用Hutool和Guava这两个丰富的工具集，自己学习测试，样例 一、增删改操作 @Test @Ignore public void crudTest() throws SQLException { // 增 Long id = db.insertForGeneratedKey(Entity.create("user").set(...
HuTool操作说明文档连接
weixin_40705360的博客
10-25 2063
HuTool操作说明
Oracle数据库基础
weixin_30498807的博客
04-10 107
一.登录Oracle数据库 　　首先运行Oracle数据库：　　　　默认的有两个账号：　　　　管理员账号： 用户名：system　　密码：manager　　　　普通账号：用户名：scott　　密码：tiger　　　　这两个账号的连接都为Normal。　　　　还有另一种连接SYSDBA：sysdba，操作系统认证，不需要账号密码，但pl/sql登录窗口有非空校验，所以账号密码随便输，连接为sysd...
Hutool之集合工具——CollectionUtil
热门推荐
weixin_34179762的博客
05-09 1万+
为什么80%的码农都做不了架构师？>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值