Question

We have a web application that uses C3P0 to pool our connections. We inject C3P0 as a data source into JdbcTemplate. You can see how we do this here:

<bean id="dataSourceDev" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${databasedev.driver}" />
    <property name="jdbcUrl" value="${databasedev.url}"/>
    <property name="user" value="${databasedev.username}"/>
    <property name="password" value="${databasedev.password}"/>

    <property name="initialPoolSize" value="5" />
    <property name="minPoolSize" value="5" />
    <property name="maxPoolSize" value="1000" />
    <property name="acquireIncrement" value="5" />
    <property name="maxStatements" value="1000" />
    <property name="maxStatementsPerConnection" value="1000"/>
    <property name="maxIdleTime" value="10800"/> <!-- 3 hours -->
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <constructor-arg>
         <ref bean="dataSourceDev" />
    </constructor-arg>
</bean>

<bean id="someDaoBean" class="com.gedi.platform.dao.SomeDaoClass">
    <property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>

<bean id="someResourceClass" class="com.gedi.platform.SomeResourceClass">
    <property name="someDao" ref="someDaoBean" />
</bean>

You can see that it’s a Java EE web application – it uses Jetty as its application server. My question is, how does Jetty instantiate our beans, and how will that affect connection pooling? If we have dozens of users using the web site at different times, will all of these users be placed in the same connection pool? Or is there only one connection pool per client, in which every HTTP client creates new instances of Resource, DAO, JdbcTemplate and C3P0?

Am I being clear? What I want to have is one connection pool for all HTTP requests, regardless of whether they come from web browsers originating in Boston or New Zealand. That way, the connection pool is exerting its maximum effects. However, if a new connection pool is instantiated for every HTTP client, then the pooling doesn’t end up being much of an improvement.

Edit

An important tidbit – We use the Jersey reference implementation of JAX-RS to produce a RESTful interface. So our servlet dispatches requests through Jersey which finds a suitable Resource class/method to handle them. I wonder whether Jersey re-instantiates these classes on every request, or keeps one instance of them at all times.

Answer 1

Neither Jersey nor Jetty are relevant here. Spring is important here. And in Spring every bean (like your dataSourceDev, jdbcTemplate and someDaoBean) are singletons. That means when Spring application context starts, it will creatly exactly one instance of each of them.

That means no matter what uses your DataSource (web request, background job, etc.), the same instance (thus the same connection pool) is used. You are right that if connection pool was created per each request, it would not have been much of an improvement. Actually it would be much, much slower.

But in your case (and this is how 99% of web applications work) all code requiring database access will compete and reuse the same connections (or wait if none available). BTW make sure your database can actually handle 1000 concurrent connections.