Hibernate.groovy


import  org.hibernate.cfg.Configuration
 import  org.hibernate.Session
 import  org.hibernate.SessionFactory
 import  org.hibernate.Transaction
 import  org.hibernate.tool.hbm2ddl.SchemaUpdate

 class  Hibernate {
    def  static  sessionFactory
    static  { 
        try  { 
            Configuration cfg  =   new  Configuration()
            cfg.configure()            
            new  SchemaUpdate(cfg).execute( true ,  true )      
            sessionFactory  =  cfg.buildSessionFactory()    
        }  catch  (Exception e) {     
            e.printStackTrace()      
        }    
    }    

    Hibernate() {}   

     private  Session getSession() {    
         return  sessionFactory.openSession()    
    }    

    Object execute(closure) {       
        def s  =  getSession()        
            def tr  =   null         
            def result  =   null         
             try  {            
                tr  =  s.beginTransaction()          
                    result  =  closure.call(s)       
                    tr.commit()      
            }  catch  (Exception e) {     
                e.printStackTrace()      
                     if  (tr  !=   null ) {     
                        tr.rollback()    
                    }        
            }  finally  {     
                s.close()   
            }        
         return  result   
    }    

     void  saveOrUpdate(obj) {
        def saveClosure  =  { s  ->  s.saveOrUpdate(obj) }      
        execute(saveClosure)    
    }    

    List executeQuery(hql) {     
        execute({ s  ->  s.createQuery(hql).list() })   
    }    

    List executeQuery(hql, parameters) {    
        def query  =  { s  ->         
            def q  =  s.createQuery(hql)        
                 if  (parameters  !=   null ) {         
                     for  (i in  0 ..parameters.size() - 1 ) {       
                        q.setParameter(i, parameters[i])       
                    }            
                }            
            q.list()       
        }        
        execute(query)    
    }    

    def get(clazz, id) {    
         return  execute({ s  ->  s.get(clazz, id) })   
    }    

     void  delete(obj) {       
        execute({ s  ->  s.delete(obj) })   
    }
}

Instead of interface, I use Closure for callback

Blogged with Flock

Tags: