Question

Firstly clarify that I checked a lot of posts before posting. Maybe I just can’t understand but the solution was posted.

I am developing an struts app v 1.2.9 with hibernate 3 (no spring).
My problem is that if for example I delete an entity, I do commit, then I can see the changes are ok in the database. But, if I query the table, retrieve this entity that I delete in advance.

This is part of my hibernate.cfg.xml

<property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">XXXXXXXXXXXXXXX</property>
<property name="hibernate.connection.username">X</property>
<property name="hibernate.connection.password">X</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.hbm2ddl.auto">validate</property>

org.hibernate.cache.NoCacheProvider

My HibernateUtil (copied from other posts)

 import org.hibernate.SessionFactory;

      import org.hibernate.cfg.Configuration;

      public class HibernateUtil {

            private static final SessionFactory sessionFactory;

            static {
                try {
                    // Create the SessionFactory from hibernate.cfg.xml
                sessionFactory = new           Configuration().configure().buildSessionFactory();

                } catch (Throwable ex) {
                    // Make sure you log the exception, as it might be swallowed
                    System.err.println("Initial SessionFactory creation failed." + ex);
                    throw new ExceptionInInitializerError(ex);
                }
            }

            public static SessionFactory getSessionFactory() {
                return sessionFactory;
            }

And my DAO

import com.mylib.modelo.Television;
import com.mylib.plugins.HibernateUtil;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.mylib.plugins.HibernateUtil;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;


public class TelevisionsDAO  {

   private static final Log log = LogFactory.getLog(TelevisionsDAO.class);

    public Television getTelevisionById(int idTelevision){
        Session session=null;
        Transaction tx =null;
        Television rs =null;
        try{
            session = HibernateUtil.getSessionFactory().getCurrentSession();
            tx = session.beginTransaction();
            session.flush();

            //QJ: Use Hibernate Criteria for more secured functionalities
            rs=(Television) session.createCriteria(Television.class)
                     .add(Restrictions.eq("idTelevision", idTelevision))
                     .uniqueResult();
            if(rs!=null)session.refresh(rs);
            tx.commit();
        }catch(HibernateException e){
            e.printStackTrace();
        }
         return rs;
    }
    public List<Television> encuentraTelevisions(Integer idUsuario){
        Session session=null;
        Transaction tx =null;
        List rs =null;
        try{
            session = HibernateUtil.getSessionFactory().getCurrentSession();
            tx = session.beginTransaction();
            //QJ: Use Hibernate Criteria for more secured functionalities
            rs=(List)session.createCriteria(Television.class)
                     .add(Restrictions.eq("usuario.idUsuario", idUsuario))
                     .list();
        }catch(HibernateException e){
            e.printStackTrace();
        }
         return rs;
    }

    public List<Television> encuentraTelevisions(Integer idUsuario, Boolean buscaOfrece){
        Session session=null;
        Transaction tx =null;
        List rs =null;
        try{
            session = HibernateUtil.getSessionFactory().getCurrentSession();
            tx = session.beginTransaction();
            //QJ: Use Hibernate Criteria for more secured functionalities
            rs=(List)session.createCriteria(Television.class)
                     .add(Restrictions.eq("usuario.idUsuario", idUsuario))
                     .add(Restrictions.eq("buscaOfrece", buscaOfrece))
                     .list();
//            for(int i=0;i<rs.size();i++){
//                session.refresh((Television)rs.get(i));
//            }
            tx.commit();
        }catch(HibernateException e){
            e.printStackTrace();
        }
         return rs;
    }

    public boolean hasTelevision(Integer idUsuario, Boolean buscaOfrece,
            Integer idConocimiento){
        Session session=null;
        Transaction tx =null;
        List rs =null;
        try{
            session = HibernateUtil.getSessionFactory().getCurrentSession();
            tx = session.beginTransaction();
            //session.flush();
            //QJ: Use Hibernate Criteria for more secured functionalities
            rs=(List)session.createCriteria(Television.class)
                     .add(Restrictions.eq("usuario.idUsuario", idUsuario))
                     .add(Restrictions.eq("buscaOfrece", buscaOfrece))
                     .add(Restrictions.eq("conocimiento.idConocimiento", idConocimiento))
                     .list();
            tx.commit();
        }catch(HibernateException e){
            e.printStackTrace();
        }
         return rs.size()>0;
    }

    public Integer addTelevision(Television television) throws Exception {
        log.info("addTelevision");
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        Transaction tx = session.beginTransaction();
        try {
            Integer p = (Integer) session.save(television);
            session.flush();
            session.refresh(television);
            tx.commit();

            log.info("end addTelevision");
            return p;
        } catch (HibernateException e) {
            log.error("addTelevision", e);
            tx.rollback();
            throw e;
        }
    }

    public void quitarTelevision(Television television) throws Exception {
        log.info("quitarTelevision");

        Session session= HibernateUtil.getSessionFactory().getCurrentSession();
        Transaction tx = session.beginTransaction();
        try {
            session.delete(television);
            session.flush();
            //session.refresh(television);
            tx.commit();

        } catch (HibernateException e) {
            log.error("quitarTelevision", e);
            tx.rollback();
            throw e;
        } 
    }

In TelevisionBL:

public Integer addTelevision(Usuario usuario, Integer idConocimiento,
boolean buscaOfrece)throws Exception{

    //compruebo que el usuario no contiene la telerencia en cuestión       
    if(!televisionDAO.hasTelevision(
            usuario.getIdUsuario(), buscaOfrece, idConocimiento)){
        Television tel = new Television();
        tel.setBuscaOfrece(buscaOfrece);
        tel.setUsuario(usuario);
        tel.setConocimiento(new Conocimiento(idConocimiento));
        return telerenciasDAO.addTelevision(tel);
    }else{
        return -1;
    }
  }

   public boolean quitarTelevisionSafe(Integer idTelevision, Integer idUsuarioRequesting) throws Exception{
        Television television = televisionsDAO.getTelevisionById(idTelevision.intValue());
        if( television.getUsuario().getIdUsuario().intValue() == idUsuarioRequesting.intValue() ){
            televisionsDAO.quitarTelevision(television);
            return true;
        }else{
            return false;
        }
    }

Answer 1

At some point you need to close the session.