can i use flush() instead of commit() when i want to use find() method twice?

Question

I want to know whether a username is already in use, and if that's not the case, whether an emailadress is already in use. I don't want to begin and commit a new transaction for each entitymanager find method because I think using just one transaction for multiple operations is more efficient then using several. Can I replace commit() with flush() in my method?

    public void createUser(User_ newUser){
            UserDao userDao = new UserDao();
    Alert alert;
    EntityTransaction transaction = entityManager.getTransaction();

        try{
            transaction.begin();
            userDao.find("userName",newUser.getUserName());
            transaction.commit();
            alert = new Alert(Alert.AlertType.ERROR,"Username already in use", ButtonType.OK);
            alert.showAndWait();
            if (alert.getResult() == ButtonType.OK)alert.close();
        }        
        catch(NoResultException e){
            try{
                transaction.begin();
                userDao.find("emailAdress",newUser.getEmailAdress());
                transaction.commit();
                alert = new Alert(Alert.AlertType.ERROR,"E-mail adress already in use", ButtonType.OK);
                alert.showAndWait();
                if (alert.getResult() == ButtonType.OK) alert.close();             
                }
            catch(NoResultException x){
                    transaction.begin();
                    userDao.save(newUser);
                    transaction.commit();
                }
        }
        catch(RuntimeException e){
            transaction.rollback();    
        }
        finally{entityManager.close();}
} 

thank you.

Answer 1

There are three issues with your code:

1. Why would you even wrap query methods in separate transactions? First of all, executing queries does not require one. Secondly, you are right in trying to wrap both your query methods with a single transaction, but for the wrong reason. This has little to do with performance and everything to do with isolation. A transaction is required here simply to prevent another call to createUser from creating a user with the same username in between those two queries (obviously, for the same reason, persisting the user should be part of the same transaction).

2. You should avoid using exceptions to handle normal states of your application. Not only would that be the proper way of using exceptions, but you'll also run into far fewer issues as far as transaction state is concerned. Judging by the fact that you're expecting userDao.find to throw NoResultException, I am assuming it is using query.getSingleResult() internally. getSingleResult should only be used when you expect a query to always have a result. You should use getResultList() instead, together with and emptiness check or, better still, query for the count of User entities with the given username

3. Your method is mixing business logic and presentation concerns. Saving data to the db and presenting alerts should most certainly not be done in a single method. If you absolutely need to communicate the error to the user in the same method that persists data, make sure you do it after the transaction is commited, to prevent it from timing out.

Answer 2

There is no way you can rollback your transaction once the commit() succeeds. Flushing is the process of synchronizing the underlying persistent store with persistable state held in memory.it will update or insert into your tables in the running transaction, but it may not commit those changes.

flush() will synchronize your database with the current state of object/objects held in the memory but it does not commit the transaction. So, if you get any exception after flush() is called, then the transaction will be rolled back. You can synchronize your database with small chunks of data using flush() instead of committing a large data at once using commit() and face the risk of getting an Out Of Memory Exception.

commit() will make data stored in the database permanent. There is no way you can rollback your transaction once the commit() succeeds.

Now its upto your business logic which one to use