Hibernate não atualiza sessão

[furacao123]

Ola estou tendo um problema com o hibernate, tenho duas aplicações que acessam um mesmo banco de dados, quando eu abro o meu formulario de consulta me carerga todos os dados em uma JTable até ae tudo bem, mas quando outra aplicação ou mesmo na mão eu altero um valor do banco, dou um buscar novamente no meu formulario de consulta e nada muda, parece q ele guarda na sessao e nao busca do banco novamente, agora se eu executo algum comando (INSERT, UPDATE, DELETE) e dou um select em seguida ele tras o valor adicionado no banco o que pode ser?

segue o GenericDAO e classe de conexao

[code]public class HibernateUtil {

private static SessionFactory sessionFactory;

static {
    try {
        sessionFactory = new AnnotationConfiguration()
           .setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLDialect")
           .setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver")
           .setProperty("hibernate.connection.url", "jdbc:mysql://Neo:3306/comanda?charSet=LATIN1")
           .setProperty("hibernate.connection.username", "root")
           .setProperty("hibernate.connection.password", "")
           .setProperty("hibernate.hbm2ddl.auto", "false")//update atualiza BD
           .setProperty("hibernate.show_sql", "false")
           .setProperty("hibernate.format_sql", "true")
           .setProperty("hibernate.c3p0.acquire_increment", "1")
           .setProperty("hibernate.c3p0.idle_test_period", "300")
           .setProperty("hibernate.c3p0.max_size", "5")
           .setProperty("hibernate.c3p0.max_statements", "50")
           .setProperty("hibernate.c3p0.min_size", "5")
           .setProperty("hibernate.c3p0.timeout", "300")
           .setProperty("hibernate.current_session_context_class", "thread")
           .addAnnotatedClass(Agrup.class)
           .addAnnotatedClass(Agrupamento.class)
           .addAnnotatedClass(Ambiente.class)
           .addAnnotatedClass(AreaAtendente.class)
           .addAnnotatedClass(Atendente.class)
           .addAnnotatedClass(Caixa.class)
           .addAnnotatedClass(Categoria.class)
           .addAnnotatedClass(Cliente.class)
           .addAnnotatedClass(Codigobarras.class)
           .addAnnotatedClass(Comanda.class)
           .addAnnotatedClass(Comandaitem.class)
           .addAnnotatedClass(Comandapagamento.class)
           .addAnnotatedClass(Cupomfiscal.class)
           .addAnnotatedClass(Cupomficalitem.class)
           .addAnnotatedClass(Cupomfiscalpagamento.class)
           .addAnnotatedClass(Formapagamento.class)
           .addAnnotatedClass(Fornecedor.class)
           .addAnnotatedClass(Impressoras.class)
           .addAnnotatedClass(LogDetalheMesa.class)
           .addAnnotatedClass(Logdiario.class)
           .addAnnotatedClass(Logmesa.class)
           .addAnnotatedClass(Mesa.class)
           .addAnnotatedClass(ModoPreparo.class)
           .addAnnotatedClass(ModoPreparoComandaItem.class)
           .addAnnotatedClass(Ncm.class)
           .addAnnotatedClass(Opcional.class)
           .addAnnotatedClass(Opcional.class)
           .addAnnotatedClass(OpcionalComandaItem.class)
           .addAnnotatedClass(Operacao.class)
           .addAnnotatedClass(Operador.class)
           .addAnnotatedClass(Produto.class)
           .addAnnotatedClass(Receita.class)
           .addAnnotatedClass(Reserva.class)
           .addAnnotatedClass(ReservaMesa.class)
           .addAnnotatedClass(Usuario.class)

           .buildSessionFactory();

    } catch(Exception e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(null, "Erro na fabrica de sessoes = "+e);
        sessionFactory = null;
    }
}

public static Session getSession() {
    return sessionFactory.openSession();
}

}[/code]

GENERIC DAO

[code]package model.dao;

import java.io.Serializable;
import java.util.List;
import javax.swing.JOptionPane;
import model.util.HibernateUtil;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;

public abstract class GenericDAO {

private final Session session;
Transaction transaction = null;

public GenericDAO() {
    this.session = HibernateUtil.getSession();
}

/**
 * Salva ou atualiza registro no banco
 * @param pojo
 */
protected void salvaOuAtualizaPojo(Serializable pojo) {
    try {
        transaction = session.beginTransaction();
        session.saveOrUpdate(pojo);
        transaction.commit();
    } catch (HibernateException e) {
        JOptionPane.showMessageDialog(null, "Erro na inserção = " + e);
        transaction.rollback();
    }
}

/**
 * Remove registro
 * @param pojo
 */
protected void removePojo(Serializable pojo) {
    try {
        transaction = session.beginTransaction();
        session.delete(pojo);
        transaction.commit();
    } catch (HibernateException e) {
        JOptionPane.showMessageDialog(null, "Erro na exclusão = " + e);
        transaction.rollback();
    }
}

/**
 * Faz consulta passando a chave primaria como parâmetro
 * @param Classe
 * @param chave primária
 * @return Objeto populado
 */
protected <T extends Serializable> T getPurePojo(Class<T> classtoSearch, Serializable key) {
    Serializable retorno = (Serializable) session.get(classtoSearch, key);
    return (T) retorno;
}

/**
 * Método geral para consulta passando HQL
 * @param query
 * @param parametros
 * @return
 */
protected Serializable getPurePojo(String query, Object... parametros) {
    Query qr = session.createQuery(query);
    for (int i = 1; i <= parametros.length; i++) {
        qr.setParameter(i, parametros[i - 1]);
    }
    Object retorno = qr.uniqueResult();
    return (Serializable) retorno;
}

/**
 * Método usa o CreateQuery
 * @param Classe
 * @param query
 * @param isLike
 * @param parametros
 * @return Lista de objetos da classe
 */
protected <T extends Serializable> List<T> getPureList(Class<T> classToCast, String query, boolean isLike, Object[]... parametros) {
    Query qr = session.createQuery(query);
    if (isLike) {
        for (Object[] param : parametros) {
            qr.setString(param[0].toString(), param[1].toString().concat("%"));
        }
    } else {
        for (Object[] param : parametros) {
            qr.setString(param[0].toString(), param[1].toString());
        }
    }
    List<T> retorno = qr.list();
    return retorno;
}

/**
 * Método usa o Criteria
 * @param Classe
 * @param isLike
 * @param parametros
 * @return Lista de Objetos da classe
 */
protected <T extends Serializable> List<T> getPureList(Class<T> classToCast, boolean isLike, Object[]... parametros) {
    Criteria criteria = session.createCriteria(classToCast);
    if (isLike) {
        for (Object[] param : parametros) {
            criteria.add(Restrictions.like(param[0].toString(), param[1].toString().concat("%")));
        }
    }
    List<T> retorno = criteria.list();
    return retorno;
}

}[/code]

e um DAO qualquer

[code]package model.dao;

import java.util.List;
import model.bean.Mesa;

public class MesaDAO extends GenericDAO {

public int grava(Mesa imp) {
    salvaOuAtualizaPojo(imp);
    return imp.getId();
}

public void remove(Mesa imp) {
    removePojo(imp);
}

public Mesa getById(Integer id) {
    return getPurePojo(Mesa.class, id);
}

public List<Mesa> getAll() {
    return getPureList(Mesa.class, "FROM Mesa mesa", false);
}

public List<Mesa> getByCadeiras(String cadeiras) {
    return getPureList(Mesa.class, "FROM Mesa mesa WHERE mesa.cadeiras = :cadeiras ORDER BY mesa.cadeiras", false, new Object[][]{{"cadeiras", cadeiras}});
}

public List<Mesa> getByAmbiente(String ambiente) {
    return getPureList(Mesa.class, "FROM Mesa mesa WHERE mesa.ambiente.descricao = :descricao ORDER BY mesa.ambiente.descricao", false, new Object[][]{{"descricao", ambiente}});
}

}[/code]

o BEAN

[code]package model.bean;

import java.io.Serializable;
import java.util.List;
import java.util.Observable;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name = “mesa”, catalog = “comanda”, schema = “”)
@NamedQueries({
@NamedQuery(name = “Mesa.findAll”, query = “SELECT m FROM Mesa m”),
@NamedQuery(name = “Mesa.findById”, query = “SELECT m FROM Mesa m WHERE m.id = :id”),
@NamedQuery(name = “Mesa.findByCadeiras”, query = “SELECT m FROM Mesa m WHERE m.cadeiras = :cadeiras”),
@NamedQuery(name = “Mesa.findByFlag”, query = “SELECT m FROM Mesa m WHERE m.flag = :flag”)})
public class Mesa extends Observable implements Serializable {

private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Basic(optional = false)
@Column(name = "id", nullable = false)
private Integer id;
@Column(name = "cadeiras")
private Integer cadeiras;
@Column(name = "flag")
private Integer flag;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "mesa", fetch = FetchType.LAZY)
private List<ReservaMesa> reservaMesaList;

@JoinColumn(name = "idambiente", referencedColumnName = "id", nullable = false)
@ManyToOne(optional = false, fetch = FetchType.LAZY)
private Ambiente ambiente;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "mesa", fetch = FetchType.LAZY)
private List<Comandapagamento> comandapagamentoList;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "mesa", fetch = FetchType.LAZY)
private List<AreaAtendente> areaAtendenteList;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "mesa", fetch = FetchType.LAZY)
private List<Comanda> comandaList;

@OneToMany(cascade = CascadeType.ALL, mappedBy = "mesa", fetch = FetchType.LAZY)
private List<Comandaitem> comandaItemList;

public Mesa() {
}

public Mesa(Integer id) {
    this.id = id;
}

public Integer getId() {
    return id;
}

public void setId(Integer id) {
    this.id = id;
}

public Integer getCadeiras() {
    return cadeiras;
}

public void setCadeiras(Integer cadeiras) {
    this.cadeiras = cadeiras;
}

public Integer getFlag() {
    return flag;
}

public void setFlag(Integer flag) {
    this.flag = flag;
}

public List<ReservaMesa> getReservaMesaList() {
    return reservaMesaList;
}

public void setReservaMesaList(List<ReservaMesa> reservaMesaList) {
    this.reservaMesaList = reservaMesaList;
}

public Ambiente getAmbiente() {
    return ambiente;
}

public void setAmbiente(Ambiente idambiente) {
    this.ambiente = idambiente;
}

public List<Comandapagamento> getComandapagamentoList() {
    return comandapagamentoList;
}

public void setComandapagamentoList(List<Comandapagamento> comandapagamentoList) {
    this.comandapagamentoList = comandapagamentoList;
}

public List<AreaAtendente> getAreaAtendenteList() {
    return areaAtendenteList;
}

public void setAreaAtendenteList(List<AreaAtendente> areaAtendenteList) {
    this.areaAtendenteList = areaAtendenteList;
}

public List<Comanda> getComandaList() {
    return comandaList;
}

public void setComandaList(List<Comanda> comandaList) {
    this.comandaList = comandaList;
}

public List<Comandaitem> getComandaItemList() {
    return comandaItemList;
}

public void setComandaItemList(List<Comandaitem> comandaItemList) {
    this.comandaItemList = comandaItemList;
}


@Override
public int hashCode() {
    int hash = 0;
    hash += (id != null ? id.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    // TODO: Warning - this method won't work in the case the id fields are not set
    if (!(object instanceof Mesa)) {
        return false;
    }
    Mesa other = (Mesa) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
        return false;
    }
    return true;
}

@Override
public String toString() {
    return String.valueOf(this.id);
}

}
[/code]

como resolvo esse problema?

Obrigado.

[alots_ssa]

Foi mal, mas eu não vi em nenhum momento vc fechando a session do hibernate… Se vc não fecha, ele vai usar o cache de primeiro nivel e vai acontecer exatamente o que vc falou, ele não vai no banco de novo. Quando vc atualiza(insert,update e delete) ele atualiza a session e aí funciona… Tenta fechar a session quando vc acabar de usar ela…

Alberto

[furacao123]

então esqueci de comentar mas quando eu fecho a session da erro nos meus relacionamentos LAZY pois quando ele tenta dar select no relacionamento a sessao esta fechada