import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private Liquibase getLiquibase(Connection connection) throws Exception {
    ServiceLocator sl = ServiceLocator.getInstance();
    if (!System.getProperties().containsKey("liquibase.scan.packages")) {
        if (sl.getPackages().remove("liquibase.core")) {
            sl.addPackageToScan("liquibase.core.xml");
        }
        if (sl.getPackages().remove("liquibase.parser")) {
            sl.addPackageToScan("liquibase.parser.core.xml");
        }
        if (sl.getPackages().remove("liquibase.serializer")) {
            sl.addPackageToScan("liquibase.serializer.core.xml");
        }
        sl.getPackages().remove("liquibase.ext");
        sl.getPackages().remove("liquibase.sdk");
    }
    LogFactory.setInstance(new LogWrapper());
    Database database = DatabaseFactory.getInstance().findCorrectDatabaseImplementation(new JdbcConnection(connection));
    return new Liquibase(CHANGELOG, new ClassLoaderResourceAccessor(getClass().getClassLoader()), database);
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private ChangeLogParserFactory() {
    Class<? extends ChangeLogParser>[] classes;
    changelogParserComparator = new Comparator<ChangeLogParser>() {
        public int compare(ChangeLogParser o1, ChangeLogParser o2) {
            return Integer.valueOf(o2.getPriority()).compareTo(o1.getPriority());
        }
    };

    parsers = new ArrayList<ChangeLogParser>();
    try {
        classes = ServiceLocator.getInstance().findClasses(ChangeLogParser.class);

        for (Class<? extends ChangeLogParser> clazz : classes) {
                register((ChangeLogParser) clazz.getConstructor().newInstance());
        }
    } catch (Exception e) {
        throw new UnexpectedLiquibaseException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
protected AbstractIntegrationTest(String changelogDir, String url) throws Exception {
    LogFactory.setLoggingLevel("info");

    this.completeChangeLog = "changelogs/" + changelogDir + "/complete/root.changelog.xml";
    this.rollbackChangeLog = "changelogs/" + changelogDir + "/rollback/rollbackable.changelog.xml";
    this.includedChangeLog = "changelogs/" + changelogDir + "/complete/included.changelog.xml";
    this.encodingChangeLog = "changelogs/common/encoding.changelog.xml";
    this.externalfkInitChangeLog= "changelogs/common/externalfk.init.changelog.xml";
    this.externalEntityChangeLog= "changelogs/common/externalEntity.changelog.xml";
    this.externalEntityChangeLog2= "com/example/nonIncluded/externalEntity.changelog.xml";
    this.invalidReferenceChangeLog= "changelogs/common/invalid.reference.changelog.xml";
    this.objectQuotingStrategyChangeLog = "changelogs/common/object.quoting.strategy.changelog.xml";

    this.url = url;

    ServiceLocator.getInstance().setResourceAccessor(TestContext.getInstance().getTestResourceAccessor());
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
public static void replaceLiquibaseServiceLocator() {
    final CustomResolverServiceLocator customResolverServiceLocator =
            new CustomResolverServiceLocator(new SpringPackageScanClassResolver());
    customResolverServiceLocator.addPackageToScan(Slf4jLiquibaseLogger.class.getPackage().getName());
    ServiceLocator.setInstance(customResolverServiceLocator);
    liquibase.logging.LogFactory.reset();
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@Test
public void replacesServiceLocator() throws Exception {
	SpringApplication application = new SpringApplication(Conf.class);
	application.setWebEnvironment(false);
	this.context = application.run();
	ServiceLocator instance = ServiceLocator.getInstance();
	Field field = ReflectionUtils.findField(ServiceLocator.class, "classResolver");
	field.setAccessible(true);
	Object resolver = field.get(instance);
	assertThat(resolver).isInstanceOf(SpringPackageScanClassResolver.class);
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@PostConstruct
public void checkChangelogExists() {
	if (this.properties.isCheckChangeLogLocation()) {
		Resource resource = this.resourceLoader
				.getResource(this.properties.getChangeLog());
		Assert.state(resource.exists(),
				"Cannot find changelog location: " + resource
						+ " (please add changelog or check your Liquibase "
						+ "configuration)");
	}
	ServiceLocator serviceLocator = ServiceLocator.getInstance();
	serviceLocator.addPackageToScan(
			CommonsLoggingLiquibaseLogger.class.getPackage().getName());
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@Test
public void replacesServiceLocator() throws Exception {
	SpringApplication application = new SpringApplication(Conf.class);
	application.setWebEnvironment(false);
	this.context = application.run();
	ServiceLocator instance = ServiceLocator.getInstance();
	Field field = ReflectionUtils.findField(ServiceLocator.class, "classResolver");
	field.setAccessible(true);
	Object resolver = field.get(instance);
	assertThat(resolver, instanceOf(SpringPackageScanClassResolver.class));
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@Override
public void start(final BundleContext context) throws Exception {
    final PackageScanClassResolver resolver = new OSGIPackageScanClassResolver(context.getBundle());
    ServiceLocator.setInstance(new CustomResolverServiceLocator(resolver));

    final ServiceReference<ConfigurationAdmin> configurationAdminServiceReference = context.getServiceReference(ConfigurationAdmin.class);
    if (configurationAdminServiceReference != null) {
        initialise(context, configurationAdminServiceReference);
    }

    final String filter = String.format("(objectClass=%s)", ConfigurationAdmin.class.getName());
    context.addServiceListener(this, filter);
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private SqlGeneratorFactory() {
    Class[] classes;
    try {
        classes = ServiceLocator.getInstance().findClasses(SqlGenerator.class);

        for (Class clazz : classes) {
            register((SqlGenerator) clazz.getConstructor().newInstance());
        }

    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
public static Logger getLogger(String name) {
    if (!loggers.containsKey(name)) {
        Logger value;
        try {
            value = (Logger) ServiceLocator.getInstance().newInstance(Logger.class);
        } catch (Exception e) {
            throw new ServiceNotFoundException(e);
        }
        value.setName(name);
        value.setLogLevel(defaultLoggingLevel);
        loggers.put(name, value);
    }

    return loggers.get(name);
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
protected DatabaseFactory() {
    try {
        Class[] classes = ServiceLocator.getInstance().findClasses(Database.class);

        //noinspection unchecked
        for (Class<? extends Database> clazz : classes) {
            register(clazz.getConstructor().newInstance());
        }

    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private TypeConverterFactory() {
    allConverters = new HashSet<TypeConverter>();
    try {
        for (Class<? extends TypeConverter> converterClass : ServiceLocator.getInstance().findClasses(TypeConverter.class)) {
            register(converterClass.newInstance());
        }
    } catch (Exception e) {
        throw new UnexpectedLiquibaseException(e);
    }
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private PreconditionFactory() {
    preconditions = new HashMap<String, Class<? extends Precondition>>();
    Class[] classes;
    try {
        classes = ServiceLocator.getInstance().findClasses(Precondition.class);

        for (Class<? extends Precondition> clazz : classes) {
                register(clazz);
        }
    } catch (Exception e) {
        throw new UnexpectedLiquibaseException(e);
    }
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private ChangeLogSerializerFactory() {
    Class<? extends ChangeLogSerializer>[] classes;
    try {
        classes = ServiceLocator.getInstance().findClasses(ChangeLogSerializer.class);

        for (Class<? extends ChangeLogSerializer> clazz : classes) {
                register((ChangeLogSerializer) clazz.getConstructor().newInstance());
        }
    } catch (Exception e) {
        throw new UnexpectedLiquibaseException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private DatabaseSnapshotGeneratorFactory() {
    try {
        Class[] classes = ServiceLocator.getInstance().findClasses(DatabaseSnapshotGenerator.class);

        for (Class<? extends DatabaseSnapshotGenerator> clazz : classes) {
            register(clazz.getConstructor().newInstance());
        }

    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
private ChangeFactory() {
    Class<? extends Change>[] classes;
    try {
        classes = ServiceLocator.getInstance().findClasses(Change.class);

        for (Class<? extends Change> clazz : classes) {
            //noinspection unchecked
            register(clazz);
        }

    } catch (Exception e) {
        throw new UnexpectedLiquibaseException(e);
    }

}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
public Executor getExecutor(Database database) {
    if (!executors.containsKey(database)) {
        try {
            Executor executor = (Executor) ServiceLocator.getInstance().newInstance(Executor.class);
            executor.setDatabase(database);
            executors.put(database, executor);
        } catch (Exception e) {
            throw new UnexpectedLiquibaseException(e);
        }
    }
    return executors.get(database);
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
public void replaceServiceLocator() {
	ServiceLocator.setInstance(new CustomResolverServiceLocator(
			new SpringPackageScanClassResolver(logger)));
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
public void replaceServiceLocator() {
	ServiceLocator.getInstance().addPackageToScan(
			CommonsLoggingLiquibaseLogger.class.getPackage().getName());
	ServiceLocator.setInstance(new CustomResolverServiceLocator(
			new SpringPackageScanClassResolver(logger)));
}
 

import liquibase.servicelocator.ServiceLocator; //导入依赖的package包/类
@PostConstruct
public void init() {
	ServiceLocator.setInstance(this);
}