SpringBoot如何启动并初始化执行sql脚本

引言

在现代的Java开发中，Spring Boot已经成为了构建微服务和独立应用程序的首选框架。它简化了Spring应用的初始搭建以及开发过程，提供了大量的自动配置选项，使得开发者能够快速启动和运行项目。然而，在实际开发过程中，我们经常需要在应用启动时执行一些SQL脚本来初始化数据库，比如创建表结构、插入初始数据等。本文将详细介绍如何在Spring Boot应用中启动并初始化执行SQL脚本。

1. Spring Boot启动流程概述

在深入探讨如何执行SQL脚本之前，我们首先需要了解Spring Boot应用的启动流程。Spring Boot应用的启动过程可以分为以下几个主要步骤：

1. 加载Spring Boot应用上下文：Spring Boot应用启动时，首先会加载Spring应用上下文。这个过程包括加载配置文件、初始化Bean、配置数据源等。

2. 执行自动配置：Spring Boot的自动配置机制会根据项目的依赖和配置，自动配置各种Bean。例如，如果项目中引入了spring-boot-starter-data-jpa依赖，Spring Boot会自动配置JPA相关的Bean。

3. 启动嵌入式Web服务器：如果项目是一个Web应用，Spring Boot会自动启动一个嵌入式的Web服务器（如Tomcat、Jetty等），并加载Web相关的配置。

4. 执行自定义初始化逻辑：在应用启动的最后阶段，Spring Boot会执行一些自定义的初始化逻辑，比如执行SQL脚本、初始化缓存等。

2. 在Spring Boot中执行SQL脚本的几种方式

在Spring Boot中，有多种方式可以在应用启动时执行SQL脚本。以下是几种常见的方式：

2.1 使用spring.datasource配置

Spring Boot提供了spring.datasource配置项，可以通过配置spring.datasource.schema和spring.datasource.data属性来指定SQL脚本的位置。Spring Boot会在应用启动时自动执行这些脚本。

2.1.1 配置spring.datasource.schema

spring.datasource.schema属性用于指定DDL（Data Definition Language）脚本的位置，通常用于创建表结构。Spring Boot会在应用启动时执行这些脚本。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    schema: classpath:schema.sql

在上面的配置中，schema.sql文件位于src/main/resources目录下。Spring Boot会在应用启动时执行schema.sql文件中的SQL语句。

2.1.2 配置spring.datasource.data

spring.datasource.data属性用于指定DML（Data Manipulation Language）脚本的位置，通常用于插入初始数据。Spring Boot会在应用启动时执行这些脚本。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    data: classpath:data.sql

在上面的配置中，data.sql文件位于src/main/resources目录下。Spring Boot会在应用启动时执行data.sql文件中的SQL语句。

2.1.3 配置多个SQL脚本

如果需要执行多个SQL脚本，可以将spring.datasource.schema和spring.datasource.data属性配置为多个文件，使用逗号分隔。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    schema: classpath:schema1.sql,classpath:schema2.sql
    data: classpath:data1.sql,classpath:data2.sql

在上面的配置中，Spring Boot会依次执行schema1.sql、schema2.sql、data1.sql和data2.sql文件中的SQL语句。

2.2 使用@PostConstruct注解

@PostConstruct注解是Java EE规范中的一部分，用于标记一个方法在Bean初始化之后执行。我们可以在Spring Boot应用中使用@PostConstruct注解来执行SQL脚本。

2.2.1 创建Bean并执行SQL脚本

首先，我们需要创建一个Bean，并在其中使用@PostConstruct注解来执行SQL脚本。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
public class DatabaseInitializer {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @PostConstruct
    public void init() {
        jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name VARCHAR(100))");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (1, 'John Doe')");
    }
}

在上面的代码中，DatabaseInitializer类是一个Spring Bean，使用@Component注解进行标记。@PostConstruct注解标记的init方法会在Bean初始化之后执行，执行SQL语句来创建表和插入数据。

2.2.2 使用@PostConstruct注解的注意事项

• @PostConstruct注解标记的方法会在Bean初始化之后执行，但不会在应用启动时立即执行。如果需要在应用启动时立即执行SQL脚本，可以考虑使用CommandLineRunner或ApplicationRunner接口。

• @PostConstruct注解标记的方法不能有参数，且不能抛出检查异常。

2.3 使用CommandLineRunner或ApplicationRunner接口

CommandLineRunner和ApplicationRunner是Spring Boot提供的两个接口，用于在应用启动时执行一些自定义逻辑。我们可以实现这两个接口来执行SQL脚本。

2.3.1 实现CommandLineRunner接口

CommandLineRunner接口提供了一个run方法，该方法会在应用启动时执行。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class DatabaseInitializer implements CommandLineRunner {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void run(String... args) throws Exception {
        jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name VARCHAR(100))");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (1, 'John Doe')");
    }
}

在上面的代码中，DatabaseInitializer类实现了CommandLineRunner接口，并在run方法中执行SQL语句来创建表和插入数据。

2.3.2 实现ApplicationRunner接口

ApplicationRunner接口与CommandLineRunner接口类似，也提供了一个run方法，但ApplicationRunner的run方法接收一个ApplicationArguments参数，可以更方便地处理命令行参数。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class DatabaseInitializer implements ApplicationRunner {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name VARCHAR(100))");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (1, 'John Doe')");
    }
}

在上面的代码中，DatabaseInitializer类实现了ApplicationRunner接口，并在run方法中执行SQL语句来创建表和插入数据。

2.3.3 CommandLineRunner与ApplicationRunner的区别

• CommandLineRunner接口的run方法接收一个String... args参数，表示命令行参数。

• ApplicationRunner接口的run方法接收一个ApplicationArguments参数，可以更方便地处理命令行参数。

• 如果不需要处理命令行参数，可以使用CommandLineRunner接口；如果需要处理命令行参数，可以使用ApplicationRunner接口。

2.4 使用Flyway或Liquibase进行数据库迁移

Flyway和Liquibase是两个流行的数据库迁移工具，可以帮助我们管理数据库的版本和变更。Spring Boot对这两个工具提供了良好的支持，可以通过配置自动执行SQL脚本。

2.4.1 使用Flyway进行数据库迁移

Flyway是一个轻量级的数据库迁移工具，支持SQL脚本和Java代码两种方式进行数据库迁移。Spring Boot可以通过spring.flyway配置项来配置Flyway。

2.4.1.1 引入Flyway依赖

首先，我们需要在pom.xml中引入Flyway的依赖。

<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>

2.4.1.2 配置Flyway

在application.yml中配置Flyway的相关属性。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
  flyway:
    enabled: true
    locations: classpath:db/migration

在上面的配置中，spring.flyway.locations属性指定了SQL脚本的位置。Flyway会在应用启动时自动执行classpath:db/migration目录下的SQL脚本。

2.4.1.3 创建SQL脚本

在src/main/resources/db/migration目录下创建SQL脚本文件，文件名需要遵循Flyway的命名规则。例如，V1__Create_users_table.sql。

CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

在上面的SQL脚本中，V1__Create_users_table.sql表示第一个版本的数据库迁移脚本，Flyway会在应用启动时执行该脚本。

2.4.2 使用Liquibase进行数据库迁移

Liquibase是另一个流行的数据库迁移工具，支持XML、YAML、JSON和SQL脚本等多种方式进行数据库迁移。Spring Boot可以通过spring.liquibase配置项来配置Liquibase。

2.4.2.1 引入Liquibase依赖

首先，我们需要在pom.xml中引入Liquibase的依赖。

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

2.4.2.2 配置Liquibase

在application.yml中配置Liquibase的相关属性。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
  liquibase:
    enabled: true
    change-log: classpath:db/changelog/db.changelog-master.xml

在上面的配置中，spring.liquibase.change-log属性指定了Liquibase的主变更日志文件的位置。Liquibase会在应用启动时自动执行该文件中的变更。

2.4.2.3 创建变更日志文件

在src/main/resources/db/changelog目录下创建db.changelog-master.xml文件。

<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.8.xsd">

    <changeSet id="1" author="john">
        <createTable tableName="users">
            <column name="id" type="int" autoIncrement="true">
                <constraints primaryKey="true" nullable="false"/>
            </column>
            <column name="name" type="varchar(100)">
                <constraints nullable="false"/>
            </column>
        </createTable>
    </changeSet>
</databaseChangeLog>

在上面的XML文件中，<changeSet>标签定义了一个数据库变更集，Liquibase会在应用启动时执行该变更集中的SQL语句。

2.5 使用Spring JDBC手动执行SQL脚本

除了上述几种方式外，我们还可以使用Spring JDBC手动执行SQL脚本。这种方式适用于需要在特定条件下执行SQL脚本的场景。

2.5.1 使用JdbcTemplate执行SQL脚本

JdbcTemplate是Spring提供的一个简化JDBC操作的工具类，我们可以使用它来执行SQL脚本。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
public class DatabaseInitializer {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @PostConstruct
    public void init() {
        jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name VARCHAR(100))");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (1, 'John Doe')");
    }
}

在上面的代码中，DatabaseInitializer类使用JdbcTemplate来执行SQL语句，创建表和插入数据。

2.5.2 使用ScriptUtils执行SQL脚本

ScriptUtils是Spring提供的一个工具类，用于执行SQL脚本文件。我们可以使用ScriptUtils来执行SQL脚本文件。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.datasource.init.ScriptUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@Component
public class DatabaseInitializer {

    @Autowired
    private DataSource dataSource;

    @PostConstruct
    public void init() throws SQLException {
        try (Connection connection = dataSource.getConnection()) {
            ScriptUtils.executeSqlScript(connection, new ClassPathResource("schema.sql"));
            ScriptUtils.executeSqlScript(connection, new ClassPathResource("data.sql"));
        }
    }
}

在上面的代码中，DatabaseInitializer类使用ScriptUtils来执行schema.sql和data.sql文件中的SQL语句。

3. 总结

在Spring Boot应用中，有多种方式可以在应用启动时执行SQL脚本。我们可以通过配置spring.datasource.schema和spring.datasource.data属性来执行SQL脚本，也可以使用@PostConstruct注解、CommandLineRunner或ApplicationRunner接口来执行自定义的初始化逻辑。此外，我们还可以使用Flyway或Liquibase进行数据库迁移，或者使用Spring JDBC手动执行SQL脚本。

选择哪种方式取决于具体的需求和场景。如果只是简单的初始化数据库，可以使用spring.datasource配置；如果需要更复杂的初始化逻辑，可以使用CommandLineRunner或ApplicationRunner接口；如果需要管理数据库的版本和变更，可以使用Flyway或Liquibase。

无论选择哪种方式，Spring Boot都提供了灵活且强大的支持，使得我们能够轻松地在应用启动时执行SQL脚本，初始化数据库。