Open Source Repository

Home /spring/spring-jdbc-3.0.5 | Repository Home



org/springframework/jdbc/datasource/embedded/EmbeddedDatabaseFactory.java
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.jdbc.datasource.embedded;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.jdbc.datasource.init.DatabasePopulator;
import org.springframework.util.Assert;

/**
 * Creates a {@link EmbeddedDatabase} instance. Callers are guaranteed that the returned database has been fully
 * initialized and populated.
 *
 <p>Can be configured:<br>
 * Call {@link #setDatabaseName(String)} to change the name of the database.<br>
 * Call {@link #setDatabaseType(EmbeddedDatabaseType)} to set the database type if you wish to use one of the supported types.<br>
 * Call {@link #setDatabaseConfigurer(EmbeddedDatabaseConfigurer)} to configure support for your own embedded database type.<br>
 * Call {@link #setDatabasePopulator(DatabasePopulator)} to change the algorithm used to populate the database.<br>
 * Call {@link #setDataSourceFactory(DataSourceFactory)} to change the type of DataSource used to connect to the database.<br>
 * Call {@link #getDatabase()} to get the {@link EmbeddedDatabase} instance.<br>
 *
 @author Keith Donald
 @author Juergen Hoeller
 @since 3.0
 */
public class EmbeddedDatabaseFactory {

  private static Log logger = LogFactory.getLog(EmbeddedDatabaseFactory.class);

  private String databaseName = "testdb";

  private DataSourceFactory dataSourceFactory = new SimpleDriverDataSourceFactory();

  private EmbeddedDatabaseConfigurer databaseConfigurer;

  private DatabasePopulator databasePopulator;

  private DataSource dataSource;


  /**
   * Set the name of the database. Defaults to "testdb".
   @param databaseName name of the test database
   */
  public void setDatabaseName(String databaseName) {
    Assert.notNull(databaseName, "Database name is required");
    this.databaseName = databaseName;
  }

  /**
   * Set the type of embedded database to use. Call this when you wish to configure
   * one of the pre-supported types. Defaults to HSQL.
   @param type the test database type
   */
  public void setDatabaseType(EmbeddedDatabaseType type) {
    this.databaseConfigurer = EmbeddedDatabaseConfigurerFactory.getConfigurer(type);
  }

  /**
   * Set the strategy that will be used to configure the embedded database instance.
   * Call this when you wish to use an embedded database type not already supported.
   @param configurer the embedded database configurer
   */
  public void setDatabaseConfigurer(EmbeddedDatabaseConfigurer configurer) {
    Assert.notNull(configurer, "EmbeddedDatabaseConfigurer is required");
    this.databaseConfigurer = configurer;
  }

  /**
   * Set the strategy that will be used to populate the embedded database. Defaults to null.
   @param populator the database populator
   */
  public void setDatabasePopulator(DatabasePopulator populator) {
    Assert.notNull(populator, "DatabasePopulator is required");
    this.databasePopulator = populator;
  }

  /**
   * Set the factory to use to create the DataSource instance that connects to the embedded database.
   * Defaults to {@link SimpleDriverDataSourceFactory}.
   @param dataSourceFactory the data source factory
   */
  public void setDataSourceFactory(DataSourceFactory dataSourceFactory) {
    Assert.notNull(dataSourceFactory, "DataSourceFactory is required");
    this.dataSourceFactory = dataSourceFactory;
  }

  /**
   * Factory method that returns the embedded database instance.
   */
  public EmbeddedDatabase getDatabase() {
    if (this.dataSource == null) {
      initDatabase();
    }
    return new EmbeddedDataSourceProxy(this.dataSource);
  }


  /**
   * Hook to initialize the embedded database. Subclasses may call to force initialization. After calling this method,
   {@link #getDataSource()} returns the DataSource providing connectivity to the db.
   */
  protected void initDatabase() {
    // Create the embedded database source first
    if (logger.isInfoEnabled()) {
      logger.info("Creating embedded database '" this.databaseName + "'");
    }
    if (this.databaseConfigurer == null) {
      this.databaseConfigurer = EmbeddedDatabaseConfigurerFactory.getConfigurer(EmbeddedDatabaseType.HSQL);
    }
    this.databaseConfigurer.configureConnectionProperties(
        this.dataSourceFactory.getConnectionProperties()this.databaseName);
    this.dataSource = this.dataSourceFactory.getDataSource();

    // Now populate the database
    if (this.databasePopulator != null) {
      try {
        populateDatabase();
      }
      catch (RuntimeException ex) {
        // failed to populate, so leave it as not initialized
        shutdownDatabase();
        throw ex;
      }
    }
  }

  private void populateDatabase() {
    try {
      Connection connection = this.dataSource.getConnection();
      try {
        this.databasePopulator.populate(connection);
      }
      finally {
        try {
          connection.close();
        }
        catch (SQLException ex) {
          // ignore
        }
      }
    }
    catch (Exception ex) {
      throw new DataAccessResourceFailureException("Failed to populate database", ex);
    }
  }

  /**
   * Hook that gets the DataSource that provides the connectivity to the embedded database.
   <p>Returns null if the DataSource has not been initialized or the database has been shut down.
   * Subclasses may call to access the datasource instance directly.
   */
  protected DataSource getDataSource() {
    return this.dataSource;
  }

  /**
   * Hook to shutdown the embedded database. Subclasses may call to force shutdown.
   * After calling, {@link #getDataSource()} returns null. Does nothing if no embedded database has been initialized.
   */
  protected void shutdownDatabase() {
    if (this.dataSource != null) {
      this.databaseConfigurer.shutdown(this.dataSource, this.databaseName);
      this.dataSource = null;
    }
  }


  private class EmbeddedDataSourceProxy implements EmbeddedDatabase {

    private final DataSource dataSource;

    public EmbeddedDataSourceProxy(DataSource dataSource) {
      this.dataSource = dataSource;
    }

    public Connection getConnection() throws SQLException {
      return this.dataSource.getConnection();
    }

    public Connection getConnection(String username, String passwordthrows SQLException {
      return this.dataSource.getConnection(username, password);
    }

    public PrintWriter getLogWriter() throws SQLException {
      return this.dataSource.getLogWriter();
    }

    public void setLogWriter(PrintWriter outthrows SQLException {
      this.dataSource.setLogWriter(out);
    }

    public int getLoginTimeout() throws SQLException {
      return this.dataSource.getLoginTimeout();
    }

    public void setLoginTimeout(int secondsthrows SQLException {
      this.dataSource.setLoginTimeout(seconds);
    }

    public <T> T unwrap(Class<T> ifacethrows SQLException {
      return this.dataSource.unwrap(iface);
    }

    public boolean isWrapperFor(Class<?> ifacethrows SQLException {
      return this.dataSource.isWrapperFor(iface);
    }

    public void shutdown() {
      shutdownDatabase();
    }
  }

}