Java SpringLiquibase类代码示例

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
/**
 * Migrate database with liquibase.
 * @param tenantKey the tenant key
 */
@SneakyThrows
public void migrate(String tenantKey) {
    final StopWatch stopWatch = createStarted();
    try {
        log.info("START - SETUP:CreateTenant:liquibase tenantKey: {}", tenantKey);
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setResourceLoader(resourceLoader);
        liquibase.setDataSource(dataSource);
        liquibase.setChangeLog(CHANGE_LOG_PATH);
        liquibase.setContexts(liquibaseProperties.getContexts());
        liquibase.setDefaultSchema(tenantKey);
        liquibase.setDropFirst(liquibaseProperties.isDropFirst());
        liquibase.setChangeLogParameters(DatabaseUtil.defaultParams(tenantKey));
        liquibase.setShouldRun(true);
        liquibase.afterPropertiesSet();
        log.info("STOP  - SETUP:CreateTenant:liquibase tenantKey: {}, result: OK, time = {} ms", tenantKey,
            stopWatch.getTime());
    } catch (Exception e) {
        log.info("STOP  - SETUP:CreateTenant:liquibase tenantKey: {}, result: FAIL, error: {}, time = {} ms",
            tenantKey, e.getMessage(), stopWatch.getTime());
        throw e;
    }
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
private void runOnAllSchemasXm() throws LiquibaseException {

        for (String schema : getSchemas()) {
            if (schema.equals("default")) {
                schema = null;
            }

            log.info("Initializing Liquibase for schema {}", schema);
            try {
                SpringLiquibase liquibase = getXmSpringLiquibase(getDataSource());
                liquibase.setDefaultSchema(schema);
                liquibase.afterPropertiesSet();
                log.info("Liquibase run for schema {}", schema);
            } catch (Exception e) {
                log.error("Failed to initialize Liquibase for schema {}", schema, e);
            }
        }

    }
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
/**
 * Create database schema for tenant.
 *
 * @param tenant - the tenant
 */
public void create(Tenant tenant) {
    StopWatch stopWatch = createStarted();
    log.info("START - SETUP:CreateTenant:schema tenantKey={}", tenant.getTenantKey());
    DatabaseUtil.createSchema(dataSource, tenant.getTenantKey());
    log.info("STOP - SETUP:CreateTenant:schema tenantKey={}, time={}ms", tenant.getTenantKey(),
        stopWatch.getTime());
    try {
        stopWatch.reset();
        stopWatch.start();
        log.info("START - SETUP:CreateTenant:liquibase tenantKey={}", tenant.getTenantKey());
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setResourceLoader(resourceLoader);
        liquibase.setDataSource(dataSource);
        liquibase.setChangeLog(CHANGE_LOG_PATH);
        liquibase.setContexts(liquibaseProperties.getContexts());
        liquibase.setDefaultSchema(tenant.getTenantKey());
        liquibase.setDropFirst(liquibaseProperties.isDropFirst());
        liquibase.setShouldRun(true);
        liquibase.afterPropertiesSet();
        log.info("STOP - SETUP:CreateTenant:liquibase tenantKey={}, time={}ms", tenant.getTenantKey(),
            stopWatch.getTime());
    } catch (LiquibaseException e) {
        throw new RuntimeException("Can not migrate database for creation tenant " + tenant.getTenantKey(), e);
    }
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Bean
public SpringLiquibase liquibase() {
    myLogger.info("Initializing Liquibase.");
    syncIfNecessary();

    // If the database is out of date, this will update it to the latest
    // schema.
    SpringLiquibase lb = new SpringLiquibase();
    lb.setChangeLog("classpath:db/changelog/db.changelog-master.yaml");
    lb.setDataSource(myDataSource);
    Map<String, String> params = Maps.newHashMap();
    params.put("verbose", "true");
    lb.setChangeLogParameters(params);
    lb.setShouldRun(true);

    return lb;
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
private SpringLiquibase getXmSpringLiquibase(DataSource dataSource) {
    SpringLiquibase liquibase = new SpringLiquibase();
    liquibase.setChangeLog(getChangeLog());
    liquibase.setChangeLogParameters(getParameters());
    liquibase.setContexts(getContexts());
    liquibase.setLabels(getLabels());
    liquibase.setDropFirst(isDropFirst());
    liquibase.setShouldRun(isShouldRun());
    liquibase.setRollbackFile(getRollbackFile());
    liquibase.setResourceLoader(getResourceLoader());
    liquibase.setDataSource(dataSource);
    liquibase.setDefaultSchema(getDefaultSchema());
    return liquibase;
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
/**
 * Create database schema for tenant.
 *
 * @param tenant - the tenant
 */
public void create(Tenant tenant) {
    final StopWatch stopWatch = createStarted();
    final String tenantKey = tenant.getTenantKey();

    log.info("START - SETUP:CreateTenant:schema tenantKey: {}", tenantKey);
    DatabaseUtil.createSchema(dataSource, tenantKey);
    log.info("STOP  - SETUP:CreateTenant:schema tenantKey: {}, time = {} ms", tenantKey,
        stopWatch.getTime());
    try {
        stopWatch.reset();
        stopWatch.start();
        log.info("START - SETUP:CreateTenant:liquibase tenantKey: {}", tenantKey);
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setResourceLoader(resourceLoader);
        liquibase.setDataSource(dataSource);
        liquibase.setChangeLog(CHANGE_LOG_PATH);
        liquibase.setContexts(liquibaseProperties.getContexts());
        liquibase.setDefaultSchema(tenantKey);
        liquibase.setDropFirst(liquibaseProperties.isDropFirst());
        liquibase.setShouldRun(true);
        liquibase.afterPropertiesSet();
        log.info("STOP  - SETUP:CreateTenant:liquibase tenantKey: {}, result: OK, time = {} ms", tenantKey,
            stopWatch.getTime());
    } catch (LiquibaseException e) {
        log.info("STOP  - SETUP:CreateTenant:liquibase tenantKey: {}, result: FAIL, error: {}, time = {} ms",
            tenantKey, e.getMessage(), stopWatch.getTime());
        throw new RuntimeException("Can not migrate database for creation tenant " + tenantKey, e);
    }
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
private SpringLiquibase getSpringLiquibase() {
    final SpringLiquibase liquibase = new SpringLiquibase();
    liquibase.setChangeLog(LIQUIBASE_CHANGELOG_LOCATION);
    liquibase.setResourceLoader(resourceLoader);
    liquibase.setDataSource(dataSource);
    return liquibase;
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testNoDataSource() throws Exception {
	this.context.register(LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	assertThat(this.context.getBeanNamesForType(SpringLiquibase.class).length)
			.isEqualTo(0);
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testDefaultSpringLiquibase() throws Exception {
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getChangeLog())
			.isEqualTo("classpath:/db/changelog/db.changelog-master.yaml");
	assertThat(liquibase.getContexts()).isNull();
	assertThat(liquibase.getDefaultSchema()).isNull();
	assertThat(liquibase.isDropFirst()).isFalse();
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testXmlChangeLog() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context,
			"liquibase.change-log:classpath:/db/changelog/db.changelog-override.xml");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getChangeLog())
			.isEqualTo("classpath:/db/changelog/db.changelog-override.xml");
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testJsonChangeLog() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context,
			"liquibase.change-log:classpath:/db/changelog/db.changelog-override.json");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getChangeLog())
			.isEqualTo("classpath:/db/changelog/db.changelog-override.json");
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testSqlChangeLog() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context,
			"liquibase.change-log:classpath:/db/changelog/db.changelog-override.sql");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getChangeLog())
			.isEqualTo("classpath:/db/changelog/db.changelog-override.sql");
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testOverrideContexts() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context,
			"liquibase.contexts:test, production");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getContexts()).isEqualTo("test, production");
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testOverrideDefaultSchema() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context,
			"liquibase.default-schema:public");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.getDefaultSchema()).isEqualTo("public");
}
 

import liquibase.integration.spring.SpringLiquibase; //导入依赖的package包/类
@Test
public void testOverrideDropFirst() throws Exception {
	EnvironmentTestUtils.addEnvironment(this.context, "liquibase.drop-first:true");
	this.context.register(EmbeddedDataSourceConfiguration.class,
			LiquibaseAutoConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class);
	this.context.refresh();
	SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
	assertThat(liquibase.isDropFirst()).isTrue();
}