Java：休眠太慢了答案

【问题标题】：Java : Hibernate is too much slowJava：休眠太慢了
【发布时间】：2013-08-24 14:09:52
【问题描述】：

我正在开发一个 swing 应用程序来处理数据，我选择 Hibernate 是因为它的性能。现在我完成了 80% 的工作。我发现应用程序太慢了，就像永远在等待。我google了一下，发现如果有很多数据，Hibernate并不是最好的选择。我不知道，问题是我的数据库很复杂，很多关联、连接、集合...... 我没有时间重新开始！请帮忙

这是一段 sn-p 代码，这是我检索数据的方式，每个实体都有一个相似的类

public class CoursCrud {
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();  
Session session ;
 public ArrayList<Object> findCoursByCoursId( int id){
    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findLastCours(){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findLastCours");
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findAllCours(){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findAllCours");
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findProfByCoursId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findProfByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}

  public ArrayList<Object> findGroupeByCoursId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findGroupeByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findGroupeByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findGroupeByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findSalleByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findSalleByCreneauId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findProfByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findProfByCreneauId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCreneauFromCoursByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCreneauFromCoursByCreneauId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();

    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCoursByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursByCreneauId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}

  public ArrayList<Object> findSalleByCoursId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findSalleByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCreneauByCoursId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCreneauByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}

public   ArrayList<Object> findCoursByGroupeId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursByGroupeId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;
}
public   ArrayList<Object> findCoursBySalleId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursBySalleId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;
}
public   ArrayList<Object> findProfBySalleId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findProfBySalleId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;
}


  public int findIndex(int id){
    CoursCrud C= new CoursCrud();
    ArrayList<Object> cours =C.findAllCours(); 
    int i=0;
    for(Object cu: cours){
        i++;
        if(((Cours) cu).getId() == id){
            break;
        }
    }
    return --i;
}
public void createData( Object p){
    session = HibernateUtil.getSessionFactory().openSession();
    Transaction transaction = null;
    try {
        transaction = session.beginTransaction();
        session.save(p);  
        transaction.commit();  
    } catch (HibernateException e) {
        transaction.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }  
}
public void updateData( Object p){

    session = sessionFactory.openSession();  
    session.beginTransaction();  

    session.update(p);  
    session.getTransaction().commit();  

    session.close();
}

public void CoursEmpty(){  
    CoursCrud C= new CoursCrud();
    List<Object> cc = C.findAllCours();
    for(Object c: cc){
        C.deleteCoursByCoursId(((Cours)c).getId());
    }
}
public void deleteCoursByCoursId(int id){
    session = HibernateUtil.getSessionFactory().openSession();
    CoursCrud C= new CoursCrud();
    Transaction transaction = null;
    try {
        transaction = session.beginTransaction();     
        Cours c = (Cours) C.findCoursByCoursId(id).get(0);
        session.delete(c);
        transaction.commit();  
    } catch (HibernateException e) {
        transaction.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }   
}

public void deleteCoursCreneauByCoursId(int id){
    session = HibernateUtil.getSessionFactory().openSession();
    Transaction transaction = null;
    try {
        transaction = session.beginTransaction();     
        Query Q = session.getNamedQuery("deleteCoursCreneauByCoursId");
        Q.setLong("id", id).executeUpdate();
        transaction.commit();  
    } catch (HibernateException e) {
        transaction.rollback();
        e.printStackTrace();
        System.out.println("Not succ !! \n");
    } finally {
        session.close();
    }   
}

  public ArrayList<Object> findCreneauIndisponibiliteByCoursId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCreneauIndisponibiliteByCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCoursIndisponibleByCreneauId(int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursIndisponibleByCreneauId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCoursByClassCoursId( int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursByClassCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public void deleteCoursByClassCours(int id){
    CoursCrud C= new CoursCrud();
    for(Object o: C.findCoursByClassCoursId(id)){
        C.deleteCoursSeanceByCoursId(((Cours)o).getId());
        C.deleteCoursCreneauByCoursId(((Cours)o).getId());
        C.deleteCoursByCoursId(((Cours)o).getId());
    }
}
  public ArrayList<Object> findGroupeByClassCoursId( int id){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findGroupeByClassCoursId");
    Q.setLong("id", id);
    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Integer> findIndexGroupebyClassCours(int id){
    CoursCrud C= new CoursCrud();
    GroupeCrud Gc= new GroupeCrud();
    ArrayList<Object> groupeSelectedList= C.findGroupeByClassCoursId(id);
    ArrayList<Object> groupeList= Gc.findAllGroupe();
    ArrayList<Integer> indexSelectedList= new ArrayList<Integer>();

    Alert a= new Alert();
    for(Object m: groupeList){
        for(Object ms: groupeSelectedList){
            if(((Groupe) m).getId() == ((Groupe) ms).getId() ){
                indexSelectedList.add(groupeList.indexOf(m));
            }
        }
    }
    return indexSelectedList;
}
  public ArrayList<Integer> findIndexSeancebyClassCours(int id){
    CoursCrud C= new CoursCrud();
    SeanceCrud sC=new SeanceCrud();
    ArrayList<Seance> SeanceSelectedList = new ArrayList<Seance>();
    for(Object o: C.findCoursByClassCoursId(id)){
        for(Object v: sC.findSeanceByCoursId(((Cours)o).getId())){
            SeanceSelectedList.add((Seance)v);
        }
    }

    ArrayList<Object> seanceList= sC.findAllSeance();
    ArrayList<Integer> indexSelectedList= new ArrayList<Integer>();

    Alert a= new Alert();
    for(Object m: seanceList){
        for(Seance ms: SeanceSelectedList){
            if(((Seance) m).getId() == ms.getId() ){
                indexSelectedList.add(seanceList.indexOf(m));
            }
        }
    }
    return indexSelectedList;
}
public void deleteCoursSeanceByCoursId(int id){
    CoursCrud C= new CoursCrud();
    session = HibernateUtil.getSessionFactory().openSession();
    Transaction transaction = null;
    try {
        transaction = session.beginTransaction();     
        Cours c = (Cours) C.findCoursByCoursId(id).get(0);
        c.getCoursSeance().clear();
        session.update(c);
        transaction.commit();  
    } catch (HibernateException e) {
        transaction.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }   
}
  public ArrayList<Integer> findIndexIndisponibilitebyCoursId(int id){
    CoursCrud C= new CoursCrud();
    CreneauCrud cC= new CreneauCrud();
    ArrayList<Object> IndispoSelectedList= C.findCreneauIndisponibiliteByCoursId(id);
    ArrayList<Object> creneauList= cC.findAllCreneau();
    ArrayList<Integer> indexindispoSelectedList= new ArrayList<Integer>();

    Alert a= new Alert();
    for(Object m: creneauList){
        for(Object ms: IndispoSelectedList){
            if(((Creneau) m).getId() == ((Creneau) ms).getId() ){
                indexindispoSelectedList.add(creneauList.indexOf(m));
            }
        }
    }
    return indexindispoSelectedList;
}
  public ArrayList<Object> findCoursIndisponibleByCreneauIdAndCoursId(int idCreneau, int idCours){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursIndisponibleByCreneauIdAndCoursId");
    Q.setLong("idCours", idCours);
    Q.setLong("idCreneau", idCreneau);

    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}
  public ArrayList<Object> findCoursByCreneauIdAndGroupeId(int idCreneau, int idGroupe){

    session = sessionFactory.openSession();  
    Query Q = session.getNamedQuery("findCoursByCreneauIdAndGroupeId");
    Q.setLong("idGroupe", idGroupe);
    Q.setLong("idCreneau", idCreneau);

    List<Object> objet = Q.list();
    session.close(); 
    return (ArrayList<Object>) objet;   
}

【问题讨论】：

如果您发布一些性能较差的代码 sn-ps 可能会有所帮助。您可能需要监视数据库以确保没有锁定问题。 ORM 不太适合批处理，但对于普通的 OLTP 应用程序来说很好。
当你使用swing和hibernate时，你的意思是你的应用程序冻结很慢？可能你想用 lucene 使用休眠，数据库中的查询很快？可能是你有n+1个问题！！照顾好那个！尽量使用show_sql=true尽量避免n+1

标签： java mysql hibernate jdbc

【解决方案1】：

您是否要返回一个大型数据集，然后使用 Java 将其过滤为少量记录？我以前见过。通过网络传输大量数据却丢弃大部分数据是一个常见的错误。

【讨论】：

【解决方案2】：

您提到DB实体之间存在复杂的关系，如果您没有，您可能想查看Hibernate“延迟加载”。

延迟加载控制何时以及如何将相关实体加载到内存中，在许多情况下，它可以带来巨大的性能提升。

【讨论】：

在某些实体中，我不得不将其设置为 EAGER 以从连接表中删除一些数据。

【解决方案3】：

不，这绝对不是这种情况。 hibernate 是目前最好的 ORM 实现之一。你应该弄清楚你的查询、数据库索引和其他优化。如果数据库是大多数应用程序的最大瓶颈。如果您看到，hibernate 在内部使用 jdbc 并触发 SQL 查询。它大大减少了您的工作，并提供了非常具体的实现和接口。请对您的问题提供更多描述，以解释为什么您认为休眠是罪魁祸首，而不是其他原因。

【讨论】：

【解决方案4】：

也许您尝试缩小问题的具体范围。您的问题可以通过适当的索引等解决。也许提供更多信息。

通常数据库中最慢的部分是创建数据库连接。你在使用数据库池吗？

【讨论】：

不，我不使用它。我读到每次创建会话工厂可能是原因。在我的代码中用于从我创建并关闭它的数据库中检索数据的每个操作。
数据库连接池很好。但它通常不是一个展示停止器。
正如您所说，这可能是原因。我不确定您从哪里调用数据库代码，但是如果您从头开始创建 sessionFactory 连接，我觉得这会很慢。不能保留之前创建的数据库连接吗？
@TonyEnnis 可以。 serverfault.com/questions/51317/…