How Spring Boot uses Liquibase for database migration

In modern application development, database migration is an indispensable link. It enables developers to effectively manage database schema changes and ensure consistency between applications and databases. Liquibase is a popular open source tool for managing version control and migration of databases. This article will introduce how to use Liquibase for database migration in Spring Boot applications.

Insert image description here

What is Liquibase?

Liquibase is a database change management tool that allows developers to track and apply database schema changes throughout the lifecycle of an application. Liquibase uses change log files in XML, YAML, JSON or SQL formats to describe changes to the database schema, and then automatically executes corresponding SQL statements based on these files. Its main features include:

Repeatability : Liquibase ensures that every database instance can be upgraded in the same way, allowing for repeatability.
Versioning : By using change sets, Liquibase can version each version of the database schema.
Multiple database support : Liquibase supports multiple databases, including MySQL, PostgreSQL, Oracle, etc.
Easy to integrate : Liquibase can be easily integrated into various development frameworks and build tools, such as Spring Boot.

Integrating Liquibase in Spring Boot

To use Liquibase in a Spring Boot application, you first need to add the appropriate dependencies. pom.xmlAdd the following dependencies to the file :

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
    <version>4.7.0</version> <!-- 根据实际情况选择最新版本 -->
</dependency>

Next, you need to configure Liquibase to connect to your database. Add database connection information in or application.propertiesfile , for example:application.yml

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

After configuring the database connection information, you can create a Liquibase change log file. A change log file is a file that describes changes to the database schema and can be written in XML, YAML, JSON, or SQL format.

Create a simple Liquibase changelog

Let's create a simple Liquibase changelog file to create a persontable named with columns idand name. src/main/resourcesCreate a file named in the directory db.changelog-master.xmlwith the following content:

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

    <changeSet id="1" author="yourname">
        <createTable tableName="person">
            <column name="id" type="INT">
                <constraints primaryKey="true" nullable="false" />
            </column>
            <column name="name" type="VARCHAR(255)" />
        </createTable>
    </changeSet>

</databaseChangeLog>

In this example, we create a persontable named and define two columns: idand . nameThe change set has an ID of 1, and the author is yourname. You can define more complex database schema changes as needed.

Start the application and apply database migrations

Now that you have configured Liquibase and created a simple changelog file, you need to enable Liquibase in your Spring Boot application.

In the Spring Boot main application class, add @EnableLiquibaseannotations:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import liquibase.integration.spring.SpringLiquibase;

@SpringBootApplication
@EnableLiquibase
public class MyApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(MyApplication.class, args);
    }
}

This annotation integrates Liquibase into a Spring Boot application, automatically finding change log files and applying them to the database.

Now you can start your Spring Boot application and Liquibase will automatically apply the database migrations. You can verify that the migration was successful by viewing the application's logs or a database management tool.

Run database migration

To run database migrations, you can use Spring Boot’s Maven plugin or Gradle plugin. The following is an example command to run a database migration using the Maven plugin:

mvn liquibase:update

This will trigger Liquibase to perform a database migration, applying the changes to the configured database.

in conclusion

Using Liquibase for database migrations in Spring Boot applications is a powerful way to manage database schema changes. By creating a change log file, configuring database connection information, and integrating Liquibase into your application, you can easily track and apply database schema changes, ensuring that your application's database is consistent with your code.

In addition, Liquibase also provides many advanced functions, such as rollback changes, condition changes, data migration, etc., to meet various database management needs. Therefore, it is a powerful tool to use in Spring Boot projects to help improve the maintainability and reliability of database changes.

I hope this article can help you understand how to use Liquibase for database migration in a Spring Boot application to better manage database schema changes. Good luck with your database migration!