Skip to content

Integrations Overview

Liquibase's logic is built with no expectation of how it is run. The same logic can be called from a CLI, from Maven, embedded in a 3rd party application, or from anywhere else.

Because Liquibase is written in Java, any application running on the JVM can easily integrate with it.

What Can Integrations Do?

Integrations can be either a lightweight wrapper adapting all the Liquibase commands to a new way of running, or a custom application picking and choosing what parts of Liquibase to call.

Liquibase On Demand

One category of integrations builds Liquibase into a tool that exposes all the available Liquibase commands for users to run on demand. Examples of this type of integration include the Liquibase CLI, Maven plugin, Gradle plugin, Ant plugin, and the NPM plugin.

These integrations act as a thin wrapper adapting the available Liquibase commands to a way of calling them.

Liquibase Embedded

Another category of integrations builds specific Liquibase operations into flows within an application framework Examples of this type of integration include Spring, Spring Boot, Quarkus, Micronaut, and Servlet Listener support.

These integrations will run update automatically against the application's database on startup. Because they are automatically running Liquibase, they do not allow arbitrary commands to be run like the "On Demand" integrations.

Custom Integrations

If you have complex "on demand" use cases or the frameworks you use don't support the commands you need to execute, you can write whatever logic you want around calls to Liquibase.

Examples of this include building Liquibase into your automated test setup, running Liquibase multi-threaded across all your database shards, or a single CLI to your users that combine Liquibase with other tools.


If you are looking to build new functionality onto Liquibase rather than building Liquibase into something else, see the extensions documentation

Primary Integration Points

    participant Integration
    participant Command API
    participant Liquibase Logic
    participant Configuration API
    participant ResourceAccessor

    Integration->>Configuration API: Create and configure
    Integration->>ResourceAccessor: Create and configure
    Integration->>Command API: Create and configure
    Integration->>Command API: execute()
    Command API->>Liquibase Logic: Runs Business Logic
    Liquibase Logic->>Configuration API: Lookup Configuration
    Liquibase Logic->>ResourceAccessor: Reads Files
    Command API-->>Integration: returns data from command

Command API

The primary facade for calling Liquibase is through the liquibase.command package. The commands provide the pluggable, complete operations that can be performed.

For more information, see the Command API documentation

Configuration API

Liquibase has an extendable and cascading configuration system.

Each integration can configure the various places configuration values can be pulled from (arguments, environment variables, configuration files, etc.) and the priority of each before running the commands that will look up configuration values.

For more information, see the Configure Configuration Guide

ResourceAccessor API

Liquibase allows each integration to control how files are found via the ResourceAccessor API. This is what is exposed to users as the search path

Each integration can configure where and how to look up files before running the commands that will read them.

For more information, see the Configure File Access Guide

Lower-Level Integration Points

If the "command" level facade is too high-level for your needs, you can always drop down to use the lower-level objects instead.

The complete API can be found in the "Code API" section.