import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
@Override
public void before() throws Throwable {
  port = defaultPort;
  if (port  < 0) {
    port = Helper.findRandomOpenPortOnAllLocalInterfaces();
  }

  postgresRuntime = PostgresStarter.getDefaultInstance()
      .prepare(
          new PostgresConfig(
              version,
              new Net("localhost", port),
              new Storage(databaseName),
              new Timeout(30000),
              new Credentials(username, password)))
      .start();
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
public synchronized void start() throws IOException {
	if (process != null) {
		throw new IllegalStateException();
	}

	Command command = Command.Postgres;

	IDownloadConfig downloadConfig = new PostgresDownloadConfigBuilder()
			.defaultsForCommand(command)
			.artifactStorePath(new FixedPath(artifactStorePath))
			.build();

	ArtifactStoreBuilder artifactStoreBuilder = new PostgresArtifactStoreBuilder()
			.defaults(command)
			.download(downloadConfig);

	LogWatchStreamProcessor logWatch = new LogWatchStreamProcessor("started",
			new HashSet<>(singletonList("failed")),
			new Slf4jStreamProcessor(getLogger("postgres"), Slf4jLevel.TRACE));

	IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
			.defaults(command)
			.processOutput(new ProcessOutput(logWatch, logWatch, logWatch))
			.artifactStore(artifactStoreBuilder)
			.build();

	PostgresStarter<PostgresExecutable, PostgresProcess> starter = new PostgresStarter<>(PostgresExecutable.class, runtimeConfig);

	PostgresConfig config = new PostgresConfig(version,
			new AbstractPostgresConfig.Net(host, port == 0 ? Network.getFreeServerPort() : port),
			new AbstractPostgresConfig.Storage(dbName),
			new AbstractPostgresConfig.Timeout(),
			new AbstractPostgresConfig.Credentials(username, password));
	process = starter.prepare(config).start();
	jdbcUrl = "jdbc:postgresql://" + config.net().host() + ":" + config.net().port() + "/" + config.storage().dbName();
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
protected static PostgresConfig launchPostgres() throws IOException {
    PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getDefaultInstance();
    final PostgresConfig pgConfig = PostgresConfig.defaultWithDbName("eventsourcing",
                                                                     "eventsourcing", "eventsourcing");
    PostgresExecutable exec = runtime.prepare(pgConfig);
    PostgresProcess process = exec.start();

    Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override public void run() {
            process.stop();
        }
    });

    return pgConfig;
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
@BeforeClass
public static void setupPostgres() {
    try {
        PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getDefaultInstance();
        final PostgresConfig config = PostgresConfig.defaultWithDbName("test","testuser","testpw");
        PostgresExecutable exec = runtime.prepare(config);
        postgresProcess = exec.start();
        Jdbc3SimpleDataSource _postgresDatasource = new Jdbc3SimpleDataSource();
        _postgresDatasource.setServerName(config.net().host());
        _postgresDatasource.setPortNumber(config.net().port());
        _postgresDatasource.setDatabaseName(config.storage().dbName());
        _postgresDatasource.setUser(config.credentials().username());
        _postgresDatasource.setPassword(config.credentials().password());
        _postgresDatasource.setAutosave(AutoSave.NEVER);
        postgresDatasource = Mockito.spy(_postgresDatasource);
        Mockito.when(postgresDatasource.getConnection()).thenAnswer(new Answer<Connection>() {
            @Override
            public Connection answer(InvocationOnMock invocation) throws Throwable {
                Connection connection = _postgresDatasource.getConnection();
                connection.setAutoCommit(false);
                return connection;
            }
        });
    } catch (IOException | SQLException e) {
        throw new RuntimeException(e);
    }
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
DatabaseRule(ConnectionPoolBuilder builder) {
    this.builder = builder;
    if (builder instanceof EmbeddedConnectionPoolBuilder)
    {
        if (process == null)
        {
            try
            {
                PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getDefaultInstance();
                PostgresConfig config = new PostgresConfig(V9_6_2, new AbstractPostgresConfig.Net(),
                    new AbstractPostgresConfig.Storage("async-pg"), new AbstractPostgresConfig.Timeout(),
                    new AbstractPostgresConfig.Credentials("async-pg", "async-pg"));
                PostgresExecutable exec = runtime.prepare(config);
                process = exec.start();

                out.printf("Started postgres to %s:%d%n", process.getConfig().net().host(), process.getConfig().net().port());
            }
            catch (IOException e)
            {
                throw new RuntimeException(e);
            }
        }

        builder.hostname(process.getConfig().net().host());
        builder.port(process.getConfig().net().port());
    }
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    //embedded postgres db
    PostgresProcess postgresProcess;
    PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getDefaultInstance();
    final PostgresConfig config = PostgresConfig.defaultWithDbName("test","testuser","testpw");
    PostgresExecutable exec = runtime.prepare(config);
    postgresProcess = exec.start();
    Jdbc3SimpleDataSource postgresDatasource = new Jdbc3SimpleDataSource();
    postgresDatasource.setServerName(config.net().host());
    postgresDatasource.setPortNumber(config.net().port());
    postgresDatasource.setDatabaseName(config.storage().dbName());
    postgresDatasource.setUser(config.credentials().username());
    postgresDatasource.setPassword(config.credentials().password());
    postgresDatasource.setAutosave(AutoSave.NEVER);
    DisableAutocommitDatasource datasource = new DisableAutocommitDatasource(postgresDatasource);

    System.out.println("\n\n\n\n\n\n\n\n");

    RootFactory root = new RootFactory();
    root.stringAttribute.set("1");
    DataSerialisationManager<RootFactory,Void> serialisationManager = new DataSerialisationManager<>(new JacksonSerialisation<>(1),new JacksonDeSerialisation<>(RootFactory.class,1),new ArrayList<>(),1);
    PostgresDataStorage<RootFactory,Void> postgresFactoryStorage = new PostgresDataStorage<>(datasource, root, serialisationManager);


    ApplicationServer<Void,Root, RootFactory,Void> applicationServer = new ApplicationServer<>(new FactoryManager<>(new RethrowingFactoryExceptionHandler<>()),postgresFactoryStorage);
    applicationServer.start();
    //output is 1 from initial factory

    DataAndNewMetadata<RootFactory> update = applicationServer.prepareNewFactory();
    update.root.stringAttribute.set("2");
    applicationServer.updateCurrentFactory(update, "", "", s -> true);
    //output is 2 from initial factory

    applicationServer.stop();
    ApplicationServer<Void,Root, RootFactory,Void> newApplicationServer = new ApplicationServer<>(new FactoryManager<>(new RethrowingFactoryExceptionHandler<>()),postgresFactoryStorage);
    newApplicationServer.start();
    //output is 2 again from the saved update



    System.out.println("\n\n\n\n\n\n\n\n");
    postgresProcess.stop();


}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
/**
 * Start an embedded PostgreSQL using the configuration of {@link #getConnectionConfig()}.
 * It also sets embedded mode to true, see {@link #setIsEmbedded(boolean)}, but
 * doesn't change the configuration.
 *
 * @throws IOException  when starting embedded PostgreSQL fails
 */
public void startEmbeddedPostgres() throws IOException {
  // starting Postgres
  embeddedMode = true;
  if (postgresProcess == null || !postgresProcess.isProcessRunning()) {
    // turns off the default functionality of unzipping on every run.
    IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder()
      .defaults(Command.Postgres)
      .artifactStore(
        new NonCachedPostgresArtifactStoreBuilder().defaults(Command.Postgres).
        download(new PostgresDownloadConfigBuilder().defaultsForCommand(Command.Postgres)
        // .progressListener(new LoggingProgressListener(logger, Level.ALL))
          .build())).build();
    PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getInstance(runtimeConfig);

    int port = postgreSQLClientConfig.getInteger(PORT);
    String username = postgreSQLClientConfig.getString(_USERNAME);
    String password = postgreSQLClientConfig.getString(_PASSWORD);
    String database = postgreSQLClientConfig.getString(DATABASE);

    String locale = "en_US.UTF-8";
    String OS = System.getProperty("os.name").toLowerCase();
    if(OS.indexOf("win") >= 0){
      locale = "american_usa";
    }

    final PostgresConfig config = new PostgresConfig(Version.Main.V9_6,
      new AbstractPostgresConfig.Net(DEFAULT_IP, port),
      new AbstractPostgresConfig.Storage(database),
      new AbstractPostgresConfig.Timeout(20000),
      new AbstractPostgresConfig.Credentials(username, password));

    config.getAdditionalInitDbParams().addAll(Arrays.asList(
      "-E", "UTF-8",
      "--locale", locale
    ));

    postgresProcess = runtime.prepare(config).start();

    log.info("embedded postgress started....");
  } else {
    log.info("embedded postgress is already running...");
  }
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
PostgresProcess startPostgres(PostgresConfig postgresConfig) throws IOException {
  log.debug("startPostgres(PostgresConfig)");
  return PostgresStarter.getDefaultInstance().prepare(postgresConfig).start();
}
 

import ru.yandex.qatools.embed.postgresql.PostgresStarter; //导入依赖的package包/类
String initializePostgresql() throws SQLException, IOException,
                              URISyntaxException {

    String password = System.getProperty(NAVI_PASSWORD, "changeMe"); // TODO no default
    final Command cmd = Command.Postgres;
    // the cached directory should contain pgsql folder
    final FixedPath cachedDir = new FixedPath(UAAS_POSTGRES);
    ArtifactStoreBuilder download = new CachedArtifactStoreBuilder().defaults(cmd)
                                                                    .tempDir(cachedDir)
                                                                    .download(new DownloadConfigBuilder().defaultsForCommand(cmd)
                                                                                                         .packageResolver(new PackagePaths(cmd,
                                                                                                                                           cachedDir))
                                                                                                         .build());
    IRuntimeConfig runtimeConfig = new RuntimeConfigBuilder().defaults(cmd)
                                                             .artifactStore(download)
                                                             .build();

    PostgresStarter<PostgresExecutable, PostgresProcess> runtime = PostgresStarter.getInstance(runtimeConfig);

    log.info("Starting Postgres");
    final PostgresConfig config = new PostgresConfig(PRODUCTION,
                                                     new Net("localhost",
                                                             findFreePort()),
                                                     new Storage(NAVI,
                                                                 UAAS_STATE),
                                                     new Timeout(),
                                                     new Credentials(NAVI,
                                                                     password));
    // pass info regarding encoding, locale, collate, ctype, instead of setting global environment settings
    config.getAdditionalInitDbParams()
          .addAll(Arrays.asList("-E", "UTF-8", "--locale=en_US.UTF-8",
                                "--lc-collate=en_US.UTF-8",
                                "--lc-ctype=en_US.UTF-8"));
    PostgresExecutable exec = runtime.prepare(config);
    PostgresProcess process = exec.start();
    Runtime.getRuntime()
           .addShutdownHook(new Thread(() -> process.stop(),
                                       "Local NAVI shutdown"));

    String uri = String.format("jdbc:postgresql://%s:%s/%s?user=%s&password=%s",
                               config.net()
                                     .host(),
                               config.net()
                                     .port(),
                               config.storage()
                                     .dbName(),
                               config.credentials()
                                     .username(),
                               config.credentials()
                                     .password());

    DbaConfiguration dbaConfig = new DbaConfiguration();
    dbaConfig.coreDb = config.storage()
                             .dbName();
    dbaConfig.corePort = config.net()
                               .port();
    dbaConfig.coreServer = config.net()
                                 .host();
    dbaConfig.coreUsername = config.credentials()
                                   .username();
    dbaConfig.corePassword = config.credentials()
                                   .password();
    try {
        new Loader(dbaConfig).bootstrap();
    } catch (Exception e) {
        throw new IllegalStateException("Cannot bootstrap CORE", e);
    }
    return uri;
}