发生错误后未释放到池的连接Spring Boot 2.1.4+JDBI+HikariCP+PostgreSQL

Question

我有一个包含在API中的Spring Boot应用程序。它公开了一个endpoint/api/persons/:id。在引擎盖下，Spring靴附带了Hibernate和Hikaricp。我的数据库是PostgreSQL 10。该应用程序是在Kotlin中构建的。

当API同时接收请求时，我发现了一个问题，似乎应用程序需要2个活动连接来执行endpoint调用的操作findPersonbyId()。

我面临的问题是，在那之后，HikariCP仍然说池上有5个活动连接。如果我查看PostgreSQL统计信息，所有连接都是空闲的。

另外，如果我同时只发送4个请求，所有的事情都是例外的，它以5个活动连接和3个挂起开始，所有的请求都返回例外的结果。

我尝试将池更改为Tomcat JDBC,但结果完全相同。

@RestController
@RequestMapping("/api/person")
class PersonResource(private val personService: PersonService,
                     private val personUpdateService: PersonUpdateService,
                     private val identityManagementService: IdentityWithManagementService) : PersonApi {

    @GetMapping("/{id}")
    override fun findPersonById(@PathVariable id: String): PersonDto? {
        return personService.findFull(id)
    }

}

@Service
class PersonService(private val documentsService: DocumentService,
                    private val postalAddressService: PostalAddressService) : EntityService<Person>(repository) {

    fun findFull(personId: String): PersonDto? {
        return find(personId)?.let { person ->
            PersonDto(
                    person,
                    postalAddressService.findByPersonId(personId).map { it.toDto() },
                    documentsService.findByPersonId(personId).map { it.toDto() }
            )
        }
    }
}

PersonPostgresRepository:

@Repository
class PersonPostgresRepository : AbstractPostgresRepository(), PersonEntityRepository {

    override fun find(id: String): Person? {
        return withHandle<Person?, Exception> {
            it.createQuery(
                    "select * " +
                            "from identiti_person " +
                            "where id = :id")
                    .bind("id", id)
                    .map(PersonRowMapper())
                    .firstOrNull()
        }
    }
}

AbstractPostgresRepository:

abstract class AbstractPostgresRepository {

    @Autowired
    private lateinit var handleManager: JdbiHandleManager

    @Autowired
    private lateinit var jdbi: Jdbi

    protected fun <R, X : Exception> withHandle(callback: (handle: Handle) -> R): R {
        val handle = handleManager.handle
        return if (handle.isPresent) {
            callback.invoke(handle.get())
        } else {
            jdbi.withHandle(HandleCallback<R, X> {
                callback.invoke(it)
            })
        }
    }
}

和jdbihandlemanager,以备您询问：

@Component
@Scope("singleton")
class JdbiHandleManager(private val jdbi: Jdbi) {

    private val currentHandle = ThreadLocal<Handle>()

    val handle: Optional<Handle>
        get() = Optional.ofNullable(currentHandle.get())

    internal fun openHandle(): Handle {
        val handle = jdbi.open()
        currentHandle.set(handle)
        return handle
    }

    internal fun closeHandle() {
        val handle = currentHandle.get()
        currentHandle.remove()
        handle?.close()
    }
}

@Configuration
open class JdbiConfig {

    @Bean
    open fun jdbi(dataSource: DataSource): Jdbi {
        // JDBI wants to control the Connection wrap the datasource in a proxy
        // That is aware of the Spring managed transaction
        val dataSourceProxy = TransactionAwareDataSourceProxy(dataSource)
        val jdbi = Jdbi.create(dataSourceProxy)
        jdbi.installPlugins()

        return jdbi
    }
}

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    override fun transactionAttributeSource(): TransactionAttributeSource {
        /*
            Defines an annotation transaction source (the default) which consider that @Service components
            are transactional by default (making the use of @Transactional optional on those classes).
            Note that the class has to be processed by a TransactionInterceptor for that source to be applied,
            this is the responsibility of the auto proxy creator below.
         */
        return object : AnnotationTransactionAttributeSource() {
            override fun findTransactionAttribute(clazz: Class<*>): TransactionAttribute? {
                return if (clazz.getAnnotation(Service::class.java) != null && clazz.getAnnotation(Transactional::class.java) == null) {
                    DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRED)
                } else super.findTransactionAttribute(clazz)
            }
        }
}

Answer 1

我没有运行您的代码，但我非常确信潜在的问题是：

您的jdbihandleManager是多余的，并导致问题（打开了2个连接）。为什么？因为TransactionAwareDataSourceProxy已经处理连接的打开和关闭。当Spring遇到一个“事务性”的方法调用（通过注释或方面）时，一个连接被打开并绑定到当前线程。

这意味着只使用jdbi.withHandle(...)是完全足够的，因为打开连接的下一个调用返回活动的事务连接，并且对close的调用是代理的，因为spring会自行关闭连接。

这里我的建议是删除您的自定义代码，并完全依赖TransactionAwareDataSourceProxy的正确操作