Spring3/Hibernate-在运行时执行数据库转储

我正在用SpringRoo开发一个应用程序，它使用Spring3和hibernate。
由于后端的构建不是高效的，所以我可以选择将数据设置回转储

如果用户提交jsp表单，则应“执行”此转储。 我可以加载Dump.sql文件，一切正常，只是不知道如何执行它。 我尝试了几种方法：
1.实体管理器的本机查询：

Query q = entityManager.createNativeQuery(dump);  
q.executeUpdate();

但它不起作用（hibernate例外），我认为这是因为hibernate无法“读取”mysql导出的Dump.sql文件“
2.方法是只使用hibernate：

Configuration cfg = new Configuration();  
File configFile = new     File(getClass().getClassLoader().getResource("/METAINF/persistence.xml").toURI());  
cfg.configure(configFile);  
SessionFactory sf=cfg.buildSessionFactory();  
Session sess=sf.openSession();  
Statement st;  
st = sess.connection().createStatement();  

但它也不起作用：

org.hibernate.MappingException:配置无效 原因：org.xml.sax.SAXParseException:文档无效：未找到语法

---

有什么建议吗？

我曾经写过一个Java类，它从一个数据库转储数据，然后将数据导入另一个数据库（但它不使用MySQL生成的转储）。也许您可以看看它

该类取决于和：

import java.io.IOException；
导入java.sql.SQLException；
导入javax.sql.DataSource；
导入org.apache.commons.logging.Log；
导入org.apache.commons.logging.LogFactory；
导入org.apache.ddlutils.Platform；
导入org.apache.ddlutils.PlatformFactory；
导入org.apache.ddlutils.model.Database；
导入org.dbunit.DatabaseUnitException；
导入org.dbunit.database.DatabaseConnection；
导入org.dbunit.database.IDatabaseConnection；
导入org.dbunit.dataset.IDataSet；
导入org.dbunit.operation.DatabaseOperation；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.beans.factory.annotation.Qualifier；
导入org.springframework.beans.factory.annotation.Value；
导入org.springframework.context.ApplicationContext；
导入org.springframework.context.support.ClassPathXmlApplicationContext；
/**
*数据库之间的转储程序。
* 
*@author-ndevege
*/
公共最终类数据库转储程序{
/**
*洛格。
*/
私有静态最终日志记录器=LogFactory.getLog（DatabaseDumper.class）；
/**
*环境（开发、持续集成等）。
*/
@值（“#{envProperties['env']}”）
私有字符串环境；
/**
*要从中转储数据的数据库。
*/
@自动连线
@限定符（“referenceDataSource”）
私有数据源；
/**
*要向其中写入数据的数据库。
*/
@自动连线
@限定符（“数据源”）
私有数据源数据源；
/**
*我们需要运行转储吗？
*/
私有布尔多伦；
/**
*@returnthedorun
*/
公共布尔值isDoRun（）{
如果（多伦）{
返回true；
}
//仅在持续集成环境中运行转储
if（“持续集成”。等效信号案例（env））{
返回true；
}
返回false；
}
/**
*@param aDoRun
*要设置的多伦
*/
公共无效设置域（最终布尔值域）{
多伦=阿多伦；
}
/**
*如果不是由Spring初始化，则设置数据源。

*从命令行启动此实用程序时使用此方法。
* 
*@SQLException
*论错误
*/
私有void initDataSources（）引发SQLException{
if（sourceDataSource==null | | destDataSource==null）{
ApplicationContext context=new ClassPathXmlApplicationContext（“spring/dbDumperContext.xml”）；
sourceDataSource=（DataSource）context.getBean（“referenceDataSource”）；
destDataSource=（DataSource）context.getBean（“DataSource”）；
}
}
/**
*转储程序执行。
* 
*@抛出异常
*论错误
*/
public void execute（）引发异常{
如果（！isDoRun（））{
debug（“不要运行环境\”+env+“\”的转储）；
}否则{
LOGGER.warn（“警告！！！运行数据库转储，可能需要一些时间…”）；
长启动=System.currentTimeMillis（）；
//提取模式
数据库模式=转储模式（sourceDataSource）；
//创建模式
createSchema（destDataSource，schema）；
//提取数据
IDataSet数据集=转储数据（sourceDataSource）；
//导入数据
导入数据（数据源、数据集）；
if（LOGGER.isDebugEnabled（））{
LOGGER.debug（“数据库转储持续时间=”+（System.currentTimeMillis（）-start）+“ms”）；
}
}
}
/**
*使用ddlutils提取模式。
* 
*@param aSourceDataSource
*源数据库
*@返回包含架构的outputstream
*@抛出DatabaseUnitException
*论错误
*@SQLException
*论错误
*@抛出异常
*论错误
*/
私有IDataSet dumpData（最终数据源aSourceDataSource）抛出DatabaseUnitException、SQLException、，
IOException{
IDatabaseConnection sourceConnection=新数据库连接（aSourceDataSource.getConnection（））；
返回sourceConnection.createDataSet（）；
}
/**
*使用dbUnit提取数据。
* 
*@param aSourceDataSource
*源数据库
*@返回包含数据的outputstream
*/
专用数据库转储模式（最终数据源aSourceDataSource）{
返回PlatformFactory.createNewPlatformInstance（aSourceDataSource.readModelFromDatabase（“sourceModel”）；
}
/**
*在目标数据库中创建架构。
* 
*@param aDestDataSource
*目标数据库
*@param模式
*模式
*/
私有void createSchema（最终数据源aDestDataSource，最终数据库架构）{
平台destformplatform=PlatformFactory.createNewPlatformInsta
import java.io.IOException;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ddlutils.Platform;
import org.apache.ddlutils.PlatformFactory;
import org.apache.ddlutils.model.Database;
import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.dataset.IDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Dumper between databases.
 * 
 * @author ndeverge
 */
public final class DatabaseDumper {

    /**
     * Le logger.
     */
    private static final Log LOGGER = LogFactory.getLog(DatabaseDumper.class);

    /**
     * Environment (dev, continuous integration etc...).
     */
    @Value("#{envProperties['env']}")
    private String env;

    /**
     * The db to dump data from.
     */
    @Autowired
    @Qualifier("referenceDataSource")
    private DataSource sourceDataSource;

    /**
     * the db where to write data to.
     */
    @Autowired
    @Qualifier("dataSource")
    private DataSource destDataSource;

    /**
     * Do we need to run the dump ?
     */
    private boolean doRun;

    /**
     * @return the doRun
     */
    public boolean isDoRun() {
        if (doRun) {
            return true;
        }
        // run the dump only on continuous-integration environment
        if ("continuous-integration".equalsIgnoreCase(env)) {
            return true;
        }
        return false;
    }

    /**
     * @param aDoRun
     *            the doRun to set
     */
    public void setDoRun(final boolean aDoRun) {
        doRun = aDoRun;
    }

    /**
     * Set datasources if not initialized by Spring.<br>
     * This method is used when this utility is started from command line.
     * 
     * @throws SQLException
     *             on errors
     */
    private void initDataSources() throws SQLException {

        if (sourceDataSource == null || destDataSource == null) {
            ApplicationContext context = new ClassPathXmlApplicationContext("spring/dbDumperContext.xml");

            sourceDataSource = (DataSource) context.getBean("referenceDataSource");

            destDataSource = (DataSource) context.getBean("dataSource");
        }

    }

    /**
     * Dumper execution.
     * 
     * @throws Exception
     *             on errors
     */
    public void execute() throws Exception {

        if (!isDoRun()) {
            LOGGER.debug("Do not run the dump for environment \"" + env + "\"");
        } else {

            LOGGER.warn("WARNING !!! Running the database dump, it may take some time...");

            long start = System.currentTimeMillis();

            // extract schema
            Database schema = dumpSchema(sourceDataSource);

            // create schema
            createSchema(destDataSource, schema);

            // extract data
            IDataSet dataSet = dumpData(sourceDataSource);

            // import data
            importData(destDataSource, dataSet);

            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Database dump duration = " + (System.currentTimeMillis() - start) + " ms");
            }
        }
    }

    /**
     * Extract schema using ddlutils.
     * 
     * @param aSourceDataSource
     *            source db
     * @return an outputstream containing the schema
     * @throws DatabaseUnitException
     *             on errors
     * @throws SQLException
     *             on errors
     * @throws IOException
     *             on errors
     */
    private IDataSet dumpData(final DataSource aSourceDataSource) throws DatabaseUnitException, SQLException,
            IOException {
        IDatabaseConnection sourceConnection = new DatabaseConnection(aSourceDataSource.getConnection());

        return sourceConnection.createDataSet();
    }

    /**
     * Extract data using dbUnit.
     * 
     * @param aSourceDataSource
     *            source db
     * @return an outputstream containing the data
     */
    private Database dumpSchema(final DataSource aSourceDataSource) {
        return PlatformFactory.createNewPlatformInstance(aSourceDataSource).readModelFromDatabase("sourceModel");

    }

    /**
     * Create schema in destination db.
     * 
     * @param aDestDataSource
     *            the destination db
     * @param schema
     *            the schema
     */
    private void createSchema(final DataSource aDestDataSource, final Database schema) {
        Platform destPlatform = PlatformFactory.createNewPlatformInstance(aDestDataSource);

        // create schema by droping tables firts (2nd parameter = true)
        destPlatform.createTables(schema, true, true);
    }

    /**
     * Data import.
     * 
     * @param aDestDataSource
     *            the destination db
     * @param dataSet
     *            the data
     * @throws SQLException
     *             on errors
     * @throws DatabaseUnitException
     *             on errors
     */
    private void importData(final DataSource aDestDataSource, final IDataSet dataSet) throws DatabaseUnitException,
            SQLException {
        IDatabaseConnection destConnection = new DatabaseConnection(aDestDataSource.getConnection());

        DatabaseOperation.CLEAN_INSERT.execute(destConnection, dataSet);
    }

    /**
     * Launch the dumper from commande line.
     * 
     * @param args
     *            paramètres
     */
    public static void main(final String[] args) {
        try {
            DatabaseDumper dumper = new DatabaseDumper();
            dumper.setDoRun(true);
            dumper.initDataSources();
            dumper.execute();
        } catch (Exception e) {
            LOGGER.error("", e);
        }
    }

}