如何实现数据库并发？

Question

I have controller ,service and dao class singleton

Dao Class:

@Autowired
JdbcTemplate jdbcTemplate;

    @Override

    public String addUsers(UserDTO userDto) throws Exception {
        // TODO Auto-generated method stub
        System.out.println("JDBC TEMPLATE::"+jdbcTemplate);
        String query="Insert into users values('"+userDto.getUserName()+"')";
        System.out.println(query);
    jdbcTemplate.update(query);
    return "success";
    }

applicationContext.xml

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <property name="dataSource" ref="dataSource" />
    </bean>



 <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource"  >

       <property name="driverClassName" value="com.mysql.jdbc.Driver" />
       <property name="url" value="jdbc:mysql://localhost:3306/demo" />
        <property name="username" value="" /> 
       <property name="password" value="" />
    </bean>

In dao class I am using JdbcTemplate which is defined as singleton and dataSource bean is also singleton.

Now I have following doubt:

1)If my JdbcTemplate is singleton and dataSource bean is singleton will they cause any problem for concurrent request?

2)Is that the ideal way to make JdbcTemplate bean and injecting in to DAo?

3)Is request scope should only be there if any class hold instance variables?

Answer 1

In order be able to work concurrently against your DB, I would suggest to you to use connection pooling.

When multiple requests will "arrive" concurrently, for each of them the connections pool will assign a dedicated connection to work against the DB.

Of course, that is under your responsibility to make sure you're not accessing to the same "area" in your DB.

In MySql DB I know that there's a locking mechanism for such scenarios, but I would recommend making a deeper research.

There are 2 well-known connection pools:

1. Apache DBCP http://commons.apache.org/proper/commons-dbcp/
2. c3po http://www.mchange.com/projects/c3p0/

More detailed explanation:

Connection Pooling

It's a technique to allow multiple clients to make use of a cached set of shared and reusable connection objects providing access to a database.

Opening/Closing database connections is an expensive process and hence connection pools improve the performance of execution of commands on a database for which we maintain connection objects in the pool.

It facilitates reuse of the same connection object to serve a number of client requests.

Every time a client request is received, the pool is searched for an available connection object and it's highly likely that it gets a free connection object.

Otherwise, either the incoming requests are queued or a new connection object is created and added to the pool (depending on how many connections are already there in the pool and how many the particular implementation and configuration can support).

As soon as a request finishes using a connection object, the object is given back to the pool from where it's assigned to one of the queued requests (based on what scheduling algorithm the particular connection pool implementation follows for serving queued requests).