11

I am developing a hotel booking site. It is a J2EE 1.4 web application and using JSP and JDBC.

I have one method which is responsible to book the hotel rooms.

booking()

And from this method I am calling other four methods

bookRooms()
makePayment()
confirmUserByMail()
confirmUserBySMS()

I am aware that two users can try to book the same room at the same time and in my current system it is possible that two users might end up with the same room.

How should I handle the transaction to avoid this concurrency issue?

It might be very common scenario but I never handled this kind of scenario before, so please guide me.

BalusC
  • 1,082,665
  • 372
  • 3,610
  • 3,555
Bacteria
  • 8,406
  • 10
  • 50
  • 67
  • 1
    In the bookRooms method, you put a hold on the room(s). In the makePayment method, you either book the room(s) or release the room(s). This is like a database transaction where all of the changes complete, or you roll back the changes. – Gilbert Le Blanc Jun 12 '15 at 19:51
  • @Gilbert Le Blanc Could u plz elaborate it more. – Bacteria Jun 17 '15 at 21:48
  • If u can switch to spring - it has annotations based txns, better security, bean support ... see a sample at https://github.com/tgkprog/sel2inSmsSend read me has directions – tgkprog Jun 19 '15 at 04:30
  • 1
    *"J2EE using JSP and JDBC"*, in other words, you don't have EJB at hands? Do you *really* mean "J2EE" as in J2EE 1.2/1.3/1.4 from more than a decade old? Don't you actually use Java EE 5 or 6 or perhaps 7? Or did you think that Tomcat is a "J2EE" server? Which server exactly are you targeting/deploying to? Standard Java EE just offers EJBs for fully transparent automatic transaction management. See also a.o. http://stackoverflow.com/questions/18369356/when-is-it-necessary-or-convenient-to-use-springjsf2-or-ejb3jsf2-or-all-of-the/ for some related background information. – BalusC Jun 19 '15 at 14:45
  • @BalusC Basically we have an old application which was developed in J2EE 1.4 and it runs in Tomcat web server, this new part is enhancement of that main application. And application owner is not interested to upgrade anything. So I cannot use EjB /spring etc, although they offer fully transparent automatic transaction management.I understand your point but my hands are tied. I have to strict on the Jsp and JDBC. – Bacteria Jun 19 '15 at 16:24

9 Answers9

1

Easiest way is add locks in your code or use locks provided by database.You can use volatile or other concurrent tools in java.

If the amount of user is not too large,you can use message queue.Visit from user is encapsulated into object, put the object into the queue and wait for process by threads. It's gonna cost a lot of memory space if there are too many users.

I've heard another way called Optimistic lock,but I've never used it in practice,you can try.

ps If the amount of user is very large,perhaps you should use cache like Memcached.Manipulate datas in the memory and map these changes to database later

Ryan_Wang
  • 11
  • 1
1

Your pseudocode implies that by the time this method is called the hotel details / payment details have already been captured by the user. There are typically two ways to go about designing such systems. This would require a decision whether to actually lock a room when a user has selected a room and is taking time while filling other details like payments etc. This is similar to Pessimistic lock in programmic languages / databases. You would need to show your user on the UI that he has to complete the transaction in x time else he would have to start again. In the application/database you have to make sure the selected rooms are locked and cannot be selected by anyone else for that particular time interval. In your data model (schema) you can add a flag to indicate if the rooms are selected, so that when another user searches for rooms this particular room(s) do not show up and are not selectable. Another approach is to use Optimistic locking where at the time of final logical transaction commit ( when you booking() method is called) - you check for the availability of the room and if already booked by another logical transaction - take the user to the beginning of the booking process. This is usually not like by customers of sites like hotel booking and the first method is generally a good user experience.

Shailendra
  • 8,874
  • 2
  • 28
  • 37
1

Assume underlying database is Oracle 11g

booking(){
start Trasaction;
...

bookRooms()
{
  1. Maintain one Room_Bookings table with Room number and Timing slot as unique key.
  2. when user selects a room and proceed further, insert oom details in Room_Bookings table.
  3. If multiple user selects same room at the same time; Oracle will throw exception of

unique constraint violation exception.

4.When you receive Exception in Java code, throw RuntimeException

  1. for successful user, call rest other methods ( i.e. makePayment().. )

    (Editing point # 6 as per below discussion)

  2. When this successful user checked-out Or timing slot ends-- i.e. period for which room booked; remove room details entry from 'Room_Bookings' table so that it will be available for further bookings.

    }
    if received RuntimeException rollback transaction with customized message; else commit transaction; end transaction. }

Also, for technology perspective, you may use EJB container managed transaction with 2 - phase commit protocol; 1 for database resource , 1 for EJB. And your method may looks like below--

@TransactionAttribute(TransactionAttributeType.REQUIRED)

booking(){

.. ..

}

Ashish Patil
  • 4,428
  • 1
  • 15
  • 36
  • If I **Maintain one Room_Bookings table with Room number as unique key**, will it work? Same room can be booked for different period, so I don't thick only 'Room number as unique key' will work at all. – Bacteria Jun 18 '15 at 16:01
  • in that case, my point #6 won't work. So it should also have Booking slot / Timing as unique member. So overall room number + timing slot would would act as composite unique key. Timing field may have precision upto milliseconds to maintain automicity of transaction. – Ashish Patil Jun 19 '15 at 04:19
1

Use @TransactionAttribute for declarative transaction management in your service.

Keep in mind, that user confirmations by email and SMS are not transactional by nature and should be only performed after successful completion of the transaction.

So, you may create a controller which will call a transactional BookingService and non-transactional NotificationService:

@WebServlet("/book")
public class BookingServlet extends HttpServlet {

    @Resource
    NotificationService notificationService;
    @Resource
    BookingService bookingService;

    @Override
    public void doPost(...) {
        bookingService.booking(...); 
        notificationService.confirmUserByMail(...);
        notificationService.confirmUserBySMS(...);
    }
}

@Stateless
public class BookingServiceImpl implements BookingService {

    @Resource
    private DataSource dataSource;

    @TransactionAttribute(REQUIRED)
    @Override
    public void booking(...) {
        bookRooms(...); 
        makePayment(...);
    }

    private void bookRooms(...) {
        //use dataSource here
    }

    private void makePayment(...) {
        //use dataSource here
    }
}

@Stateless
public class NotificationServiceImpl implements NotificationService {

    @Override
    public void notifyUserByMail(...) { 
       ...
    }
    @Override
    public void notifyUserBySMS(...) { 
       ...
    }
}
Konstantin Pavlov
  • 956
  • 1
  • 10
  • 24
1

i am assuming you are using plain JDBC code and no ORM tool is involved here .you can put

conn.setAutoCommit(false);

so before committing transaction you can use locking mechanism as mention above not sure if locking is avail with J2EE 1.4 or not , if not please create queue for each hotel room or group of hotel rooms. once committed redirect all waiting request to other queue.

Bhupi
  • 387
  • 3
  • 16
1

I would not use a lock on the database, instead I would insert a UNIQUE constraint on the database table of reservations for (ROOM, DAY) if it is possible.

Then I would use transaction in my code like this

Connection con = somehowGetYourConnection();

try {
    con.setAutoCommit(false);

    //query1
    //...

    //some more stuff
    //...

    //query 2, inserting into the table of the reservation
    //...

    con.commit();

}
catch(SQLException e)
{
    //log somehow
    //...

    con.rollback();

    //you will need somehow to tell your user that the reservation failed
    //...

}

Now when you are going to make the insert into the table of reservations and commit it, if there is already another reservation for the same day and the same room a SQLException is going to be launched and the whole reservation transaction is going to be rollbacked.

In this way you are sure at the end of the day that you won't have double reservations for the same room.

alessiop86
  • 1,285
  • 2
  • 19
  • 38
0

I'm sure there are high level ways to do this but I would just use a simple boolean isFull and have it become true when a booking is made.

boolean roomIsFull = false;
if (roomIsFull)
{
    //Sir this room is already booked. Please Pick Another.
}
else
{
    //Do your stuff.
    roomIsFull = true;
}

Then you can still use your current code.

To ensure that a room is only booked once one can use the synchronized keyword to ensure that the method can be used once( not the best since two different rooms can't be booked at once)

Other option is to use volatile keyword so if a room object is being accessed other methods can see that.

Source: http://www.vogella.com/tutorials/JavaConcurrency/article.html#concurrency_overview

Dasman
  • 317
  • 4
  • 19
  • I don't think this way I can prevent concurrency issue. – Bacteria Jun 12 '15 at 23:16
  • To fix that I think you should use either synchronized or volatile keywords in Java. Good article here: http://www.vogella.com/tutorials/JavaConcurrency/article.html#concurrency_overview – Dasman Jun 13 '15 at 13:37
  • Why was this downvoted? It has most of the elements of the 4 answers. In fact all 4 answers try their best to solve the problem. Either all 4 should be downvoted or none at all. – Dasman Jun 15 '15 at 14:22
  • Java level concurrency controls are inappropriate in this instance because an enterprise application is often distributed across two or more servers. – Steve C Jun 16 '15 at 02:49
0

In that case you can use Synchronized Method like this

public synchronized void  booking()
{
    Start Transaction;
}

Here we achieved a solution because Synchronized has it own nature where it allows only one user at a time ,after that user finish the job it will allow next to perform

Arun Prasath
  • 100
  • 6
0

To solve your concurrency use case you need to use the user's session to store or acquire the connection from the JDBC engine.

  • EJB Session Container solution can be an option (see solution above) that is more complex as you use the EJB tier of your server (if exists) ...

  • In case you want a more simple solution you can use the HTTPSession object to store your connection. The challenge here is to set / limit your JDBC connection pool according to your deployment scenario / use case and test it. This is possible by a set of configuration parameters for the JDBC engine or during initialization.

There is a relevant section in the web.xml configuration for referring the JDBC Connection as an application resource. I would use a Servlet Context Listener object to init the connection with the relevant configuration and HTTP Session Listener object to handle session related connection management and logging.

Gabor Jakab
  • 236
  • 2
  • 6