How to use

HibernateTemplate

in

org.springframework.orm.hibernate5

@Override
public void delete(String entityName, Object entity) throws DataAccessException {
  delete(entityName, entity, null);
}

/**
 * Create a HibernateTemplate for the given SessionFactory.
 * Only invoked if populating the DAO with a SessionFactory reference!
 * <p>Can be overridden in subclasses to provide a HibernateTemplate instance
 * with different configuration, or a custom HibernateTemplate subclass.
 * @param sessionFactory the Hibernate SessionFactory to create a HibernateTemplate for
 * @return the new HibernateTemplate instance
 * @see #setSessionFactory
 */
protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
  return new HibernateTemplate(sessionFactory);
}

@Override
@Nullable
public Object get(String entityName, Serializable id) throws DataAccessException {
  return get(entityName, id, null);
}

@Override
public void saveOrUpdate(final Object entity) throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    session.saveOrUpdate(entity);
    return null;
  });
}

@Override
public void replicate(final String entityName, final Object entity, final ReplicationMode replicationMode)
    throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    session.replicate(entityName, entity, replicationMode);
    return null;
  });
}

@Override
public void deleteAll(final Collection<?> entities) throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    for (Object entity : entities) {
      session.delete(entity);
    }
    return null;
  });
}

@Override
public void delete(final Object entity, @Nullable final LockMode lockMode) throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    if (lockMode != null) {
      session.buildLockRequest(new LockOptions(lockMode)).lock(entity);
    }
    session.delete(entity);
    return null;
  });
}

@Override
@Nullable
public <T> T get(final Class<T> entityClass, final Serializable id, @Nullable final LockMode lockMode)
    throws DataAccessException {
  return executeWithNativeSession(session -> {
    if (lockMode != null) {
      return session.get(entityClass, id, new LockOptions(lockMode));
    }
    else {
      return session.get(entityClass, id);
    }
  });
}

@Override
public void update(final Object entity, @Nullable final LockMode lockMode) throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    session.update(entity);
    if (lockMode != null) {
      session.buildLockRequest(new LockOptions(lockMode)).lock(entity);
    }
    return null;
  });
}

@Override
public Object load(final String entityName, final Serializable id, @Nullable final LockMode lockMode)
    throws DataAccessException {
  return nonNull(executeWithNativeSession(session -> {
    if (lockMode != null) {
      return session.load(entityName, id, new LockOptions(lockMode));
    }
    else {
      return session.load(entityName, id);
    }
  }));
}

/**
 * Return the Hibernate SessionFactory used by this DAO.
 */
@Nullable
public final SessionFactory getSessionFactory() {
  return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null);
}

@Override
public void refresh(final Object entity, @Nullable final LockMode lockMode) throws DataAccessException {
  executeWithNativeSession(session -> {
    if (lockMode != null) {
      session.refresh(entity, new LockOptions(lockMode));
    }
    else {
      session.refresh(entity);
    }
    return null;
  });
}

@Override
public void update(final String entityName, final Object entity, @Nullable final LockMode lockMode)
    throws DataAccessException {
  executeWithNativeSession(session -> {
    checkWriteOperationAllowed(session);
    session.update(entityName, entity);
    if (lockMode != null) {
      session.buildLockRequest(new LockOptions(lockMode)).lock(entityName, entity);
    }
    return null;
  });
}

/**
 * Unsupported or unused keys should be deleted. This method deletes all entries with the given key.
 * 
 * @param key Key of the entries to delete.
 */
protected void deleteOldKeys(final String key)
{
 final Query query = hibernateTemplate.getSessionFactory().getCurrentSession().createQuery(
   "delete from " + UserXmlPreferencesDO.class.getSimpleName() + " where key = '" + key + "'");
 final int numberOfUpdatedEntries = query.executeUpdate();
 log.info(numberOfUpdatedEntries + " '" + key + "' entries deleted.");
}

@Override
public <T> T load(final Class<T> entityClass, final Serializable id, @Nullable final LockMode lockMode)
    throws DataAccessException {
  return nonNull(executeWithNativeSession(session -> {
    if (lockMode != null) {
      return session.load(entityClass, id, new LockOptions(lockMode));
    }
    else {
      return session.load(entityClass, id);
    }
  }));
}

@Override
public void evict(final Object entity) throws DataAccessException {
  executeWithNativeSession(session -> {
    session.evict(entity);
    return null;
  });
}

@Override
public boolean contains(final Object entity) throws DataAccessException {
  Boolean result = executeWithNativeSession(session -> session.contains(entity));
  Assert.state(result != null, "No contains result");
  return result;
}

@Override
public void lock(final String entityName, final Object entity, final LockMode lockMode)
    throws DataAccessException {
  executeWithNativeSession(session -> {
    session.buildLockRequest(new LockOptions(lockMode)).lock(entityName, entity);
    return null;
  });
}

public void templateSave(Object entity) {
  template.save(entity);
}

@SuppressWarnings("unchecked")
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List<O> internalLoadAll()
{
 return (List<O>) hibernateTemplate.find("from " + clazz.getSimpleName() + " t");
}