hibernate session initialization very slow in production with many entities definition - performance

Question

I have a Spring Boot app with 296 persisted objects annotated by #Entity using Hibernate framework for persitence implementation. In developpement using eclipse on a Core i7-6700 (4x 3.4Ghz - 4Ghz Turbo, SSD), the SessionFactory is initialized in almost 6 seconds.
My production server is a virtualized windows server on a Xeon E5-2620v2 (6x 2,1GHz - 2.6Ghz, HDD (+ SSD cache)). I have no control about allocated resources by virtualization.
When I run my app on this server, it take about 25 seconds to instantiate the SessionFactory.
No speed problem when app is fully initialized: the execution speed of all webservices/databases queries is normal.
Naively I think hibernate create SQL Queries of basical CRUD operations when SessionFactory is instantiated.
I tried adding #DynamicInsert and #DynamicUpdate on all #Entity classes but it did not bring to me a better startup time and SessionFactory instantiation time is the same.
I use the following spring / hibernate / others pertinent libraries versions: (from my pom.xml)
<hibernate.version>5.4.5.Final</hibernate.version>
<spring.version>5.1.9.RELEASE</spring.version>
<springSecurity.version>5.1.6.RELEASE</springSecurity.version>
<springBoot.version>2.1.8.RELEASE</springBoot.version>
<mssql-jdbc.version>7.4.1.jre11</mssql-jdbc.version>
<apache-commons-dbcp2.version>2.5.0</apache-commons-dbcp2.version>
<eh-cache.version>2.10.6</eh-cache.version>
<javaassist.version>3.25.0-GA</javaassist.version>
This is my hibernate SessionFactory configuration (part of application.mssql.properties file):
hibernate.dialect = org.hibernate.dialect.SQLServer2012Dialect
# useless cause I use GenerationType.IDENTITY
# for primary key (id) of all entities
hibernate.jdbc.batch_size = 20
hibernate.cache.use_query_cache = false
hibernate.cache.use_second_level_cache = true
hibernate.cache.provider_class = org.hibernate.cache.EhCacheProvider
hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory
hibernate.connection.driver_class = com.microsoft.sqlserver.jdbc.SQLServerDriver
hibernate.enable_lazy_load_no_trans = true
hibernate.cache.use_reference_entries = true
hibernate.connection.url = jdbc:sqlserver://localhost:1433;databaseName=master;user=usr;password=pwd;
hibernate.connection.username = usr
hibernate.connection.password = pwd
# Multitenancy configuration
hibernate.multiTenancy = SCHEMA
hibernate.multi_tenant_connection_provider = MultiTenantConnectionProvider
hibernate.tenant_identifier_resolver = CurrentTenantIdentifierResolver
That is how I define my hibernate SessionFactory (I know that I can use standard JPA session factory but this app was made like that and I don't want to change that, moreover, I have simplified class content for more readeability):
#SpringBootApplication()
#EnableAutoConfiguration(
excludeName = {
"org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration"
}
)
#ComponentScan(
basePackages = {
// my packages list
}
)
#Configuration
#PropertySource({ "classpath:application.mssql.properties" })
#EnableCaching
#EnableTransactionManagement
public class ApplicationConfiguration {
#Autowired
private Environment env;
/**
* #return SQL-Server pooled connection using apache dbcp2
*/
#Primary
#Bean
public DataSource dataSource() {
BasicDataSource ds = new BasicDataSource();
ds.setUrl(this.env.get("hibernate.connection.url"));
ds.setUsername(this.env.get("hibernate.connection.username"));
ds.setPassword(this.env.get("hibernate.connection.password"));
ds.setDriverClassName(this.env.get("hibernate.connection.driver_class"));
ds.setMaxIdle(10);
ds.setMaxOpenPreparedStatements(100);
return ds;
}
/**
* #return main sessionFactory (the mostly used sessionFactory in app)
*/
#Primary
#Autowired
#Bean
public LocalSessionFactoryBean sessionFactory(#Qualifier("dataSource") DataSource dataSource,
MultiTenantConnectionProvider multiTenantConnectionProviderImpl,
CurrentTenantIdentifierResolver currentTenantIdentifierResolverImpl) {
LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setPackagesToScan("my.root.pojo.package");
// get hibernate properties from this.env (application.mssql.properties file)
Properties hibernateProperties = getHibernateProperties();
hibernateProperties.put(AvailableSettings.MULTI_TENANT, "SCHEMA");
hibernateProperties.put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, multiTenantConnectionProviderImpl);
hibernateProperties.put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, currentTenantIdentifierResolverImpl);
sessionFactory.setHibernateProperties(hibernateProperties);
sessionFactory.setDataSource(dataSource);
return sessionFactory;
// FROM THIS POINT --->
}
/**
* #return transactionManager for main sessionFactory
*/
#Bean
#Autowired
#Primary
public HibernateTransactionManager transactionManager(#Qualifier("sessionFactory") SessionFactory sessionFactory) {
// ----> TO THIS POINT took 6 sec in development, 25 sec in production
HibernateTransactionManager txManager = new HibernateTransactionManager();
txManager.setNestedTransactionAllowed(true);
txManager.setSessionFactory(sessionFactory);
return txManager;
}
// some other stuff:
// - sessionFactory on another databases,
// - getHibernateProperties() implementation,
// - initServer() method annotated by #Bean(initMethod = "init")
// - etc ...
}
Is it normal to have this speed difference?
Did I forgotten something in hibernate configuration ?
Any help will be welcomed.