springboot 整合mysql实现版本管理通用最新解决方案

-- 初始化建表sql
use bank;
-- tb_user表建表
CREATE TABLE `tb_user` (
  `id` int(12) NOT NULL,
  `user_name` varchar(32) DEFAULT NULL,
  `password` varchar(64) DEFAULT NULL,
  `phone` varchar(32) DEFAULT NULL,
  `address` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- tb_role表建表
CREATE TABLE `tb_role` (
  `id` int(12) NOT NULL,
  `role_name` varchar(32) DEFAULT NULL,
  `role_type` varchar(64) DEFAULT NULL,
  `code` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- tb_role 表增加索引
alter tb_role add index idx_code(code);

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.init.DataSourceInitializer;
import org.springframework.jdbc.datasource.init.DatabasePopulator;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
/**
 * 成功执行
 */
@Component
@Slf4j
public class DatabaseInitializer implements InitializingBean {
    @Value("classpath:db/init.sql")
    private Resource dataScript;
    @Bean
    public DataSourceInitializer dataSourceInitializer(final DataSource dataSource) {
        final DataSourceInitializer initializer = new DataSourceInitializer();
        // 设置数据源
        initializer.setDataSource(dataSource);
        initializer.setDatabasePopulator(databasePopulator());
        return initializer;
    }
    private DatabasePopulator databasePopulator() {
        final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
        populator.addScripts(dataScript);
        log.info("sql脚本初始化完成");
        return populator;
    }
    @Override
    public void afterPropertiesSet() throws Exception {
    }
}

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://IP:3306/bank?createDatabaseIfNotExist=true&useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
    #初始化sql建表相关配置属性 ========================
    schema: classpath:db/init.sql     #初始化sql语句，DDL相关
    data: classpath:db/data.sql       # 追加数据，添加字段，索引等
    separator: ";"                    # sql语句中的结束分隔符，通常为;
    continue-on-error: false        #执行错误时是否继续
    initialization-mode: always     #是否每次启动工程时都执行
    platform: mysql                   #使用哪种数据库
    sqlScriptEncoding: utf-8        #编码

        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
            <version>6.0.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.2.RELEASE</version>
        </dependency>

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://IP:3306/bank
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
  flyway:
    enabled: true
    encoding: UTF-8
    cleanDisabled: true
    ## 迁移sql脚本文件存放路径，默认db/migration
    locations: classpath:db/migration
    ## 迁移sql脚本文件名称的前缀，默认V
    sqlMigrationPrefix: V
    ## 迁移sql脚本文件名称的分隔符，默认2个下划线__
    sqlMigrationSeparator: __
    # 迁移sql脚本文件名称的后缀
    sqlMigrationSuffixes: .sql
    validateOnMigrate: true
    # 设置为true，当迁移发现数据库非空且存在没有元数据的表时，自动执行基准迁移，新建schema_version表
    baselineOnMigrate: true

-- 初始化建表sql
use bank;
-- tb_user表建表
CREATE TABLE `tb_user` (
  `id` int(12) NOT NULL,
  `user_name` varchar(32) DEFAULT NULL,
  `password` varchar(64) DEFAULT NULL,
  `phone` varchar(32) DEFAULT NULL,
  `address` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- tb_role表建表
CREATE TABLE `tb_role` (
  `id` int(12) NOT NULL,
  `role_name` varchar(32) DEFAULT NULL,
  `role_type` varchar(64) DEFAULT NULL,
  `code` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- 初始化建表sql
use bank;
-- 给tb_user表添加一个索引
alter table tb_user add index idx_name(user_name);
-- 给tb_user表追加新字段
alter table tb_user add column woker varchar(32) default null;

        <dependency>
            <groupId>org.liquibase</groupId>
            <artifactId>liquibase-core</artifactId>
            <version>3.6.3</version>
        </dependency>

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.1.xsd">
    <changeSet id="v1.0.0-1" author="zcy" context="main">
        <sqlFile path="classpath:/sql/v1.0.0/1.init.sql"/>
        <sqlFile path="classpath:/sql/v1.0.0/2.init-data.sql"/>
    </changeSet>
</databaseChangeLog>

import liquibase.integration.spring.SpringLiquibase;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.DefaultResourceLoader;
import javax.annotation.Resource;
import javax.sql.DataSource;
@Slf4j
@Configuration
public class LiquibaseConfig {
    //指定liquibase版本
    @Value("${dc.version:main}")
    private String contexts;
    //是否开启liquibase
    @Value("${dc.liquibase.enable:true}")
    private Boolean enable;
    //liquibase用到的两张表，记录与管理升级sql相关
    private static final String DATABASE_CHANGE_LOG_TABLE = "lqb_changelog_demo";
    private static final String DATABASE_CHANGE_LOG_LOCK_TABLE = "lqb_lock_demo";
    @Resource
    private DataSource dataSource;
    /**
     * liquibase bean配置声明
     */
    @Bean
    public SpringLiquibase liquibase() {
        SpringLiquibase liquibase = new SpringLiquibase();
        // Liquibase xml 文件路径
        liquibase.setChangeLog("classpath:sql/master.xml");
        liquibase.setDataSource(dataSource);
        if (StringUtils.isNotBlank(contexts)) {
            liquibase.setContexts(contexts);
        }
        liquibase.setShouldRun(enable);
        liquibase.setResourceLoader(new DefaultResourceLoader());
        // 覆盖Liquibase changelog表名
        liquibase.setDatabaseChangeLogTable(DATABASE_CHANGE_LOG_TABLE);
        liquibase.setDatabaseChangeLogLockTable(DATABASE_CHANGE_LOG_LOCK_TABLE);
        return liquibase;
    }
}

-- 初始化建表sql
use bank;
-- tb_depart表建表
CREATE TABLE `tb_depart` (
  `id` int(12) NOT NULL,
  `dept_name` varchar(32) DEFAULT NULL,
  `dept_type` varchar(64) DEFAULT NULL,
  `code` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--version 1.0.0,build 2023-08-11 ,新建用户表
CREATE TABLE `tb_user` (
  `id` int(12) NOT NULL,
  `user_name` varchar(32) DEFAULT NULL,
  `password` varchar(64) DEFAULT NULL,
  `phone` varchar(32) DEFAULT NULL,
  `address` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.*;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;
/**
 * 操作sysversion表相关
 */
public class SysVersionUtils {
    public static void main(String[] args){
        boolean sysVersionTableExist = SysVersionConfig.isSysVersionTableExist();
        if(!sysVersionTableExist){
            //如果没有创建表，执行表的创建
            SysVersionConfig.checkAndCreateSysVersion();
        }
        //到这一步，说明已经创建完成了，接下来开始解析sql文件进行脚本的初始化
        String sqlFilePath= "classpath:sql/table_init.sql";
        parseAndStoreVersionInfo(sqlFilePath);
    }
    public static void parseAndStoreVersionInfo(String sqlFilePat)  {
        File databaseFile = null;
        try {
            databaseFile = ResourceUtils.getFile(sqlFilePat);
        } catch (FileNotFoundException e) {
            System.out.println("获取或解析sql文件失败");
            e.printStackTrace();
            return;
        }
        List<String> readLines = null;
        try {
            readLines = FileUtils.readLines(databaseFile, "UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("解析sql文件失败");
            return;
        }
        if (CollectionUtils.isEmpty(readLines)) {
            return;
        }
        //如果解析数据时发现不合理的数据行，是直接抛出异常不再执行？还是忽略？可以自行扩展，这里暂时跳过，记录日志
        List<String> versionInfoList = new LinkedList<>();
        for (String readLine : readLines) {
            if (!isValidVersionTagLine(readLine)) {
                continue;
            }
            versionInfoList.add(readLine);
        }
        //检查数据库中sys_version数据是否存在
        Connection connection = JdbcUtils.getConnection();
        VersionRecord dbVersionRecord = getDbVersionRecord(connection);
        if (dbVersionRecord == null) {
            System.out.println("初次执行sql变更");
           String upgradeSql = getSqlTextFromLines(readLines);
            System.out.println("to execute sql : " + upgradeSql);
            //解析得到最后一行的version数据
            String lastVersionLine = ((LinkedList<String>) versionInfoList).getLast();
            TemLineRecord temLineRecord = ParseUtils.getFromLine(lastVersionLine);
            System.out.println("本次变更的sql版本号信息" + temLineRecord.getVersionNum() + ":" + temLineRecord.getBuildDate());
            //TODO 执行sql建表相关的创建
            initSysVersion(connection,"app",temLineRecord.getVersionNum(),temLineRecord.getBuildDate());
            //执行sql升级
            doUpgradeSql(connection,upgradeSql);
            System.out.println("完成sql的初始化执行");
            return;
        }
        /**
         * FIXME 1、如果sys_version已经有数据了，说明之前做过升级了，只需要解析最新的版本变更;
         * FIXME 2、可以重复执行，如果没有版本变更，直接忽略，不用解析
         */
        //拿到最后一行的version信息，下面使用
        String lastVersionLine = ((LinkedList<String>) versionInfoList).getLast();
        TemLineRecord lineRecord = ParseUtils.getFromLine(lastVersionLine);
        if(lineRecord.getBuildDate().equals(dbVersionRecord.getBuildDate()) &&
                lineRecord.getVersionNum().equals(dbVersionRecord.getVersionNum())){
            System.out.println("已经是最新版本号，无需升级");
            return;
        }
        //从哪一行开始的数据才是本次需要执行的sql呢？那就是：数据库中的两个字段和 --version 以及时间正好能够对的上的那一行开始
        getTargetSqlLines(readLines, versionInfoList, dbVersionRecord);
        String sqlText = getSqlTextFromLines(readLines);
        System.out.println("待执行的sql ：" + sqlText);
        //执行本次sql的更新
        doUpgradeSql(connection,sqlText);
        //升级版本号
        updateSysVersion(lineRecord,dbVersionRecord.getId());
    }
    private static void getTargetSqlLines(List<String> readLines, List<String> versionInfoList, VersionRecord dbVersionRecord) {
        String targetLine = null;
        int lineNum = 0;
        for (int i = 0; i < versionInfoList.size() - 1; i++) {
            if (versionInfoList.get(i).contains(dbVersionRecord.getVersionNum()) && versionInfoList.get(i).contains(dbVersionRecord.getBuildDate())) {
                lineNum = i;
                break;
            }
        }
        targetLine = versionInfoList.get(lineNum + 1);
        int targetNum = 0;
        for (int i = 0; i < readLines.size(); i++) {
            if (readLines.get(i).equalsIgnoreCase(targetLine)) {
                //找到这一行的行号
                targetNum = i;
                break;
            }
        }
        //接下来移除targetNum之前的所有元素
        readLines.subList(0, targetNum+1).clear();
    }
    /**
     * 将读取到的数据行组装成sql
     * @param allLines
     * @return
     */
    public static String getSqlTextFromLines(List<String> allLines){
        if(CollectionUtils.isEmpty(allLines)){
            System.out.println("数据行为空");
            return null;
        }
        StringBuilder stringBuilder = new StringBuilder();
        for(String text : allLines){
            if(text.startsWith("--")){
                continue;
            }else if(StringUtils.isEmpty(text)){
                continue;
            }
            stringBuilder.append(text);
            stringBuilder.append("\n");
        }
        return stringBuilder.toString();
    }
    /**
     * 更新版本号
     * @param lineRecord
     * @param id
     */
    public static void updateSysVersion(TemLineRecord lineRecord,String id){
        Connection connection = JdbcUtils.getConnection();
        PreparedStatement  ps=null;
        String sql="UPDATE sys_version SET BUILD_DATE=?, VERSION_NUM= ? WHERE id=?";
        try {
            ps=connection.prepareStatement(sql);
            ps.setString(1, lineRecord.getBuildDate());
            ps.setString(2, lineRecord.getVersionNum());
            ps.setString(3, id);
            ps.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                connection.close();
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 初次新增版本号
     * @param connection
     * @param id
     * @param versionNum
     * @param dateStr
     */
    public static void initSysVersion(Connection connection,String id,String versionNum,String dateStr){
        PreparedStatement  ps=null;
        String sql = "insert into sys_version values('" +id+"','"+versionNum+"','"+dateStr+"')";
        try {
            ps = connection.prepareStatement(sql);
            ps.execute(sql);
            System.out.println("初始化插入sys_version版本号成功");
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("初始化插入sys_version版本号失败");
        }
    }
    /**
     * 执行升级sql
     * @param connection
     * @param sql
     * @throws SQLException
     */
    private static void doUpgradeSql(Connection connection, String sql)  {
        if(StringUtils.isEmpty(sql)){
            System.out.println("带升级的sql不存在");
            return;
        }
        Statement statement = null;
        try {
            statement = connection.createStatement();
            String[] sqlCommands = sql.split(";");
            for (String sqlCommand : sqlCommands) {
                if (!sqlCommand.trim().isEmpty()) {
                    try {
                        statement.executeUpdate(sqlCommand);
                    } catch (SQLException e) {
                        e.printStackTrace();
                        System.out.println("执行升级sql失败");
                    }
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 获取数据库的最新版本号
     * @param connection
     * @return
     */
    public static VersionRecord getDbVersionRecord(Connection connection) {
        String sql = "select * from sys_version";
        PreparedStatement ps = null;
        ResultSet rs = null;
        VersionRecord versionRecord = null;
        try {
            ps = connection.prepareStatement(sql);
            rs = ps.executeQuery();
            if (rs.next()) {
                versionRecord = new VersionRecord();
                versionRecord.setId(rs.getString("id"));
                versionRecord.setBuildDate(rs.getString("BUILD_DATE"));
                versionRecord.setVersionNum(rs.getString("VERSION_NUM"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("获取最新版本号失败");
        }
        return versionRecord;
    }
    private static Pattern oldVersionTagPattern = Pattern.compile("^--version\\s[0-9\\.]+,build\\s.*");
    public static boolean isValidVersionTagLine(String tagLine) {
        return oldVersionTagPattern.matcher(tagLine).matches();
    }
}