Java Hibernate 5多租户数据库appraoch：面临关闭hikari连接池的问题

在我的应用程序中，有4个数据库服务器，每个数据库服务器有9个模式，因此我使用hibernate Multitenance进行会话及其工作， 但我面临一个问题，它不是关闭hikari连接池对象 例如，在我的开发代码中，每当代码自动构建其创建新连接池（如HikariPool-5-Start completed）时，应用程序停止或重新启动时，它不会关闭最后4个hikari池

public class DataSourceMultiTenantConnectionProviderImpl extends AbstractDataSourceBasedMultiTenantConnectionProviderImpl {

    private static final long serialVersionUID = 1L;

    @Autowired
    private Map<String, DataSource> dataSourcesNSAP;

    @Override
    protected DataSource selectAnyDataSource() {
        return this.dataSourcesNSAP.values().iterator().next();
    }

    @Override
    protected DataSource selectDataSource(String tenantIdentifier) {
        return this.dataSourcesNSAP.get(tenantIdentifier);
    }
    
    @Override
    public void releaseAnyConnection(Connection connection) throws SQLException {
        System.out.println("-----------releaseAnyConnection methode called-----------");
        connection.close();
    }
    
    @Override
    public void releaseConnection(String tenantIdentifier, Connection connection) throws SQLException {
        System.out.println("-----------releaseConnection methode called-----------");
        releaseAnyConnection(this.dataSourcesNSAP.get(tenantIdentifier).getConnection());
        
    }
    
     @SuppressWarnings("rawtypes")
        @Override
        public boolean isUnwrappableAs(Class unwrapType) {
         return ConnectionProvider.class.equals( unwrapType ) ||
                    MultiTenantConnectionProvider.class.equals( unwrapType ) ||
                    AbstractMultiTenantConnectionProvider.class.isAssignableFrom( unwrapType );
        }
        @Override
        public <T> T unwrap(Class<T> unwrapType) {
             if ( isUnwrappableAs( unwrapType ) ) {
                    return (T) this;
                }
                throw new UnknownUnwrapTypeException( unwrapType );
        }
        @Override
        public boolean supportsAggressiveRelease() {
            return true;
        }
        
        
        
} 

@Configuration
@EnableTransactionManagement
public class MultiTenantHibernateConfiguration {

    @Autowired
    private DataBaseProperty dbproperty;
@Bean(name = "dataSourcesNSAP")
    public Map<String, DataSource> getAllDataSources() {
        Map<String, DataSource> result = new HashMap<>();
        Map<String, DbProperty> dpMap = dbproperty.getDb();
        DataSource ds ;
        DataSourceBuilder<?> db_builder ;
        for (Map.Entry<String, DbProperty> entry : dpMap.entrySet()) {
            db_builder = DataSourceBuilder
                        .create().driverClassName(dbproperty.getDriver())
                        .username(entry.getValue().getUsername())
                        .password(entry.getValue().getPassword())
                        .url(entry.getValue().getUrl());
            ds = db_builder.build();
            result.put(entry.getKey(), ds);
        }

        return result;
    }   
    

    @Bean
    public MultiTenantConnectionProvider multiTenantConnectionProvider() {

        return new DataSourceMultiTenantConnectionProviderImpl();
    }

    @Bean
    public CurrentTenantIdentifierResolver currentTenantIdentifierResolver() {
        return new TenantDBIdentifierResolverImpl();
    }

    @Bean
    public PhysicalNamingStrategy getPhysicalNamingRegistry() {
        return new CustomPhysicalNamingStrategy();
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setMultiTenantConnectionProvider(multiTenantConnectionProvider());
        sessionFactory.setCurrentTenantIdentifierResolver(currentTenantIdentifierResolver());
        sessionFactory.setHibernateProperties(hibernateProperties());
        sessionFactory.setPackagesToScan(new String[] { "nic.in.nsap.model" });
        //sessionFactory.setPhysicalNamingStrategy(getPhysicalNamingRegistry());
        return sessionFactory;
    }

    private final Properties hibernateProperties() {
        Properties hibernateProperties = new Properties();
        hibernateProperties.setProperty("hibernate.multiTenancy", "DATABASE");
        hibernateProperties.setProperty("hibernate.hbm2ddl.auto", "none");
        hibernateProperties.setProperty("hibernate.show_sql", "true");
        hibernateProperties.setProperty("hibernate.format_sql", "true");
        hibernateProperties.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
        hibernateProperties.setProperty("hibernate.current_session_context_class", "org.springframework.orm.hibernate5.SpringSessionContext");
        return hibernateProperties;
    }

    @Bean
    public PlatformTransactionManager hibernateTransactionManager() {
        HibernateTransactionManager transactionManager = new HibernateTransactionManager();
        transactionManager.setSessionFactory(sessionFactory().getObject());
        return transactionManager;
    }
}

公共类DataSourceMultiTenantConnectionProviderImpl扩展了AbstractDataSourceBasedMultiTenantConnectionProviderImpl{
私有静态最终长serialVersionUID=1L；
@自动连线
私有地图数据源NSAP；
@凌驾
受保护的数据源selectAnyDataSource（）{
返回此.datasourcensap.values（）.iterator（）.next（）；
}
@凌驾
受保护的数据源selectDataSource（字符串租户标识符）{
返回此.datasourcensap.get（租户标识符）；
}
@凌驾
public void releaseAnyConnection（连接连接）引发SQLException{
System.out.println（“--------------releaseanyConnectionmethode调用-----------------”；
connection.close（）；
}
@凌驾
public void releaseConnection（字符串租户标识符，连接连接）引发SQLException{
System.out.println（“--------------调用的releaseConnection方法------------”；
releaseAnyConnection（this.datasourcensap.get（tenantIdentifier.getConnection（））；
}
@抑制警告（“原始类型”）
@凌驾
公共布尔IsUnwrapbleas（类unwrapType）{
返回ConnectionProvider.class.equals（unwrapType）||
MultiTenantConnectionProvider.class.equals（unwrapType）||
AbstractMultiTenantConnectionProvider.class.isAssignableFrom（unwrapType）；
}
@凌驾
公共展开（类展开类型）{
if（isUnwrappableAs（UnwrappType））{
返回（T）这个；
}
抛出新的未知UnwrapTypeException（unwrapType）；
}
@凌驾
公共布尔值supportsAggressiveRelease（）{
返回true；
}
} 
@配置
@启用事务管理
公共类多租户配置{
@自动连线
私有数据库属性dbproperty；
@Bean（name=“datasourcensap”）
公共地图getAllDataSources（）{
映射结果=新的HashMap（）；
Map dpMap=dbproperty.getDb（）；
数据源ds；
数据源生成器db_生成器；
对于（Map.Entry:dpMap.entrySet（））{
db_builder=数据源生成器
.create（）.driverClassName（dbproperty.getDriver（））
.username（entry.getValue（）.getUsername（））
.password（entry.getValue（）.getPassword（））
.url（entry.getValue（）.getUrl（））；
ds=db_builder.build（）；
result.put（entry.getKey（），ds）；
}
返回结果；
}   
@豆子
公共多租户连接提供程序多租户连接提供程序（）{
返回新数据源MultitenantConnectionProviderImpl（）；
}
@豆子
public CurrentTenantIdentifierResolver CurrentTenantIdentifierResolver（）{
返回新的TenantDBIdentifierResolverImpl（）；
}
@豆子
公共物理命名策略getPhysicalNamingRegistry（）{
返回新的CustomPhysicalNamingStrategy（）；
}
@豆子
公共LocalSessionFactoryBean sessionFactory（）{
LocalSessionFactoryBean sessionFactory=新的LocalSessionFactoryBean（）；
setMultiTenantConnectionProvider（multiTenantConnectionProvider（））；
setCurrentTenantIdentifierResolver（currentTenantIdentifierResolver（））；
setHibernateProperties（hibernateProperties（））；
setPackagesToScan（新字符串[]{“nic.in.nsap.model”}）；
//setPhysicalNamingStrategy（getPhysicalNamingRegistry（））；
返回工厂；
}
私有最终属性hibernateProperties（）{
Properties hibernateProperties=新属性（）；
setProperty（“hibernate.multitenance”，“DATABASE”）；
setProperties（“hibernate.hbm2ddl.auto”、“none”）；
setProperties（“hibernate.show_sql”，“true”）；
setProperty（“hibernate.format_sql”，“true”）；
setProperties（“hibernate.dialogue”、“org.hibernate.dialogue.postgresqldialdialogue”）；
setProperties（“hibernate.current_session_context_class”，“org.springframework.orm.hibernate5.SpringSessionContext”）；
归还财产；
}
@豆子
公共平台事务管理器hibernateTransactionManager（）{
HibernateTransactionManager transactionManager=新的HibernateTransactionManager（）；
transactionManager.setSessionFactory（sessionFactory（）.getObject（））；
返回事务管理器；
}
}

//最后我得到了session对象，如 sessionfactory.withOptions（）.tenantIdentifier（“USER1”）.openSession（）

---

请有人解决我的问题，并向我建议是否有其他更好的方法来满足我的要求

请有人查看我的问题您说最后5个连接没有关闭，您在哪里访问DAO，向我们展示您是否为每个构建使用带/不带EntityManager local的JPARepository，IDE将重新启动并回收您的连接，请详细说明您的问题