Java Code Examples for org.hibernate.boot.Metadata

@Override
public String[] getSqlDropStrings(Table table, Metadata metadata)
{
	// Check for actually existing table and indices.
	if (!tableExists(table))
		return new String[] {};
	Set<String> existingIndices = getIndicesExcludingPK(table);

	if (existingIndices.isEmpty())
		return super.getSqlDropStrings(table, metadata);

	List<String> dropIndices = new ArrayList<>();
	for (String index : existingIndices)
	{
		dropIndices.add("DROP INDEX `" + index + "`");
	}
	String[] tableDrop = super.getSqlDropStrings(table, metadata);

	String[] res = new String[dropIndices.size() + tableDrop.length];
	dropIndices.toArray(res);
	System.arraycopy(tableDrop, 0, res, dropIndices.size(), tableDrop.length);

	return res;
}
 

@Override
public String getAlterTableToDropUniqueKeyCommand(UniqueKey uniqueKey, Metadata metadata)
{
	// First check that this unique key actually is present, as this is a
	// lot faster than trying to drop it and then fail.
	initIndices();
	UniqueIndex idx = indices.getIndex(uniqueKey);
	if (idx == null)
	{
		return null;
	}
	// Remove from cache
	indices.removeIndex(uniqueKey);
	final StringBuilder buf = new StringBuilder("DROP INDEX ");
	buf.append(dialect.quote(uniqueKey.getName()));

	return buf.toString();
}
 

protected void applyConstraints(Metadata metadata) {
	File tempFile = null;
   	try {
       	tempFile = File.createTempFile("schema", ".sql");
       	new SchemaExport().setOutputFile(tempFile.getAbsolutePath())
       			.setFormat(false).createOnly(EnumSet.of(TargetType.SCRIPT), metadata);
       	List<String> sqls = new ArrayList<>();
       	for (String sql: FileUtils.readLines(tempFile)) {
       		if (isApplyingConstraints(sql)) {
       			sqls.add(sql);
       		}
       	}
       	execute(sqls, true);
   	} catch (IOException e) {
   		throw new RuntimeException(e);
   	} finally {
   		if (tempFile != null)
   			tempFile.delete();
   	}
}
 

protected void createTables(Metadata metadata) {
	File tempFile = null;
   	try {
       	tempFile = File.createTempFile("schema", ".sql");
       	new SchemaExport().setOutputFile(tempFile.getAbsolutePath())
       			.setFormat(false).createOnly(EnumSet.of(TargetType.SCRIPT), metadata);
       	List<String> sqls = new ArrayList<>();
       	for (String sql: FileUtils.readLines(tempFile)) {
       		if (shouldInclude(sql) && !isApplyingConstraints(sql))
       			sqls.add(sql);
       	}
       	execute(sqls, true);
   	} catch (IOException e) {
   		throw new RuntimeException(e);
   	} finally {
   		if (tempFile != null)
   			FileUtils.deleteFile(tempFile);
   	}
}
 

protected void dropConstraints(Metadata metadata) {
	File tempFile = null;
   	try {
       	tempFile = File.createTempFile("schema", ".sql");
       	new SchemaExport().setOutputFile(tempFile.getAbsolutePath())
       			.setFormat(false).drop(EnumSet.of(TargetType.SCRIPT), metadata);
       	List<String> sqls = new ArrayList<>();
       	for (String sql: FileUtils.readLines(tempFile)) {
       		if (isDroppingConstraints(sql))
       			sqls.add(sql);
       	}
       	execute(sqls, false);
   	} catch (IOException e) {
   		throw new RuntimeException(e);
   	} finally {
   		if (tempFile != null)
   			tempFile.delete();
   	}
}
 

protected void cleanDatabase(Metadata metadata) {
	File tempFile = null;
   	try {
       	tempFile = File.createTempFile("schema", ".sql");
       	new SchemaExport().setOutputFile(tempFile.getAbsolutePath())
       			.setFormat(false).drop(EnumSet.of(TargetType.SCRIPT), metadata);
       	List<String> sqls = new ArrayList<>();
       	for (String sql: FileUtils.readLines(tempFile)) {
       		sqls.add(sql);
       	}
       	execute(sqls, false);
   	} catch (IOException e) {
   		throw new RuntimeException(e);
   	} finally {
   		if (tempFile != null)
   			tempFile.delete();
   	}
}
 

@Override
public void start() {
	if (Bootstrap.isServerRunning(Bootstrap.installDir)) {
		logger.error("Please stop server before cleaning database");
		System.exit(1);
	}
	checkDataVersion(false);

	Metadata metadata = buildMetadata();
	cleanDatabase(metadata);

	if (getDialect().toLowerCase().contains("hsql")) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
	}
	logger.info("Database is cleaned successfully");
	
	System.exit(0);
}
 

@Override
public void integrate(Metadata metadata, SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry) {
    EventListenerRegistry service = serviceRegistry.getService(org.hibernate.event.service.spi.EventListenerRegistry.class);

    StandardPBEStringEncryptor encrypt = new StandardPBEStringEncryptor();
    encrypt.setPassword("test_password");
    RenderedMessageEncryptEventListener encryptListener = new RenderedMessageEncryptEventListener();
    encryptListener.setStringEncryptor(encrypt);

    RenderedMessageDecryptEventListener decryptListener = new RenderedMessageDecryptEventListener();
    decryptListener.setStringEncryptor(encrypt);

    FullTextIndexEventListener fullTextListener = new FullTextIndexEventListener();

    service.appendListeners(EventType.PRE_UPDATE, encryptListener);
    service.prependListeners(EventType.POST_UPDATE, decryptListener);
    service.appendListeners(EventType.PRE_INSERT, encryptListener);
    service.prependListeners(EventType.POST_INSERT, decryptListener);
    service.appendListeners(EventType.POST_LOAD, decryptListener);
}
 

@Override
public void start() {
    StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.connection.username", config.persistence.user)
            .applySetting("hibernate.connection.password", config.persistence.pass)
            .applySetting("hibernate.connection.driver_class", config.persistence.driver)
            .applySetting("hibernate.connection.url", config.persistence.url)
            .applySetting("hibernate.dialect", config.persistence.dialect)
            .applySetting("hibernate.connection.pool_size", config.persistence.pool_size + "")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("hibernate.show_sql", config.persistence.showSQL + "")
            .build();

    MetadataSources sources = new MetadataSources(registry);

    Timings.time("RegisterDBEntities", () ->
            new Reflections().getTypesAnnotatedWith(Entity.class).forEach(sources::addAnnotatedClass));

    try {
        Metadata metadata = sources.buildMetadata();
        sessionFactory = metadata.buildSessionFactory();
    } catch (Exception e) {
        StandardServiceRegistryBuilder.destroy(registry);
        e.printStackTrace();
    }
}
 

@Before
public void setup() {
	StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
		.applySetting( "hibernate.show_sql", "true" )
		.applySetting( "hibernate.format_sql", "true" )
		.applySetting( "hibernate.hbm2ddl.auto", "update" )
		.applySetting( "hibernate.dialect", "org.hibernate.dialect.H2Dialect" )
		.applySetting( "hibernate.connection.driver_class", "org.h2.Driver" )
		.applySetting( "hibernate.connection.url", "jdbc:h2:mem:testdbHibernate" )
		.applySetting( "hibernate.connection.username", "sa" )
		.applySetting( "hibernate.connection.password", "" )
		.applySetting( "hibernate.use_sql_comment", "true" )
		;
	Metadata metadata  = null;
	if(packageBase()== null){
	metadata= new MetadataSources( srb.build() ).addAnnotatedClass(getEntityClass()).buildMetadata();
	}else{
	    metadata= new MetadataSources( srb.build() )
	            .addAnnotatedClass(Item.class)
	            .addAnnotatedClass(Offer.class)

	            .addPackage(packageBase()).buildMetadata();
	}

       sf = metadata.buildSessionFactory();
   }
 

@BeforeClass
public static void setup() {
    // @formatter:off
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.show_sql", "true")
            .applySetting("hibernate.format_sql", "true")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("use_sql_comments", "true")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
            .applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate")
            .applySetting("hibernate.connection.username", "sa")
            .applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(EmailMessage.class).addAnnotatedClass(Email.class).buildMetadata();

    sf = metadata.buildSessionFactory();
    // @formatter:on
}
 

@BeforeClass
public static void setup() {
    // @formatter:off
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.show_sql", "true")
            .applySetting("hibernate.format_sql", "true")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("use_sql_comments", "true")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
            .applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate")
            .applySetting("hibernate.connection.username", "sa")
            .applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(Address.class).addAnnotatedClass(User.class).buildMetadata();

    sf = metadata.buildSessionFactory();
    // @formatter:on
}
 

@BeforeClass
public static void setup() {
    // @formatter:off
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.show_sql", "true")
            .applySetting("hibernate.format_sql", "true")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("use_sql_comments", "true")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
            .applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate")
            .applySetting("hibernate.connection.username", "sa")
            .applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(Address.class).addAnnotatedClass(User.class).buildMetadata();

    sf = metadata.buildSessionFactory();
    // @formatter:on
}
 

@BeforeClass
public static void setup() {
    // @formatter:off
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.show_sql", "true")
            .applySetting("hibernate.format_sql", "true")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("use_sql_comments", "true")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
            .applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate")
            .applySetting("hibernate.connection.username", "sa")
            .applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(EmailMessage.class).addAnnotatedClass(Email.class).buildMetadata();

    sf = metadata.buildSessionFactory();
    // @formatter:on
}
 

@BeforeClass
public static void setup() {
    // @formatter:off
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
            .applySetting("hibernate.show_sql", "true")
            .applySetting("hibernate.format_sql", "true")
            .applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("use_sql_comments", "true")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect")
            .applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate")
            .applySetting("hibernate.connection.username", "sa")
            .applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(EmailMessage.class).addAnnotatedClass(Email.class).buildMetadata();

    sf = metadata.buildSessionFactory();
    // @formatter:on
}
 

@Before
public void setup() {
	StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
		.applySetting( "hibernate.show_sql", "true" )
		.applySetting( "hibernate.format_sql", "true" )
		.applySetting( "hibernate.hbm2ddl.auto", "update" )
		.applySetting( "hibernate.dialect", "org.hibernate.dialect.H2Dialect" )
		.applySetting( "hibernate.connection.driver_class", "org.h2.Driver" )
		.applySetting( "hibernate.connection.url", "jdbc:h2:mem:testdbHibernate" )
		.applySetting( "hibernate.connection.username", "sa" )
		.applySetting( "hibernate.connection.password", "" )
		.applySetting( "hibernate.use_sql_comment", "true" )
		;
	Metadata metadata  = null;
	if(packageBase()== null){
	metadata= new MetadataSources( srb.build() ).addAnnotatedClass(getEntityClass()).buildMetadata();
	}else{
	    metadata= new MetadataSources( srb.build() )
	            .addAnnotatedClass(Item.class)
	            .addAnnotatedClass(Offer.class)

	            .addPackage(packageBase()).buildMetadata();
	}

       sf = metadata.buildSessionFactory();
   }
 

@Test
public void testEntityToDatabaseBindingMetadata() {
    Metadata metadata = MetadataExtractorIntegrator.INSTANCE.getMetadata();

    for ( PersistentClass persistentClass : metadata.getEntityBindings()) {
        Table table = persistentClass.getTable();
        LOGGER.info( "Entity: {} is mapped to table: {}",
                     persistentClass.getClassName(),
                     table.getName()
        );

        for(Iterator propertyIterator =
                persistentClass.getPropertyIterator(); propertyIterator.hasNext(); ) {
            Property property = (Property) propertyIterator.next();
            for(Iterator columnIterator =
                    property.getColumnIterator(); columnIterator.hasNext(); ) {
                Column column = (Column) columnIterator.next();
                LOGGER.info( "Property: {} is mapped on table column: {} of type: {}",
                             property.getName(),
                             column.getName(),
                             column.getSqlType()
                );
            }
        }
    }
}
 

/**
 * Method that actually creates the file.
 *
 * @param dbDialect to use
 */
private void generate(Dialect dialect) {

        StandardServiceRegistryBuilder ssrb = new StandardServiceRegistryBuilder();
        ssrb.applySetting("hibernate.dialect", dialect.getDialectClass());
        StandardServiceRegistry standardServiceRegistry = ssrb.build();

        MetadataSources metadataSources = new MetadataSources(standardServiceRegistry);
        for (Class clzz : jpaClasses) {
                metadataSources.addAnnotatedClass(clzz);
        }

        Metadata metadata = metadataSources.buildMetadata();

        SchemaExport export = new SchemaExport();

        export.setDelimiter(";");
        export.setOutputFile(dialect.name().toLowerCase() + ".ddl");
        //export.execute(true, false, false, true);
        export.execute(EnumSet.of(TargetType.SCRIPT), Action.BOTH, metadata);
}
 

private Block metadataBuilder() {
  return unit -> {
    MetadataBuilder mb = unit.get(MetadataBuilder.class);
    expect(mb.applyImplicitNamingStrategy(ImplicitNamingStrategyJpaCompliantImpl.INSTANCE))
        .andReturn(mb);
    expect(mb.applyScanEnvironment(unit.get(ScanEnvironment.class))).andReturn(mb);

    SessionFactoryBuilder sfb = unit.mock(SessionFactoryBuilder.class);
    unit.registerMock(SessionFactoryBuilder.class, sfb);

    Metadata md = unit.mock(Metadata.class);
    expect(md.getSessionFactoryBuilder()).andReturn(sfb);

    expect(mb.build()).andReturn(md);

    unit.registerMock(Metadata.class, md);
  };
}
 

public DBServiceImpl() {
    StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder();

    Map<String, Object> settings = new HashMap<>();
    settings.put(Environment.DIALECT, "org.hibernate.dialect.MySQL5Dialect");
    settings.put(Environment.DRIVER, "com.mysql.cj.jdbc.Driver");
    settings.put(Environment.URL, "jdbc:mysql://localhost:3306/db_example");
    settings.put(Environment.USER, "tully");
    settings.put(Environment.PASS, "tully");
    settings.put(Environment.HBM2DDL_AUTO, "create");
    settings.put(Environment.SHOW_SQL, true);
    settings.put(Environment.ENABLE_LAZY_LOAD_NO_TRANS, true);

    // c3p0 configuration
    settings.put(Environment.C3P0_MIN_SIZE, 5);         //Minimum size of pool
    settings.put(Environment.C3P0_MAX_SIZE, 20);        //Maximum size of pool
    settings.put(Environment.C3P0_ACQUIRE_INCREMENT, 1);//Number of connections acquired at a time when pool is exhausted
    settings.put(Environment.C3P0_TIMEOUT, 1800);       //Connection idle time

    registryBuilder.applySettings(settings);

    ServiceRegistry registry = registryBuilder.build();
    MetadataSources sources = new MetadataSources(registry)
            .addAnnotatedClass(PhoneDataSet.class)
            .addAnnotatedClass(UserDataSet.class)
            .addAnnotatedClass(AddressDataSet.class);


    Metadata metadata = sources.getMetadataBuilder().build();
    sessionFactory = metadata.getSessionFactoryBuilder().build();
}
 

@Override
public String getAlterTableToAddUniqueKeyCommand(UniqueKey uniqueKey, Metadata metadata)
{
	ConfigurationService config = metadata.getDatabase().getBuildingOptions().getServiceRegistry()
			.getService(ConfigurationService.class);
	if (config != null)
	{
		String value = config.getSetting("hibernate.hbm2ddl.auto", StandardConverters.STRING);
		if (!value.equalsIgnoreCase("update"))
		{
			// We should only check whether it is already present in an
			// update scenario, in all other scenarios, just return the
			// actual create statement.
			return org.hibernate.mapping.Index.buildSqlCreateIndexString(dialect, uniqueKey.getName(),
					uniqueKey.getTable(), uniqueKey.columnIterator(), uniqueKey.getColumnOrderMap(), true,
					metadata);
		}
	}
	// First check that this unique key is not already present, as this is a
	// lot faster than trying to create it and then fail.
	initIndices();
	UniqueIndex idx = indices.getIndex(uniqueKey);
	if (idx != null)
	{
		return null;
	}
	return org.hibernate.mapping.Index.buildSqlCreateIndexString(dialect, uniqueKey.getName(), uniqueKey.getTable(),
			uniqueKey.columnIterator(), uniqueKey.getColumnOrderMap(), true, metadata);
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
	for (Object o : args)
	{
		if (o instanceof Metadata)
		{
			addAuxiliaryDatabaseObjects(((Metadata) o).getDatabase());
			break;
		}
	}
	return method.invoke(delegate, args);
}
 

/**
 * Creating a session
 * @return org.hibernate.Session
 */
private Session createHibernateSession() {
    try {
        Map<String, String> settings = new HashMap<String, String>();
        settings.put("hibernate.connection.driver_class", "org.sqlite.JDBC");
        settings.put("hibernate.connection.url", "jdbc:sqlite:mysqlite.db");
        settings.put("hibernate.connection.username", "");
        settings.put("hibernate.connection.password", "");
        settings.put("hibernate.show_sql", "true");
        settings.put("hibernate.hbm2ddl.auto", "update");

        StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .applySettings(settings)
                .build();

        MetadataSources sources = new MetadataSources(registry)
                .addAnnotatedClass(Person.class);

        Metadata metadata = sources
                .getMetadataBuilder()
                .build();

        SessionFactory sessionFactory = metadata
                .getSessionFactoryBuilder()
                .build();

        session = sessionFactory.openSession();
    } catch (Exception e) {
        System.out.println(e.getMessage());
        return null;
    }
    System.out.println("Session created successfully.");
    return session;
}
 

protected Metadata buildMetadata() {
	MetadataSources metadataSources = new MetadataSources(serviceRegistry);
	for (Class<? extends AbstractEntity> each: LoaderUtils.findImplementations(AbstractEntity.class, AbstractEntity.class)) {
		metadataSources.addAnnotatedClass(each);
	}
	
	return metadataSources.getMetadataBuilder().applyPhysicalNamingStrategy(physicalNamingStrategy).build();
}
 

@Sessional
@Override
public void importData(Metadata metadata, File dataDir) {
	Session session = dao.getSession();
	List<Class<?>> entityTypes = getEntityTypes(sessionFactory);
	Collections.reverse(entityTypes);
	for (Class<?> entityType: entityTypes) {
		File[] dataFiles = dataDir.listFiles(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				return name.startsWith(entityType.getSimpleName() + "s.xml");
			}
			
		});
		for (File file: dataFiles) {
			try {
				logger.info("Importing from data file '" + file.getName() + "'...");
				session.beginTransaction();
				VersionedDocument dom = VersionedDocument.fromFile(file);
				
				for (Element element: dom.getRootElement().elements()) {
					element.detach();
					AbstractEntity entity = (AbstractEntity) new VersionedDocument(DocumentHelper.createDocument(element)).toBean();
					session.replicate(entity, ReplicationMode.EXCEPTION);
				}
				session.flush();
				session.clear();
				session.getTransaction().commit();
			} catch (Throwable e) {
				session.getTransaction().rollback();
				throw Throwables.propagate(e);
			}
		}
	}	
}
 

protected void validateData(Metadata metadata, File dataDir) {
	List<Class<?>> entityTypes = getEntityTypes(sessionFactory);
	Collections.reverse(entityTypes);
	for (Class<?> entityType: entityTypes) {
		File[] dataFiles = dataDir.listFiles(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				return name.startsWith(entityType.getSimpleName() + "s.xml");
			}
			
		});
		for (File file: dataFiles) {
			try {
				logger.info("Validating data file '" + file.getName() + "'...");
				VersionedDocument dom = VersionedDocument.fromFile(file);
				
				for (Element element: dom.getRootElement().elements()) {
					element.detach();
					AbstractEntity entity = (AbstractEntity) new VersionedDocument(DocumentHelper.createDocument(element)).toBean();
					validator.validate(entity);
				}
			} catch (Throwable e) {
				throw Throwables.propagate(e);
			}
		}
	}	
}
 

@Override
public void start() {
	if (Bootstrap.command.getArgs().length == 0) {
		logger.error("Missing password parameter. Usage: {} <new password>", Bootstrap.command.getScript());
		System.exit(1);
	}
	if (Bootstrap.isServerRunning(Bootstrap.installDir)) {
		logger.error("Please stop server before resetting admin password");
		System.exit(1);
	}

	checkDataVersion(false);

	Metadata metadata = buildMetadata();
	sessionFactory = metadata.getSessionFactoryBuilder().applyInterceptor(interceptor).build();
	
	User root = userManager.get(User.ROOT_ID);
	if (root == null) {
		logger.error("Server not set up yet");
		System.exit(1);
	}
	String password = Bootstrap.command.getArgs()[0];
	root.setPassword(passwordService.encryptPassword(password));
	userManager.save(root);
	
	// wait for a short period to have embedded db flushing data
	try {
		Thread.sleep(1000);
	} catch (InterruptedException e) {
		throw new RuntimeException(e);
	}
	sessionFactory.close();
	
	logger.info("Password of user '" + root.getName() + "' has been reset to: " + password);
	System.exit(0);
}
 

private void doRestore(Metadata metadata, File dataDir) {
	migrateData(dataDir);
	validateData(metadata, dataDir);

	String dbDataVersion = checkDataVersion(true);

	if (dbDataVersion != null) {
		logger.info("Cleaning database...");
		cleanDatabase(metadata);
	}
	
	logger.info("Creating tables...");
	createTables(metadata);
	
	logger.info("Importing data into database...");
	importData(metadata, dataDir);
	
	logger.info("Applying foreign key constraints...");
	try {
		applyConstraints(metadata);		
	} catch (Exception e) {
		logger.error("Failed to apply database constraints", e);
		logger.info("If above error is caused by foreign key constraint violations, you may fix it via your database sql tool, "
				+ "and then run {} to reapply database constraints", Command.getScript("apply_db_constraints"));
		System.exit(1);
	}
}
 

public DBServiceImpl() {
    StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder();

    Map<String, Object> settings = new HashMap<>();
    settings.put(Environment.DIALECT, "org.hibernate.dialect.MySQL5Dialect");
    settings.put(Environment.DRIVER, "com.mysql.cj.jdbc.Driver");
    settings.put(Environment.URL, "jdbc:mysql://localhost:3306/db_example");
    settings.put(Environment.USER, "tully");
    settings.put(Environment.PASS, "tully");
    settings.put(Environment.HBM2DDL_AUTO, "create");
    settings.put(Environment.SHOW_SQL, true);
    settings.put(Environment.ENABLE_LAZY_LOAD_NO_TRANS, true);

    // c3p0 configuration
    settings.put(Environment.C3P0_MIN_SIZE, 5);         //Minimum size of pool
    settings.put(Environment.C3P0_MAX_SIZE, 20);        //Maximum size of pool
    settings.put(Environment.C3P0_ACQUIRE_INCREMENT, 1);//Number of connections acquired at a time when pool is exhausted
    settings.put(Environment.C3P0_TIMEOUT, 1800);       //Connection idle time

    registryBuilder.applySettings(settings);

    ServiceRegistry registry = registryBuilder.build();
    MetadataSources sources = new MetadataSources(registry)
            .addAnnotatedClass(PhoneDataSet.class)
            .addAnnotatedClass(UserDataSet.class);


    Metadata metadata = sources.getMetadataBuilder().build();
    sessionFactory = metadata.getSessionFactoryBuilder().build();
}
 

@Override
	public SessionFactory buildFactory(String configFile) {
		try {
			//configuration = new Configuration().configure(configFile);
//			StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder()
//			.applySettings(configuration.getProperties());
//			SessionFactory factory2 = configuration.buildSessionFactory(builder.build());
			
			
			StandardServiceRegistry standardRegistry = new   StandardServiceRegistryBuilder()
				    .configure(configFile)
				    .build();

			MetadataSources metadataSources = new MetadataSources( standardRegistry );
			
			DomainScanner instanceFromProperties = getScanner(configFile);
			List<Class<? extends BaseDatabaseDomain>> scan = instanceFromProperties.scan(configFile);
			for(Class<? extends BaseDatabaseDomain> temp:scan){
				metadataSources.addAnnotatedClass(temp);
			}
			
		//	new HibernateUtil().scanDomain(metadataSources);
			
			Metadata metadata = metadataSources.getMetadataBuilder()
			    .applyImplicitNamingStrategy( ImplicitNamingStrategyJpaCompliantImpl.INSTANCE )
			    .build();

			SessionFactory factory2 = metadata.getSessionFactoryBuilder().build();
		
			
			return factory2;
			/*ProxoolConnectionProvider aConnectionProvider;*/
		} catch (Exception e) {
			steed.util.logging.LoggerFactory.getLogger().error("创建sessionFactory失败",e);
		}
		return null;
	}
 

private static SessionFactory createSessionFactory() {
    standardRegistry = new StandardServiceRegistryBuilder()
            .configure( "hibernate.cfg.xml" )
            .build();

    Metadata metadata = new MetadataSources( standardRegistry )
            .getMetadataBuilder()
            .build();

    sessionFactory = metadata.getSessionFactoryBuilder().build();

    return sessionFactory;
}
 

@BeforeClass
public static void setup() {
    StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder().applySetting("hibernate.show_sql", "true").applySetting("hibernate.format_sql", "true").applySetting("hibernate.hbm2ddl.auto", "update")
            .applySetting("hibernate.dialect", "org.hibernate.dialect.H2Dialect").applySetting("hibernate.connection.driver_class", "org.h2.Driver")
            .applySetting("hibernate.connection.url", "jdbc:h2:mem:testdbHibernate").applySetting("hibernate.connection.username", "sa").applySetting("hibernate.connection.password", "")
            .applySetting("hibernate.use_sql_comment", "true");
    Metadata metadata = null;
    log.info("+++ setup");
    metadata = new MetadataSources(srb.build()).addAnnotatedClass(Book.class).buildMetadata();

    sf = metadata.buildSessionFactory();
}
 

@Before
public void setup() {
	StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
		.applySetting( "hibernate.show_sql", "true" )
		.applySetting( "hibernate.format_sql", "true" )
		.applySetting( "hibernate.hbm2ddl.auto", "update" )
		.applySetting( "hibernate.dialect", "org.hibernate.dialect.H2Dialect" )
		.applySetting( "hibernate.connection.driver_class", "org.h2.Driver" )
		.applySetting( "hibernate.connection.url", "jdbc:h2:mem:testdbHibernate" )
		.applySetting( "hibernate.connection.username", "sa" )
		.applySetting( "hibernate.connection.password", "" )
		.applySetting( "hibernate.use_sql_comment", "true" )
		;
	Metadata metadata  = null;
	if(packageBase()== null){
	metadata= new MetadataSources( srb.build() ).addAnnotatedClass(getEntityClass()).buildMetadata();
	}else{
	    metadata= new MetadataSources( srb.build() )
	            .addAnnotatedClass(Item.class)
	            .addAnnotatedClass(Tank.class)
	            .addAnnotatedClass(Crew.class)
	            .addAnnotatedClass(TankBi.class)
	            .addAnnotatedClass(CrewBi.class)
	            .addPackage(packageBase()).buildMetadata();
	}

       sf = metadata.buildSessionFactory();
   }
 

@Before
public void setup() {
	StandardServiceRegistryBuilder srb = new StandardServiceRegistryBuilder()
		.applySetting( "hibernate.show_sql", "true" )
		.applySetting( "hibernate.format_sql", "true" )
		.applySetting( "hibernate.hbm2ddl.auto", "update" )
		.applySetting( "hibernate.dialect", "org.hibernate.dialect.H2Dialect" )
		.applySetting( "hibernate.connection.driver_class", "org.h2.Driver" )
		.applySetting( "hibernate.connection.url", "jdbc:h2:mem:testdbHibernate" )
		.applySetting( "hibernate.connection.username", "sa" )
		.applySetting( "hibernate.connection.password", "" )
		.applySetting( "hibernate.use_sql_comment", "true" )
		;
	Metadata metadata  = null;
	if(packageBase()== null){
	metadata= new MetadataSources( srb.build() ).addAnnotatedClass(getEntityClass()).buildMetadata();
	}else{
	    metadata= new MetadataSources( srb.build() )
	            .addAnnotatedClass(Product.class)
	            .addAnnotatedClass(ProductCustomer.class)
	            .addAnnotatedClass(ProductResource.class)
	            .addAnnotatedClass(Part.class)

	            .addPackage(packageBase()).buildMetadata();
	}

       sf = metadata.buildSessionFactory();
   }
 

/**
 * Method to build the hibernate session factory.
 * 
 * @return A Hibernate SessionFactory object.
 */
private static synchronized SessionFactory buildSessionFactory() {
	try {
		if (HibernateUtil.serviceRegistry == null) {
			HibernateUtil.serviceRegistry = new StandardServiceRegistryBuilder()
					.configure("au/com/ifti/models/hibernate/database.xml").build();
		}
		Metadata metadata = new MetadataSources(HibernateUtil.serviceRegistry).getMetadataBuilder().build();
		return metadata.getSessionFactoryBuilder().build();
	} catch (Throwable ex) {
		throw new ExceptionInInitializerError(ex);
	}
}
 

@Override
public void integrate( Metadata metadata, SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry )
{
    final EventListenerRegistry registry = serviceRegistry.getService( EventListenerRegistry.class );

    DeletedObjectPostDeleteEventListener listener = new DeletedObjectPostDeleteEventListener();
    registry.appendListeners( EventType.POST_DELETE, listener );
}
 

/**
 * Retrieve a hibernate session factory.
 *
 * @param hibernate5ConfigPath File path to hibernate config (i.e. hibernate-cfg.xml)
 * @param modelPackageName Name of package containing all models to be loaded by hibernate
 * @return Hibernate session factory.
 */
public static SessionFactory getSessionFactory(String hibernate5ConfigPath, String modelPackageName) {
    StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
            .configure(new File(hibernate5ConfigPath))
            .build();
    MetadataSources sources = new MetadataSources(standardRegistry);

    getAllEntities(modelPackageName).forEach(sources::addAnnotatedClass);

    Metadata metaData =  sources.getMetadataBuilder().build();
    return metaData.getSessionFactoryBuilder().build();
}
 

/**
 * @param accessType Cache access typr.
 * @param igniteInstanceName Name of the grid providing caches.
 * @return Session factory.
 */
private SessionFactory startHibernate(AccessType accessType, String igniteInstanceName) {
    StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder();

    builder.applySetting("hibernate.connection.url", CONNECTION_URL);

    for (Map.Entry<String, String> e : HibernateL2CacheSelfTest.hibernateProperties(igniteInstanceName, accessType.name()).entrySet())
        builder.applySetting(e.getKey(), e.getValue());

    builder.applySetting(USE_STRUCTURED_CACHE, "true");
    builder.applySetting(REGION_CACHE_PROPERTY + ENTITY1_NAME, "cache1");
    builder.applySetting(REGION_CACHE_PROPERTY + ENTITY2_NAME, "cache2");
    builder.applySetting(REGION_CACHE_PROPERTY + TIMESTAMP_CACHE, TIMESTAMP_CACHE);
    builder.applySetting(REGION_CACHE_PROPERTY + QUERY_CACHE, QUERY_CACHE);

    MetadataSources metadataSources = new MetadataSources(builder.build());

    metadataSources.addAnnotatedClass(Entity1.class);
    metadataSources.addAnnotatedClass(Entity2.class);
    metadataSources.addAnnotatedClass(Entity3.class);
    metadataSources.addAnnotatedClass(Entity4.class);

    Metadata metadata = metadataSources.buildMetadata();

    for (PersistentClass entityBinding : metadata.getEntityBindings()) {
        if (!entityBinding.isInherited())
            ((RootClass)entityBinding).setCacheConcurrencyStrategy(accessType.getExternalName());
    }

    return metadata.buildSessionFactory();
}
 

/**
 * Starts Hibernate.
 *
 * @param accessType Cache access type.
 * @param igniteInstanceName Ignite instance name.
 * @return Session factory.
 */
private SessionFactory startHibernate(org.hibernate.cache.spi.access.AccessType accessType, String igniteInstanceName) {
    StandardServiceRegistryBuilder builder = registryBuilder();

    for (Map.Entry<String, String> e : hibernateProperties(igniteInstanceName, accessType.name()).entrySet())
        builder.applySetting(e.getKey(), e.getValue());

    // Use the same cache for Entity and Entity2.
    builder.applySetting(REGION_CACHE_PROPERTY + ENTITY2_NAME, ENTITY_NAME);

    StandardServiceRegistry srvcRegistry = builder.build();

    MetadataSources metadataSources = new MetadataSources(srvcRegistry);

    for (Class entityClass : getAnnotatedClasses())
        metadataSources.addAnnotatedClass(entityClass);

    Metadata metadata = metadataSources.buildMetadata();

    for (PersistentClass entityBinding : metadata.getEntityBindings()) {
        if (!entityBinding.isInherited())
            ((RootClass)entityBinding).setCacheConcurrencyStrategy(accessType.getExternalName());
    }

    for (org.hibernate.mapping.Collection collectionBinding : metadata.getCollectionBindings())
        collectionBinding.setCacheConcurrencyStrategy(accessType.getExternalName() );

    return metadata.buildSessionFactory();
}
 

@Override
public void integrate(
        Metadata metadata,
        SessionFactoryImplementor sessionFactory,
        SessionFactoryServiceRegistry serviceRegistry) {

    final EventListenerRegistry eventListenerRegistry =
            serviceRegistry.getService( EventListenerRegistry.class );

    eventListenerRegistry.appendListeners(EventType.PERSIST, RootAwareInsertEventListener.INSTANCE);
    eventListenerRegistry.appendListeners(EventType.FLUSH_ENTITY, RootAwareUpdateAndDeleteEventListener.INSTANCE);
}