手写代码生成工具实现类似Mybatis-Plus的效果-----02

#全新智己L6全国试驾开启#

package com.alatus.builder;

import com.alatus.Entity.FieldInfo;
import com.alatus.Entity.TableInfo;
import com.alatus.constant.Constants;
import com.alatus.utils.PropertiesUtils;
import com.alatus.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.List;


public class TableBuilder {
    private static Connection CONNECTION = null;
    private static Logger LOGGER = LoggerFactory.getLogger(TableBuilder.class);
    private static String SHOW_TABLE_STATUS = "show table status";
    private static String SHOW_TABLE_FIELDS = "show full fields from %s";
    static{
        String driverName = PropertiesUtils.getValue("db.driver.name");
        String url = PropertiesUtils.getValue("db.url");
        String username = PropertiesUtils.getValue("db.username");
        String password = PropertiesUtils.getValue("db.password");
        try {
            Class.forName(driverName);
            CONNECTION = DriverManager.getConnection(url, username, password);
            LOGGER.info("数据库连接成功");
        } catch (ClassNotFoundException e) {
            LOGGER.error("数据库驱动加载失败: {}", e.getMessage(), e);
        } catch (SQLException e) {
            LOGGER.error("数据库连接失败: {}", e.getMessage(), e);
        }
    }
    public static void getTables(){
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List<TableInfo> tableInfoList = new ArrayList<>();
        try{
            preparedStatement = CONNECTION.prepareStatement(SHOW_TABLE_STATUS);
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                String tableName = resultSet.getString("name");
                String comment = resultSet.getString("comment");
                TableInfo tableInfo = new TableInfo();
                tableInfo.setTableName(tableName);
                tableInfo.setComment(comment);
                String beanName = tableName;
                if(Constants.IGNORE_TABLE_PREFIX){
                    beanName = tableName.substring(tableName.indexOf("_")+1);
                }
                beanName = processFields(beanName,true);
                tableInfo.setBeanName(beanName);
                tableInfo.setBeanParamName(beanName+Constants.SUFFIX_BEAN_PARAM);
                tableInfo.setFieldList(getFieldInfo(tableInfo));
                tableInfoList.add(tableInfo);
            }
        }
        catch (SQLException e){
            LOGGER.error("获取表失败: {}", e.getMessage(), e);
        }
        finally {
            LOGGER.info("关闭数据库连接");
            // 关闭 ResultSet
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    LOGGER.error("关闭ResultSet失败: {}", e.getMessage(), e);
                }
            }
            // 关闭 PreparedStatement
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    LOGGER.error("关闭PreparedStatement失败: {}", e.getMessage(), e);
                }
            }
            // 关闭 Connection
            if (CONNECTION != null) {
                try {
                    CONNECTION.close();
                } catch (SQLException e) {
                    LOGGER.error("关闭Connection失败: {}", e.getMessage(), e);
                }
            }
        }
    }
    private static List<FieldInfo> getFieldInfo(TableInfo tableInfo){
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List<FieldInfo> fieldInfoList = new ArrayList<>();
        try{
            preparedStatement = CONNECTION.prepareStatement(String.format(SHOW_TABLE_FIELDS,tableInfo.getTableName()));
            resultSet = preparedStatement.executeQuery();
            while(resultSet.next()){
                String field = resultSet.getString("field");
                String type = resultSet.getString("type");
                String comment = resultSet.getString("comment");
                String extra = resultSet.getString("extra");
                if(type.indexOf("(")>0){
//                    从第一个字母开始,到(出现的位置截串,取得不要符号的类型名称
                    type = type.substring(0,type.indexOf("("));
                }
                String propertyName = processFields(field,false);
                FieldInfo fieldInfo = new FieldInfo();
                fieldInfo.setFieldName(field);
                fieldInfo.setComment(comment);
                fieldInfo.setSqlType(type);
                fieldInfo.setIsAutoIncrement("auto_increment".equalsIgnoreCase(extra));
                fieldInfo.setPropertyName(propertyName);
                fieldInfoList.add(fieldInfo);
            }
        }
        catch (SQLException e){
            LOGGER.error("获取表失败: {}", e.getMessage(), e);
        }
        finally {
            LOGGER.info("关闭数据库连接");
            // 关闭 ResultSet
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    LOGGER.error("关闭ResultSet失败: {}", e.getMessage(), e);
                }
            }
            // 关闭 PreparedStatement
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    LOGGER.error("关闭PreparedStatement失败: {}", e.getMessage(), e);
                }
            }
            return fieldInfoList;
        }
    }
    private static String processFields(String fieldName,Boolean upperCase){
        StringBuilder builder = new StringBuilder();
        String[] fields = fieldName.split("_");
        builder.append(upperCase? StringUtils.firstCharToUpperCase(fields[0]):fields[0]);
        for (int i = 1; i < fields.length; i++) {
            builder.append(StringUtils.firstCharToUpperCase(fields[i]));
        }
        return builder.toString();
    }
    private static String processJavaType(String type) {
        if (ArrayUtils.contains(Constants.SQL_INTEGER_TYPE, type)) {
            return "Integer";
        } else if (ArrayUtils.contains(Constants.SOL_LONG_TYPE, type)) {
            return "Long";
        } else if (ArrayUtils.contains(Constants.SQL_STRING_TYPE, type)) {
            return "String";
        } else if (ArrayUtils.contains(Constants.SOL_DATE_TIME_TYPES, type) || ArrayUtils.contains(Constants.SOL_DATE_TYPES, type)) {
            return "Date";
        } else if (ArrayUtils.contains(Constants.SQL_DECIMAL_TYPE, type)) {
            return "BigDecimal";
        } else {
            LOGGER.error("不支持的数据类型: {}", type);
            return null;
        }
    }
}

package com.alatus.constant;

import com.alatus.utils.PropertiesUtils;

public class Constants {
    public static Boolean IGNORE_TABLE_PREFIX;
    public static String SUFFIX_BEAN_PARAM;
    static{
        IGNORE_TABLE_PREFIX = Boolean.valueOf(PropertiesUtils.getValue("ignore.table.prefix"));
        SUFFIX_BEAN_PARAM = PropertiesUtils.getValue("suffix.bean.param");
    }
    public final static String[] SOL_DATE_TIME_TYPES = new String[] {"datetime", "timestamp"};
    public final static String[] SOL_DATE_TYPES = new String[] {"date"};
    public static final String[] SQL_DECIMAL_TYPE = new String[] {"decimal", "double", "float"};
    public static final String[] SQL_STRING_TYPE = new String[] {"char", "varchar", "text", "mediumtext", "longtext"};
    // Integer
    public static final String[] SQL_INTEGER_TYPE = new String[] {"int", "tinyint"};
    // Long
    public static final String[] SOL_LONG_TYPE = new String[] {"bigint"};
}

package com.alatus;

import com.alatus.builder.TableBuilder;

public class GeneratorApplication {
    public static void main(String[] args) {
        TableBuilder.getTables();
    }
}

package com.alatus.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

public class PropertiesUtils {
    private static Properties properties = new Properties();
    private static Map<String, String> propertiesMap = new ConcurrentHashMap<>();
    private static Logger LOGGER = LoggerFactory.getLogger(PropertiesUtils.class);
    static {
        InputStream inputStream = null;
        try{
//            典中典资源加载
            inputStream = PropertiesUtils.class.getClassLoader().getResourceAsStream("application.properties");
            properties.load(inputStream);
//            我想起来了,这个Properties对象是JAVA提供的特殊Map结构
            Iterator<Object> iterator = properties.keySet().iterator();
//            所以也是自带KV结构的,因此我只要遍历它的KeySet,取出每一个Key,再把对应的Key和对应的Value放入Map中
//            就可以实现完整的加载properties中的数据了
            while(iterator.hasNext()){
                String key = (String) iterator.next();
                propertiesMap.put(key,properties.getProperty(key));
            }
        }catch (Exception e){
            LOGGER.error("加载配置文件失败: {}", e.getMessage(), e);
        }finally {
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    LOGGER.error("关闭资源失败: {}", e.getMessage(), e);
                }
            }
        }
    }
    public static String getValue(String key){
//        因为我们的配置信息是静态读取的,所以直接返回Map中的值即可
        return propertiesMap.get(key);
    }
}

db.driver.name=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/ourapp?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
db.username=root
db.password=abc123
ignore.table.prefix=true
suffix.bean.param=Param