web-dev-qa-db-fra.com

Hibernate Session.delete () un objet s'il existe

Dans JavaDoc de la classe Session, la description de la méthode delete est:

Supprimez une instance persistante de la banque de données. L'argument peut être une instance associée à la session réceptrice ou une instance transitoire avec un identifiant associé à un état persistant existant.

Mes questions sont:

  1. Je veux supprimer un objet de détachement, puis-je utiliser cette méthode, la session AFAIK rend d'abord un objet persistant de détachement, puis effectue son opération. Ai-je raison?
  2. Si je ne suis pas sûr de l'existence de l'objet dans la base de données, dois-je utiliser Session.get () pour vérifier s'il est nul ou non, puis effectuer l'opération de suppression ou je peux utiliser directement l'opération de suppression?

Voici un extrait de code:

public void removeUnallocatedUserIfExits(final long itemId) {
    getHibernateTemplate().execute(new HibernateCallback() {

        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            session.flush();
            session.setCacheMode(CacheMode.IGNORE);
            UnallocatedUser unallocatedUser;
            if ((unallocatedUser = (UnallocatedUser) session.get(UnallocatedUser.class, itemId)) != null) {
                session.delete(unallocatedUser);
            }
            session.flush();
            return null;
        }
    });
}

Est-ce que ça va?

javahibernatesession
17
Tapas Bose

ou une instance transitoire avec un identifiant associé à un état persistant existant

Cela signifie que vous pouvez directement passer votre entity à session.delete(), afin de supprimer cet objet. De plus, vous n'avez pas besoin de vérifier si l'entité existe ou non. Il devrait y avoir une exception si aucun enregistrement n'a été trouvé dans la base de données. En fait, nous n'obtenons généralement pas vraiment ce cas. Nous supprimons toujours une entité existante, je veux dire que la logique habituelle est comme ça; donc pas besoin de faire ça. Vous pouvez simplement le faire,

SomeEntity ent = session.load(SomeEntity.class, '1234');
session.delete(ent);

ou vous pouvez le faire à la place,

SomeEntity ent = new SomeEntity('1234'); // used constructor for brevity
session.delete(ent);

Btw, vous pouvez également utiliser cette version session.delete(String query),

sess.delete("from Employee e where e.id = '1234'"); // Just found it is deprecated
27
Adeel Ansari
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class DeletePersistentObjectWithHibernate {

public static void main(String[] args) {

        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        Session session = sessionFactory.getCurrentSession();

        long id = 2;

        try {
            session.beginTransaction();

            Employee employee = (Employee) session.get(Employee.class, id);

            session.delete(employee);

            session.getTransaction().commit();
        }
        catch (HibernateException e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }

    }

}
7
Musaddique

Je viens de trouver une meilleure solution:

Query q = session.createQuery("delete Entity where id = X");
q.executeUpdate();

Hibernate Delete query

3
bluearrow

Essaye ça...

public <T> T delete(T t) throws Exception {
    try {
        t = load(t);
        session.delete(t);
        session.flush();
    } catch (Exception e) {
        throw e;
    } finally {
        session.clear();
    }

    return t;
}

public <T> T load(T t) {
    session.buildLockRequest(LockOptions.NONE).lock(t);
    return t;
}
3
jsina

Vous pouvez facilement y parvenir en suivant une mise en veille prolongée simple comme suit,

Session session=getSession();  
String hql = "delete from Student where classId= :id"; 
session.createQuery(hql).setString("id", new Integer(id)).executeUpdate();
1
Osama Abdulsattar

Je veux supprimer un objet de détachement, puis-je utiliser cette méthode, la session AFAIK rend d'abord un objet persistant de détachement, puis effectue son opération. Ai-je raison?

Si vous connaissez l'identifiant de l'objet que vous souhaitez supprimer, vous pouvez créer une instance avec son ensemble d'identificateurs et la transmettre à la méthode de suppression de session. Cette instance serait considérée comme étant à l'état détaché (car il y a un identifiant associé), mais elle sera rattachée en interne à la session par Hibernate puis supprimée.

Si je ne suis pas sûr de l'existence de l'objet dans la base de données, dois-je utiliser Session.get () pour vérifier s'il est nul ou non, puis effectuer l'opération de suppression ou je peux utiliser directement l'opération de suppression?

La méthode delete lèvera StaleObjectException si elle ne trouve pas l'objet à supprimer. Vous pouvez donc utiliser la gestion des exceptions pour décider quoi faire dans ce cas.

1
Shailendra