通用休眠

Question

所附图片显示的是我的情况：

每个过程都有它自己的文件，每个文件都有它的类型。

我有很多程序超过20个，所以每个程序超过60个表 。我必须表明，添加，删除和更新相关的文件，...... 所以我写相同的代码多次 的代码是这样的：

//******************list des document liés à l'étape 
    Session se = HibernateSessionFactory.getSession(); 
    Criteria cr = se.createCriteria(TypeDocFinDetachement.class); 
    cr.add(Restrictions.eq("step",step)); 
    List<TypeDocFinDetachement> list = cr.list(); 

    //---------------------------------------procédure fin détachement en question 
    FinDetachementDAO finDetachementDAO = new FinDetachementDAO(); 
    FinDetachement finDetachement=null; 

    if(sidFinDetachement!="") 
    { Integer idFinDetachement = Integer.parseInt(sidFinDetachement); 
     finDetachement = finDetachementDAO.findById(idFinDetachement); 
    } 

     //*************list des document déjà scannées 
     Session sess = HibernateSessionFactory.getSession(); 
     Criteria criteria = sess.createCriteria(DocumentFinDetachement.class); 
     //criteria.add(Restrictions.eq("finDetachement",finDetachement)); 
     criteria.createAlias("typeDocFinDetachement", "t"); 
     criteria.add(Restrictions.eq("t.step",step)); 
     List<DocumentFinDetachement> listdoc = criteria.list(); 
     Iterator<DocumentFinDetachement> it = listdoc.iterator(); 
     Iterator<TypeDocFinDetachement> iterator = list.iterator(); 

我在J2EE environnment工作与hibernate框架。 我必须为每个程序编写一个特定的代码， 我想知道是否有一种方法来推广这一点？

你也可以参考这个问题：Conceptual issue working with hibernate

Answer 1

好像你有3种不同形式的实体。例如。对于 “程序”， “FinDetachement”：

• TypeDocFinDetachement
• DocFinDetachement
• FinDetachement

目前尚不清楚为什么需要3（显然，如果能减少数量）。总之，假设你需要的所有3 ...

1. 介绍常见抽象祖先类为每个“文件类型”和“文件”和“程序”，并使用@Inheritance（见Hibernate Docs）：

   @Entity 
   @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) // Other strategies would also work 
   public abstract class TypeDocument { 
       // put common document fields & methods here - 
       // if you can work out what they are (they do exist - even if minor!) 
   
       @Id 
       Integer id; 
   
       String step; 
   
       // etc 
   } 
   
   @Entity 
   @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) // Other strategies would also work 
   public abstract class Document { 
       // put common document fields & methods here - 
       // if you can work out what they are (they do exist - even if minor!) 
   } 
   
   @Entity 
   @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) // Other strategies would also work 
   public abstract class Procedure { 
       // put common document fields & methods here - 
       // if you can work out what they are (they do exist - even if minor!) 
   } 
   

2. 这些扩展为您的实际实体：

   @Entity 
   public class TypeDocFinDetachement extends TypeDocument { 
       // put specific fields & methods here 
   } 
   
   @Entity 
   public class DocFinDetachement extends Document { 
       // put specific fields & methods here 
   } 
   
   @Entity 
   public class FinDetachement extends Procedure { 
       // put specific fields & methods here 
   } 
   

3. 介绍普通的G- JPA的逻辑

   public abstract class ProcedureDAO<T extends TypeDocument, D extends Document, P extends Procedure> { 
   
       public P findById(Integer id) { 
        // put "procedure" query logic here 
       } 
   
       public void execProcedure(Class typeDocumentClass, 
                String typeDocName, 
                Class docClass, 
                String docName, 
                String step, 
                String procedureId) { 
        //******************list des document liés à l'étape 
        Session se = HibernateSessionFactory.getSession(); 
        Criteria cr = se.createCriteria(typeDocumentClass); 
        cr.add(Restrictions.eq("step",step)); 
        List<T> list = cr.list(); 
        Iterator<T> iterator = list.iterator(); 
   
        //------------------------ procédure fin détachement en question 
        P procedure =null; 
        if(sid != "") { 
         Integer id = Integer.parseInt(procedureId); 
         procedure = findById(id); 
        } 
   
        //*************list des document déjà scannées 
        // Session sess = HibernateSessionFactory.getSession(); 
        Criteria criteria = sess.createCriteria(docClass); 
        //criteria.add(Restrictions.eq(docName,doc)); 
        criteria.createAlias(typeDocName, "t"); 
        criteria.add(Restrictions.eq("t.step",step)); 
        List<D> listdoc = criteria.list(); 
        Iterator<D> it = listdoc.iterator(); 
   
        // etc 
       } 
   } 
   

4. 如果可能的话eneric DAO，把所有JPA逻辑到祖先DAO和实例，并把它称为“内联”。例如： -

   public class SomeOtherClass { 
   
       public void someMethod() { 
        ProcedureDAO<TypeDocFinDetachement, DocFinDetachement, FinDetachement> finDetachementDAO = new ProcedureDAO(); 
        finDetachementDAO.execProcedure(TypeDocFinDetachement.class, "typeDocFinDetachement", DocumentFinDetachement.class, "finDetachement", "someStage"); 
       } 
   } 
   

5. 如果4是不可能的，创建扩展的DAO（但只有在绝对必要的，因为逻辑必须显著改变）：

   public class FinDetachementDAO extends ProcedureDAO<TypeDocFinDetachement, DocFinDetachement, FinDetachement> { 
   
       // extend/override JPA logic here 
   
   } 
   
   public class SomeOtherClass { 
   
       public void someMethod() { 
        FinDetachementDAO finDetachementDAO = new FinDetachementDAO(); 
        finDetachementDAO.execProcedure(TypeDocFinDetachement.class, "typeDocFinDetachement", DocumentFinDetachement.class, "finDetachement", "someStage"); 
   
       } 
   }