Question

I’m using Spring/Hibernate combination for my project, with standard CRUD operations.

I wonder, is it reasonable to validate object existence before its deletion or update? If it is, where is the most appropriate place to do – service or dao layer?

EDIT:
Sorry, I didn’t make the point at first when I asked this question. The only motive for existence checking is to throw friendly exception to client of service (no DAO specific).

Problem is that I ‘have to do’ existence checking because my service method below is transactional, and besides that, I’m using HibernateTemplate and DaoSupport helper classes for session manipulation in DAO objects.

According to mentioned, Hibernate exception (in case of deleting non-existing instance for example) is thrown at commit time, which is out of my reach, because (I suppose) commit is executed by PlatformTransactionManager in proxy object, and I have no opportunity to handle that exception in my service method and re-throw some friendly exception to the client.

But even if I keep my strategy to check existence before deletion, bad stuff is that I have problems with NonUniqueObjectException in the case that instance exist, because I re-attach (in delete-time) already loaded instance (in read-time due existence checking).

For example:

//Existence checking in this example is not so important
public void delete(Employee emp){  
    Employee tempEmp=employeeDao.read(emp.getId());  
    if(tempEmp==null)  
        throw new SomeAppSpecificException();  
}  
//Existence checking in this example is maybe 'more logical'    
public void save(Assignment a){  
    Task t=taskDao.read(a.getTask().getId());
    if(t==null)  
        throw new FriendlyForeignKeyConstraintException(); 
    Employee e=employeeDao.read(a.getEmployee().getId());  
    if(e==null)  
        throw new EmployeeNotFoundExc();
    //...some more integrity checking and similar...  
    assignmentDao.save(a); 
}

The point is that I just want to throw friendly exception with appropriate message in the case of mentioned situations (integrity violations and similar).

Answer 1

In Hibernate terms, both update and delete operations (and corresponding methods on Session) deal with persisted entities. Their existence is, therefore, implied and verifying it again in your code is kind of pointless – Hibernate will do that on its own and throw an exception if that’s not the case. You can then catch and handle (or rethrow) that exception.

On a side note (based on your sample code), it’s not necessary to explicitly read the instance you’re going to delete. Session provides load() method that will return proxy instance suitable for passing to delete() method without actually hitting the database. It assumes that instance associated with given PK exists and will fail (throw an exception) later if that’s not the case.

Edit (based on question clarification):

When you say you want to throw “friendly” exception to the client, the definitions of “friendly” and “client” become important. In most real-life scenarios your transaction would span across more than a simple atomic “save()” or “delete()” method on one of your services.

If the client is local and you don’t need separate transactions within a single client interaction (typical scenario – web app running in the same VM with service layer), it’s usually a good idea to initiate / commit transaction there (see Open Session In View, for example). You can then catch and properly handle (including wrapping / re-throwing, if needed) exceptions during commit. Other scenarios are more complicated, but ultimately the exception will be propagated to your “top level” client; it’s just that unwrapping it may prove to be complicated if you need to present the “root” cause to the client in a “friendly” way.

The bottom line, though, is that it’s up to you. If you’d rather fail fast with your own exception (at the expense of writing some boilerplate code), there’s nothing really wrong with that.