Java读取数据库表(二)

这篇具有很好参考价值的文章主要介绍了Java读取数据库表(二)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Java读取数据库表(二)

Java读取数据库表(二)

application.properties

db.driver.name=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/easycrud?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false
db.username=root
db.password=xpx24167830

#是否忽略表前缀
ignore.table.prefix=true

#参数bean后缀
suffix.bean.param=Query

辅助阅读

配置文件中部分信息被读取到之前文档说到的Constants.java中以常量的形式存储,BuildTable.java中会用到,常量命名和上面类似。

StringUtils.java

package com.easycrud.utils;

/**
 * @BelongsProject: EasyCrud
 * @BelongsPackage: com.easycrud.utils
 * @Author: xpx
 * @Email: 2436846019@qq.com
 * @CreateTime: 2023-05-03  13:30
 * @Description: 字符串大小写转换工具类
 * @Version: 1.0
 */

public class StringUtils {
    /**
     * 首字母转大写
     * @param field
     * @return
     */
    public static String uperCaseFirstLetter(String field) {
        if (org.apache.commons.lang3.StringUtils.isEmpty(field)) {
            return field;
        }
        return field.substring(0, 1).toUpperCase() + field.substring(1);
    }

    /**
     * 首字母转小写
     * @param field
     * @return
     */
    public static String lowerCaseFirstLetter(String field) {
        if (org.apache.commons.lang3.StringUtils.isEmpty(field)) {
            return field;
        }
        return field.substring(0, 1).toLowerCase() + field.substring(1);
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(lowerCaseFirstLetter("Abcdef"));
        System.out.println(uperCaseFirstLetter("abcdef"));
    }
}

辅助阅读

org.apache.commons.lang3.StringUtils.isEmpty()

只能判断String类型是否为空(org.springframework.util包下的Empty可判断其他类型),源码如下

public static boolean isEmpty(final CharSequence cs) {
	return cs == null || cs.length() == 0;
}

xx.toUpperCase()

字母转大写

xx.toLowerCase()

字母转小写

xx.substring()

返回字符串的子字符串

索引从0开始
public String substring(int beginIndex)	//起始索引,闭
public String substring(int beginIndex, int endIndex)	//起始索引到结束索引,左闭右开

BuildTable.java完整代码

package com.easycrud.builder;

import com.easycrud.bean.Constants;
import com.easycrud.bean.FieldInfo;
import com.easycrud.bean.TableInfo;
import com.easycrud.utils.JsonUtils;
import com.easycrud.utils.PropertiesUtils;
import com.easycrud.utils.StringUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @BelongsProject: EasyCrud
 * @BelongsPackage: com.easycrud.builder
 * @Author: xpx
 * @Email: 2436846019@qq.com
 * @CreateTime: 2023-05-02  18:02
 * @Description: 读Table
 * @Version: 1.0
 */

public class BuildTable {

    private static final Logger logger = LoggerFactory.getLogger(BuildTable.class);
    private static Connection conn = null;

    /**
     * 查表信息,表名,表注释等
     */
    private static String SQL_SHOW_TABLE_STATUS = "show table status";

    /**
     * 将表结构当作表读出字段的信息,如字段名(field),类型(type),自增(extra)...
     */
    private static String SQL_SHOW_TABLE_FIELDS = "show full fields from %s";

    /**
     * 检索索引
     */
    private static String SQL_SHOW_TABLE_INDEX = "show index from %s";

    /**
     * 读配置,连接数据库
     */
    static {
        String driverName = PropertiesUtils.getString("db.driver.name");
        String url = PropertiesUtils.getString("db.url");
        String user = PropertiesUtils.getString("db.username");
        String password = PropertiesUtils.getString("db.password");

        try {
            Class.forName(driverName);
            conn = DriverManager.getConnection(url,user,password);
        } catch (Exception e) {
            logger.error("数据库连接失败",e);
        }
    }

    /**
     * 读取表
     */
    public static List<TableInfo> getTables() {
        PreparedStatement ps = null;
        ResultSet tableResult = null;

        List<TableInfo> tableInfoList = new ArrayList();
        try{
            ps = conn.prepareStatement(SQL_SHOW_TABLE_STATUS);
            tableResult = ps.executeQuery();
            while(tableResult.next()) {
                String tableName = tableResult.getString("name");
                String comment = tableResult.getString("comment");
                //logger.info("tableName:{},comment:{}",tableName,comment);

                String beanName = tableName;
                /**
                 * 去xx_前缀
                 */
                if (Constants.IGNORE_TABLE_PREFIX) {
                    beanName = tableName.substring(beanName.indexOf("_")+1);
                }
                beanName = processFiled(beanName,true);

//                logger.info("bean:{}",beanName);

                TableInfo tableInfo = new TableInfo();
                tableInfo.setTableName(tableName);
                tableInfo.setBeanName(beanName);
                tableInfo.setComment(comment);
                tableInfo.setBeanParamName(beanName + Constants.SUFFIX_BEAN_PARAM);

                /**
                 * 读字段信息
                 */
                readFieldInfo(tableInfo);

                /**
                 * 读索引
                 */
                getKeyIndexInfo(tableInfo);

//                logger.info("tableInfo:{}",JsonUtils.convertObj2Json(tableInfo));

                tableInfoList.add(tableInfo);

//                logger.info("表名:{},备注:{},JavaBean:{},JavaParamBean:{}",tableInfo.getTableName(),tableInfo.getComment(),tableInfo.getBeanName(),tableInfo.getBeanParamName());
            }
            logger.info("tableInfoList:{}",JsonUtils.convertObj2Json(tableInfoList));
        }catch (Exception e){
            logger.error("读取表失败",e);
        }finally {
            if (tableResult != null) {
                try {
                    tableResult.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return tableInfoList;
    }

    /**
     * 将表结构当作表读出字段的信息,如字段名(field),类型(type),自增(extra)...
     * @param tableInfo
     * @return
     */
    private static void readFieldInfo(TableInfo tableInfo) {
        PreparedStatement ps = null;
        ResultSet fieldResult = null;

        List<FieldInfo> fieldInfoList = new ArrayList();
        try{
            ps = conn.prepareStatement(String.format(SQL_SHOW_TABLE_FIELDS,tableInfo.getTableName()));
            fieldResult = ps.executeQuery();

            Boolean haveDateTime = false;
            Boolean haveDate = false;
            Boolean haveBigDecimal = false;

            while(fieldResult.next()) {
                String field = fieldResult.getString("field");
                String type = fieldResult.getString("type");
                String extra = fieldResult.getString("extra");
                String comment = fieldResult.getString("comment");

                /**
                 * 类型例如varchar(50)我们只需要得到varchar
                 */
                if (type.indexOf("(") > 0) {
                    type = type.substring(0, type.indexOf("("));
                }
                /**
                 * 将aa_bb变为aaBb
                 */
                String propertyName = processFiled(field, false);

//                logger.info("f:{},p:{},t:{},e:{},c:{},",field,propertyName,type,extra,comment);

                FieldInfo fieldInfo = new FieldInfo();
                fieldInfoList.add(fieldInfo);

                fieldInfo.setFieldName(field);
                fieldInfo.setComment(comment);
                fieldInfo.setSqlType(type);
                fieldInfo.setAutoIncrement("auto_increment".equals(extra) ? true : false);
                fieldInfo.setPropertyName(propertyName);
                fieldInfo.setJavaType(processJavaType(type));

//                logger.info("JavaType:{}",fieldInfo.getJavaType());

                if (ArrayUtils.contains(Constants.SQL_DATE_TIME_TYPES, type)) {
                    haveDateTime = true;
                }
                if (ArrayUtils.contains(Constants.SQL_DATE_TYPES, type)) {
                    haveDate = true;
                }
                if (ArrayUtils.contains(Constants.SQL_DECIMAL_TYPE, type)) {
                    haveBigDecimal = true;
                }
            }
            tableInfo.setHaveDataTime(haveDateTime);
            tableInfo.setHaveData(haveDate);
            tableInfo.setHaveBigDecimal(haveBigDecimal);

            tableInfo.setFieldList(fieldInfoList);
        }catch (Exception e){
            logger.error("读取表失败",e);
        }finally {
            if (fieldResult != null) {
                try {
                    fieldResult.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 检索唯一索引
     * @param tableInfo
     * @return
     */
    private static List<FieldInfo> getKeyIndexInfo(TableInfo tableInfo) {
        PreparedStatement ps = null;
        ResultSet fieldResult = null;

        List<FieldInfo> fieldInfoList = new ArrayList();
        try{
            /**
             * 缓存Map
             */
            Map<String,FieldInfo> tempMap = new HashMap();
            /**
             * 遍历表中字段
             */
            for (FieldInfo fieldInfo : tableInfo.getFieldList()) {
                tempMap.put(fieldInfo.getFieldName(),fieldInfo);
            }

            ps = conn.prepareStatement(String.format(SQL_SHOW_TABLE_INDEX,tableInfo.getTableName()));
            fieldResult = ps.executeQuery();
            while(fieldResult.next()) {
                String keyName = fieldResult.getString("key_name");
                Integer nonUnique = fieldResult.getInt("non_unique");
                String columnName = fieldResult.getString("column_name");

                /**
                 * 0是唯一索引,1不唯一
                 */
                if (nonUnique == 1) {
                    continue;
                }

                List<FieldInfo> keyFieldList = tableInfo.getKeyIndexMap().get(keyName);

                if (null == keyFieldList) {
                    keyFieldList = new ArrayList();
                    tableInfo.getKeyIndexMap().put(keyName,keyFieldList);
                }

                keyFieldList.add(tempMap.get(columnName));
            }
        }catch (Exception e){
            logger.error("读取索引失败",e);
        }finally {
            if (fieldResult != null) {
                try {
                    fieldResult.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return fieldInfoList;
    }

    /**
     * aa_bb__cc==>AaBbCc || aa_bb_cc==>aaBbCc
     * @param field
     * @param uperCaseFirstLetter,首字母是否大写
     * @return
     */
    private static String processFiled(String field,Boolean uperCaseFirstLetter) {
        StringBuffer sb = new StringBuffer();
        String[] fields=field.split("_");
        sb.append(uperCaseFirstLetter ? StringUtils.uperCaseFirstLetter(fields[0]):fields[0]);
        for (int i = 1,len = fields.length; i < len; i++){
            sb.append(StringUtils.uperCaseFirstLetter(fields[i]));
        }
        return sb.toString();
    }

    /**
     * 为数据库字段类型匹配对应Java属性类型
     * @param type
     * @return
     */
    private static String processJavaType(String type) {
        if (ArrayUtils.contains(Constants.SQL_INTEGER_TYPE,type)) {
            return "Integer";
        }else if (ArrayUtils.contains(Constants.SQL_LONG_TYPE,type)) {
            return "Long";
        }else if (ArrayUtils.contains(Constants.SQL_STRING_TYPE,type)) {
            return "String";
        }else if (ArrayUtils.contains(Constants.SQL_DATE_TIME_TYPES,type) || ArrayUtils.contains(Constants.SQL_DATE_TYPES,type)) {
            return "Date";
        }else if (ArrayUtils.contains(Constants.SQL_DECIMAL_TYPE,type)) {
            return "BigDecimal";
        }else {
            throw new RuntimeException("无法识别的类型:"+type);
        }
    }
}

辅助阅读

去表名前缀,如tb_test-->test

beanName = tableName.substring(beanName.indexOf("_")+1);

indexOf("_")定位第一次出现下划线的索引位置,substring截取后面的字符串。

processFiled(String,Boolean)

自定义方法,用于将表名或字段名转换为Java中的类名或属性名,如aa_bb__cc-->AaBbCc || aa_bb_cc-->aaBbCc

processFiled(String,Boolean)中的String[] fields=field.split("_")

xx.split("_")是将xx字符串按照下划线进行分割。

processFiled(String,Boolean)中的append()

StringBuffer类包含append()方法,相当于“+”,将指定的字符串追加到此字符序列。

processJavaType(String)

自定义方法,用于做数据库字段类型与Java属性类型之间的匹配。

processJavaType(String)中的ArrayUtils.contains(A,B)

判断B是否在A中出现过。文章来源地址https://www.toymoban.com/news/detail-433671.html

到了这里,关于Java读取数据库表(二)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SSM项目中数据库连接properties文件加密

    思路:在项目开始运行之前,先使用加密程序把正确的明文密码进行加密得到密文信息,修改配置文件中的password为密文,在项目启动的时候要把这个密文进行解开为明文、让spring连接数据库使用。 参考文章来源 数据库连接进行加密的主要目的是为了保证应用软件的数据的正

    2024年02月09日
    浏览(29)
  • SpringBoot项目application配置文件数据库密码上传git暴露问题解决方案

    项目中含有配置文件,配置文件中含有数据库的用户名和密码,上传git直接对外网开放。那后果会怎样可想而知。 jasypt(Java Simplified Encryption)是一个简化的开源 Java 加密工具库 输出 使用很简单,只需要引入jasypt-spring-boot-starter依赖,然后将配置文件中的明文换成\\\"ENC(密文即可)“

    2024年04月14日
    浏览(47)
  • Flash读取数据库中的数据

     Flash读取数据库中的数据 要读取数据库的记录,首先需要建立一个数据库,并输入一些数据。数据库建立完毕后,由Flash向ASP提交请求,ASP根据请求对数据库进行操作后将结果返回给Flash,Flash以某种方式把结果显示出来。 1.启动Access2003,新建一名为“userInfo.mdb”的数据库,

    2024年01月25日
    浏览(44)
  • Python读取hbase数据库

    1. hbase连接 首先用hbase shell 命令来进入到hbase数据库,然后用list命令来查看hbase下所有表,以其中表“DB_level0”为例,可以看到库名“baotouyiqi”是拼接的,python代码访问时先连接: 备注:完整代码在最后,想运行的直接滑倒最后复制即可 2. 按条件读取hbase数据 然后按照条件

    2024年04月09日
    浏览(50)
  • Python爬虫之读取数据库中的数据

    之前几篇我们一直在研究如何从网站上快速、方便的获取数据,并将获取到的数据存储在数据库中。但是将数据存储在数据中并不是我们的目的,获取和存储数据的目的是为了更好的利用这些数据,利用这些数据的前提首先需要从数据库按一定的格式来读取数据,这一篇主要

    2023年04月13日
    浏览(49)
  • Python数据分析之读取Excel数据并导入数据库

    曾某年某一天某地 时间如静止的空气 你的不羁 给我惊喜 ——《谁愿放手》陈慧琳 入职新公司两个多月,发现这边的数据基础很差,很多数据甚至没有系统承载,大量的Excel表,大量的人工处理工作,现阶段被迫“面向Excel”编程。本文主要介绍使用Python读取Excel数据并导入

    2024年01月25日
    浏览(51)
  • python Flask项目使用SQLalchemy连接数据库时,出现RuntimeError:Working outside of application context.的解决过程记录

    在使用python的Flask框架跟着教程编写项目时,我跟着教程使用了三个文件来组织,分别是main.py(主程序),module.py(数据库模型),controller.py(蓝图模块程序,用Blueprint衔接) 在主程序中,创建app、SQLalchemy实例对象db并将二者绑定 在module.py中,导入主程序中的db和app,创建

    2024年02月09日
    浏览(45)
  • pb如何在数据库保存和读取图片

    字段类型Image(不同数据库不同,如果没有再查找blob等类型),然后使用如下编程套路: 读取:    这样的字段不能放在数据窗口的Detail节中,通常用户点击某行数据,获取该行的主键信息,以该信息为条件检索图片信息。比如,主键为id,图片保存在zp字段中:    在dw_1的

    2024年02月09日
    浏览(43)
  • 自定义Flink SourceFunction定时读取数据库

    Source 是Flink获取数据输入的地方,可以用StreamExecutionEnvironment.addSource(sourceFunction) 将一个 source 关联到你的程序。Flink 自带了许多预先实现的 source functions,不过你仍然可以通过实现 SourceFunction 接口编写自定义的非并行 source,也可以通过实现继承 RichSourceFunction 类编写自定义的

    2024年02月02日
    浏览(34)
  • Python读取excle文件,插入到数据库

     一、需求背景         最近项目实践过程中遇到了一个问题:在使用Navicat将数据导入到PostgreSQL数据库时,发现时间格式的字段中的时间数值发生了变化,导致部分数据的时间不正确,故数据手动导入数据库报错。为了解决这个问题,决定编写Python代码来读取Excel文件,

    2024年02月16日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包