Generally you go by making a generic DAO interface (could be called as a CRUD repository) and making this generic. Example (Please note that this is not that verbose, just for referring):
public interface GenericDAO<T, ID extends Serializable> {
T save(T entity);
void delete(T entity);
}
Example implementation:
public class GenericHibernateDAO<T, ID extends Serializable>
implements GenericDAO<T, ID> {
private Class<T> persistentClass;
public GenericHibernateDAO() {
this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
.getGenericSuperclass()).getActualTypeArguments()[0];
}
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
public Session getSession()
{
return sessionFactory.getCurrentSession();
}
@Override
public T save(T entity)
{
getSession().save(entity);
return entity;
}
@Override
public void delete(T entity) {
getSession().delete(entity);
}
}
Also, you can refer other similar SO question.
For exception handling you can handle business exceptions or for that matter any exception at individual controller level or from a single point using @ControllerAdvice.
E.g:
@ControllerAdvice
public class GlobalDefaultExceptionHandler {
@ExceptionHandler(Exception.class)
public String exception(Exception e) {
return "error";
}
}
Here is a good blog which touches on exception handling at individual controller level using @ExceptionHandler and at global level using @ControllerAdvice as well as @ExceptionHandler
----------------------------------UPDATE------------------------------------
Hibernate throws a runtime exception called HibernateException.
Think of @Transactional as your BEGIN TRANSACTION COMMIT ROLLBACK model in database, i.e. if you do any operations inside a transaction and if any error occurs during this you should rollback the entire transaction. So, generally we put this sort of code/annotation (@Transactional) in the service layers where you may combine several dao methods and put them together in a transaction making them as a unit of work.
The syntax for using this is:
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
What this means is that if any exception occurs (please note that I have explicitly mentioned Exception.class you can increase the scope and make it Throwable.class) spring would rollback any data updated/ inserted/ deleted for you. If you want to understand Propagation please refer this.
