Erro na Sessão do Hibernate

Bom já procurei no google, guj e outro. mas sei lá n consegui resolver.. ta foda. ja mudei a implementação dos meus metodos pq vi q poderia ser o bi-direcional das Classes.. mas nada da certo..

Alguem pode me dar uma Luz quanto a esse erro???

se Alguem Puder me ajudar Muito Obrigado =D

Provavelmente seu problema começou a partir do momento que você abriu duas sessões por acidente (s1 e s2, por exemplo).
Aí você deve estar tentando atualizar uma instância gerenciada por s1 usando s2.

Então eu tenho noção disso.. mas tipo meu problema ocorre.. q eu faço select d uma lista.. e dps vo tentar excluir um item dessa lista....
mas no select n abre sessão.. n sei pq tem esse problema...

Acho que será melhor você mostrar um pouco de código.

Metodo que estou excluindo 1 Item..

GenericDAO

public class GenericDAO<T> extends HibernateUtil implements InterfaceDAO<T, Serializable>{
	
	/* Classe e Session utilizada nos metodos */
	private final Class<T> classe;
	private Session session;
	
	public GenericDAO(Class<T> classe) {
		this.classe = classe;
		session = HibernateUtil.getCurrentSession();
	}

/* Retorna um Objeto, de acordo com ID passado por parâmetro. */
	public T procurarPorId(Serializable id) {
		return (T) session.load(classe, id);
	}
	
	/* Apaga um Objeto, de acordo com objeto passado por parâmetro.  */
	public void apagar(T entidade) {
		try{
			doBeginTransaction();
			getCurrentSession().delete(entidade);
			doCommit();
	
		}
		catch (Exception e) {
			doRollback();
			e.printStackTrace();
		}
	}
	
	
	/* Lista todos objetos de uma Entidade */
	public List<T> listar() {
		Criteria c = session.createCriteria(classe);
		return c.list();
	}
	
	/* Retorna uma Lista de Objetos, Passa-se por Parametro uma Query, e os parâmetros por um Map. */
	public List<T> listaPorCriterio(String query, Map<String,Object> parametros){
		Query q = session.createQuery(query);
		
		for(String chave : parametros.keySet()){
			q.setParameter(chave, parametros.get(chave));
		}
		
		return q.list();
	}
}

E Minha Classe Hibernate Util..

public class HibernateUtil {   
    /**  
     * Protegido para evitar a criação da classe  
     */   
    protected HibernateUtil() {   
        super();   
    }   
  
    /* Constante de caminho do arquivo de configuração do Hibernate */   
  
    /* Threads que controlarão a sessão e a transação */   
    private static final ThreadLocal<Session> threadSession = new ThreadLocal<Session>();   
    private static final ThreadLocal<Transaction> threadTransaction = new ThreadLocal<Transaction>();   
  
    /* Variaveis do Hibernate */   
    private static final Configuration cfg = new AnnotationConfiguration();   
    private static SessionFactory sessionFactory;   
    
    /* Variavel log4J */
      private static Logger log = Logger.getLogger(HibernateUtil.class);
  
    /**  
   		Método que retorna a instancia da Sessão.   
     */   
    public static Session getCurrentSession() throws HibernateException {   
        Session session = threadSession.get();   
  
        try {   
            if (session == null || !session.isOpen()) {   
                if (sessionFactory == null) {   
                    try {   
                        cfg.configure();   
                        sessionFactory = cfg.buildSessionFactory();   
                    }catch (Exception e) {   
                        throw e;   
                    }   
                }   
                session = (sessionFactory != null) ? sessionFactory.openSession() : null;   
         
                threadSession.set(session);   
            }   
        } catch (Exception e) {   
            throw new HibernateException(e);   
        }   
        log.info("Sessão Retornada");
        return session;   
    }   
  
    /**  
     * Método que fecha a sessão do Hibernate.  
     * @throws SessionFactoryException  
     */   
    public static void doCloseSession() throws HibernateException {   
        Session session = threadSession.get();   
        threadSession.set(null);   
  
        try {   
            if (session != null) {   
                session.close(); 
                log.info("Sessão Fechada");
            }   
        } catch (Exception e) {   
            throw new HibernateException(e);   
        }   
    }   
  
    /**  
     * Método que inicia a transação do Hibernate.  
     * @throws SessionFactoryException  
     */   
    public static void doBeginTransaction() throws HibernateException {   
        Transaction tx = threadTransaction.get();   
  
        try {   
            if(tx == null){   
                tx = getCurrentSession().beginTransaction();   
                threadTransaction.set(tx);  
                log.info("Sessão Pronta para Transação");
            }   
        } catch (Exception e) {   
            throw new HibernateException(e);   
        }   
    }   
  
    /**  
     * Método que executa o rollback da transação.  
     * @throws SessionFactoryException  
     */   
    public static void doRollback() throws HibernateException {   
        Transaction tx = threadTransaction.get();   
  
        try {   
            if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){   
                tx.rollback();   
                threadTransaction.set(null);  
                log.info("Rollback Efetuado");
            }   
        } catch (Exception e) {   
            throw new HibernateException(e);   
        }   
    }   
    
    /* LIMPANDO CACHE PRIMÁRIO DO HIBERNATE   */
    public static void doFlush(){   
        try {   
            getCurrentSession().flush();   
            getCurrentSession().clear();  
            log.info("Cache Limpo");
        
        } catch (Exception e) {   
            throw new HibernateException(e);   
        }   
    }   
    /**  
     * Método que commita a transação.  
     * @throws SessionFactoryException  
     */   
    public static void doCommit() throws HibernateException {   
        Transaction tx = threadTransaction.get();   
  
        try {   
            if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){   
                tx.commit();   
                threadTransaction.set(null);   
                log.info("Commit Efetuado");
                doFlush();
            }   
        } catch (Exception e) {   
            doRollback();   
            throw new HibernateException(e);   
        }   
    }   
}

Acho q com isso da pra ter uma ideia das melecas que deve ter aki no projeto kkkk

Bom, eu estou vendo que você abre a sessão mas não a fecha. Você precisa fechar a sessão após cada operação.

Sim.. eu sei.. mas tipo eu colokei o metodo doCloseSession. após o commit mas ai ele da erro falando q ta fechada a sessão

Notícias, artigos e o maior fórum brasileiro sobre Java