这篇文章将为大家详细讲解有关启动Springboot项目后怎么实现自动创建多表关联的数据库，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。
sql脚本的语句就是平常的create建表语句，类似如下：
create table ACT_PROCDEF_INFO ( ID_ varchar(64) not null, PROC_DEF_ID_ varchar(64) not null, REV_ integer, INFO_JSON_ID_ varchar(64), primary key (ID_) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
增加外部主键、索引——
create index ACT_IDX_INFO_PROCDEF on ACT_PROCDEF_INFO(PROC_DEF_ID_); alter table ACT_PROCDEF_INFO add constraint ACT_FK_INFO_JSON_BA foreign key (INFO_JSON_ID_) references ACT_GE_BYTEARRAY (ID_); alter table ACT_PROCDEF_INFO add constraint ACT_FK_INFO_PROCDEF foreign key (PROC_DEF_ID_) references ACT_RE_PROCDEF (ID_); alter table ACT_PROCDEF_INFO add constraint ACT_UNIQ_INFO_PROCDEF unique (PROC_DEF_ID_);
整体就是设计一套符合符合需求场景的sql语句，保存在.sql的脚本文件里，最后统一存放在resource目录下，类似如下：
接下来，就是实现CommandLineRunner的接口，重写其run()的bean回调方法，在run方法里开发能自动建库与建表逻辑的功能。
目前，我已将开发的demo上传到了我的github，感兴趣的童鞋，可自行下载，目前能直接下下来在本地环境运行，可根据自己的实际需求针对性参考使用。
首先，在解决这类需求时，第一个先要解决的地方是，Springboot启动后如何实现只执行一次建表方法。
这里需要用到一个CommandLineRunner接口，这是Springboot自带的，实现该接口的类，其重写的run方法，会在Springboot启动完成后自动执行，该接口源码如下：
@FunctionalInterface
public interface CommandLineRunner {
/**
*用于运行bean的回调
*/
void run(String... args) throws Exception;
}
扩展一下，在Springboot中，可以定义多个实现CommandLineRunner接口类，并且可以对这些实现类中进行排序，只需要增加@Order，其重写的run方法就可以按照顺序执行，代码案例验证：
@Component
@Order(value=1)
public class WatchStartCommandSqlRunnerImpl implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("第一个Command执行");
}
@Component
@Order(value = 2)
public class WatchStartCommandSqlRunnerImpl2 implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("第二个Command执行");
}
}
控制台打印的信息如下：
第一个Command执行
第二个Command执行
根据以上的验证，因此，我们可以通过实现CommandLineRunner的接口，重写其run()的bean回调方法，用于在Springboot启动后实现只执行一次建表方法。实现项目启动建表的功能，可能还需实现判断是否已经有相应数据库，若无，则应先新建一个数据库，同时，得考虑还没有对应数据库的情况，因此，我们通过jdbc第一次连接MySQL时，应连接一个原有自带存在的库。每个MySql安装成功后，都会有一个mysql库，在第一次建立jdbc连接时，可以先连接它。
代码如下：
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://127.0.0.1:3306/mysql?useUnicode=true&characterEncoding=UTF-8&ueSSL=false&serverTimezone=GMT%2B8";
Connection conn= DriverManager.getConnection(url,"root","root");
建立与MySql软件连接后，先创建一个Statement对象，该对象是jdbc中可用于执行静态 SQL 语句并返回它所生成结果的对象，这里可以使用它来执行查找库与创建库的作用。
//创建Statement对象
Statement statment=conn.createStatement();
/**
使用statment的查询方法executeQuery("show databases like \"fte\"")
检查MySql是否有fte这个数据库
**/
ResultSet resultSet=statment.executeQuery("show databases like \"fte\"");
//若resultSet.next()为true，证明已存在；
//若false，证明还没有该库,则执行statment.executeUpdate("create database fte")创建库
if(resultSet.next()){
log.info("数据库已经存在");
}else {
log.info("数据库未存在，先创建fte数据库");
if(statment.executeUpdate("create database fte")==1){
log.info("新建数据库成功");
}
}
在数据库fte自动创建完成后，就可以在该fte库里去做建表的操作了。
我将建表的相关方法都封装到SqlSessionFactory类里，相关建表方法同样需要用到jdbc的Connection连接到数据库，因此，需要把已连接的Connection引用变量当做参数传给SqlSessionFactory的初始构造函数：
public void createTable(Connection conn,Statement stat) throws SQLException {
try {
String url="jdbc:mysql://127.0.0.1:3306/fte?useUnicode=true&characterEncoding=UTF-8&ueSSL=false&serverTimezone=GMT%2B8";
conn=DriverManager.getConnection(url,"root","root");
SqlSessionFactory sqlSessionFactory=new SqlSessionFactory(conn);
sqlSessionFactory.schemaOperationsBuild("create");
} catch (SQLException e) {
e.printStackTrace();
}finally {
stat.close();
conn.close();
}
}
初始化new SqlSessionFactory(conn)后，就可以在该对象里使用已进行连接操作的Connection对象了。
public class SqlSessionFactory{
private Connection connection ;
public SqlSessionFactory(Connection connection) {
this.connection = connection;
}
......
}
这里传参可以有两种情况，即“create”代表创建表结构的功能，“drop”代表删除表结构的功能：
sqlSessionFactory.schemaOperationsBuild("create");
进入到这个方法里，会先做一个判断——
public void schemaOperationsBuild(String type) {
switch (type){
case "drop":
this.dbSchemaDrop();break;
case "create":
this.dbSchemaCreate();break;
}
}
若是this.dbSchemaCreate()，执行建表操作：
/**
* 新增数据库表
*/
public void dbSchemaCreate() {
if (!this.isTablePresent()) {
log.info("开始执行create操作");
this.executeResource("create", "act");
log.info("执行create完成");
}
}
this.executeResource("create", "act")代表创建表名为act的数据库表——
public void executeResource(String operation, String component) {
this.executeSchemaResource(operation, component, this.getDbResource(operation, operation, component), false);
}
其中 this.getDbResource(operation, operation, component)是获取sql脚本的路径，进入到方法里，可见——
public String getDbResource(String directory, String operation, String component) {
return "static/db/" + directory + "/mysql." + operation + "." + component + ".sql";
}
接下来，读取路径下的sql脚本，生成输入流字节流：
public void executeSchemaResource(String operation, String component, String resourceName, boolean isOptional) {
InputStream inputStream = null;
try {
//读取sql脚本数据
inputStream = IoUtil.getResourceAsStream(resourceName);
if (inputStream == null) {
if (!isOptional) {
log.error("resource '" + resourceName + "' is not available");
return;
}
} else {
this.executeSchemaResource(operation, component, resourceName, inputStream);
}
} finally {
IoUtil.closeSilently(inputStream);
}
}
最后，整个执行sql脚本的核心实现在this.executeSchemaResource(operation, component, resourceName, inputStream)方法里——
/**
* 执行sql脚本
* @param operation
* @param component
* @param resourceName
* @param inputStream
*/
private void executeSchemaResource(String operation, String component, String resourceName, InputStream inputStream) {
//sql语句拼接字符串
String sqlStatement = null;
Object exceptionSqlStatement = null;
try {
/**
* 1.jdbc连接mysql数据库
*/
Connection connection = this.connection;
Exception exception = null;
/**
* 2、分行读取"static/db/create/mysql.create.act.sql"里的sql脚本数据
*/
byte[] bytes = IoUtil.readInputStream(inputStream, resourceName);
/**
* 3.将sql文件里数据分行转换成字符串，换行的地方，用转义符“\n”来代替
*/
String ddlStatements = new String(bytes);
/**
* 4.以字符流形式读取字符串数据
*/
BufferedReader reader = new BufferedReader(new StringReader(ddlStatements));
/**
* 5.根据字符串中的转义符“\n”分行读取
*/
String line = IoUtil.readNextTrimmedLine(reader);
/**
* 6.循环读取的每一行
*/
for(boolean inOraclePlsqlBlock = false; line != null; line = IoUtil.readNextTrimmedLine(reader)) {
/**
* 7.若下一行line还有数据，证明还没有全部读取，仍可执行读取
*/
if (line.length() > 0) {
/**
8.在没有拼接够一个完整建表语句时，！line.endsWith(";")会为true，
即一直循环进行拼接，当遇到";"就跳出该if语句
**/
if ((!line.endsWith(";") || inOraclePlsqlBlock) && (!line.startsWith("/") || !inOraclePlsqlBlock)) {
sqlStatement = this.addSqlStatementPiece(sqlStatement, line);
} else {
/**
9.循环拼接中若遇到符号";"，就意味着，已经拼接形成一个完整的sql建表语句，例如
create table ACT_GE_PROPERTY (
NAME_ varchar(64),
VALUE_ varchar(300),
REV_ integer,
primary key (NAME_)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin
这样，就可以先通过代码来将该建表语句执行到数据库中，实现如下：
**/
if (inOraclePlsqlBlock) {
inOraclePlsqlBlock = false;
} else {
sqlStatement = this.addSqlStatementPiece(sqlStatement, line.substring(0, line.length() - 1));
}
/**
* 10.将建表语句字符串包装成Statement对象
*/
Statement jdbcStatement = connection.createStatement();
try {
/**
* 11.最后，执行建表语句到数据库中
*/
log.info("SQL: {}", sqlStatement);
jdbcStatement.execute(sqlStatement);
jdbcStatement.close();
} catch (Exception var27) {
log.error("problem during schema {}, statement {}", new Object[]{operation, sqlStatement, var27});
} finally {
/**
* 12.到这一步，意味着上一条sql建表语句已经执行结束，
* 若没有出现错误话，这时已经证明第一个数据库表结构已经创建完成，
* 可以开始拼接下一条建表语句，
*/
sqlStatement = null;
}
}
}
}
if (exception != null) {
throw exception;
}
} catch (Exception var29) {
log.error("couldn't " + operation + " db schema: " + exceptionSqlStatement, var29);
}
}
这部分代码主要功能是，先用字节流形式读取sql脚本里的数据，转换成字符串，其中有换行的地方用转义符“/n”来代替。接着把字符串转换成字符流BufferedReader形式读取，按照“/n”符合来划分每一行的读取，循环将读取的每行字符串进行拼接，当循环到某一行遇到“；”时，就意味着已经拼接成一个完整的create建表语句，类似这样形式——
create table ACT_PROCDEF_INFO ( ID_ varchar(64) not null, PROC_DEF_ID_ varchar(64) not null, REV_ integer, INFO_JSON_ID_ varchar(64), primary key (ID_) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE utf8_bin;
这时，就可以先将拼接好的create建表字符串，通过 jdbcStatement.execute(sqlStatement)语句来执行入库了。当执行成功时，该ACT_PROCDEF_INFO表就意味着已经创建成功，接着以BufferedReader字符流形式继续读取下一行，进行下一个数据库表结构的构建。
整个过程大概就是这个逻辑，可以在此基础上，针对更为复杂的建表结构sql语句进行设计，在项目启动时，自行执行相应的sql语句，来进行建表。
关于启动Springboot项目后怎么实现自动创建多表关联的数据库就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
