hibernate通用方法

最重要的几项方法是Configuration，SessionFactory，Session，Transaction，query。

Configuration 配置
configure()
configure(String resource)
addResource(String resource)导入一个指定位置的映射文件
addClass(Class clazz)导入与指定类同一个包中的以类名为前缀，后缀为.hbm.xml的映射文件
buildSessionFactory()

SessionFactory Session工厂
openSession()
getCurrentSession()
close()

Session 很重要的一个对象
操作对象的方法
save(Object)
update(Object)
delete(Object)
查询的方法
createQuery(String)--> Query
createCriteria(Class)
管理事务的方法
beginTransaction() --> Transaction
getTransaction() --> Transaction获取当前Session中关联的事务对象
其他的方法
...

Transaction 事务
commit()
rollback()

Query 查询
list() 查询一个结果集合。
uniqueResult()查询一个唯一的结果，如果没有结果，则返回null，如果结果有多个，就抛异常。
...

c，sf，s的操作放在hibernateutils中

package myce.casia.db;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
 
public class HibernateUtils {
 
    private static SessionFactory sessionFactory;
 
    static {
    
        sessionFactory = new Configuration()//
                .configure()//
                .buildSessionFactory();
    }
 
    /*
     * 获得一个全局唯一的SessionFactory
     * 
     * @return
     */
 
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
 
    /*
     * 从全局SessionFactory中打开一个Session
     */
    public static Session openSession() {
        return sessionFactory.openSession();
    }
 
    public static void setSessionFactory(SessionFactory sessionFactory) {
        HibernateUtils.sessionFactory = sessionFactory;
    }
 
}
t，以及增删查改的操作放在dao中

package myce.casia.db;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
 

 
/**
 * @author LinDL
 * 
 */
public class KnowledgeAndRelationDao {
 
    public void save(KnowledgeRelation knowledgeRelation) {
        Session session = HibernateUtils.openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            session.save(knowledgeRelation);
            transaction.commit();
        } catch (RuntimeException e) {
            // TODO: handle exception
            transaction.rollback();
            throw e;
        } finally {
 
        }
        session.close();
    }
 
    public void update(KnowledgeRelation knowledgeRelation) {
        Session session = HibernateUtils.openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            session.update(knowledgeRelation);
            transaction.commit();
        } catch (RuntimeException e) {
            // TODO: handle exception
            transaction.rollback();
            throw e;
        } finally {
 
        }
        session.close();
    }
 
    public void delete(int id) {
        Session session = HibernateUtils.openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            KnowledgeRelation knowledgeRelation = (KnowledgeRelation) session.get(KnowledgeRelation.class, id);// 要先获取到实体对象
            session.delete(knowledgeRelation);// 删除的是实体对象
            transaction.commit();
        } catch (RuntimeException e) {
            // TODO: handle exception
            transaction.rollback();
            throw e;
        } finally {
 
        }
        session.close();
    }
 
    /**
     * @param id
     * @return
     */
    public KnowledgeRelation getById(int id) {
        Session session = HibernateUtils.openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            KnowledgeRelation knowledgeRelation = (KnowledgeRelation) session.get(KnowledgeRelation.class, id);
            transaction.commit();
            return knowledgeRelation;
        } catch (RuntimeException e) {
            // TODO: handle exception
            transaction.rollback();
            throw e;
        } finally {
            session.close();
        }
    }
 
    /**
     * @return
     */
    public List<KnowledgeRelation> findAll() {
        Session session = HibernateUtils.openSession();
        Transaction transaction = null;
        try {
            transaction = session.beginTransaction();
            // 使用HQL查询
            // List<user> all = session.createQuery(from User).list();
            // 使用面向对象的方式查询
            Criteria criteria = session.createCriteria(KnowledgeRelation.class);
            // criteria.add(Restrictions.eq(id, 5));// 添加限制条件，查询id等于5的记录
            // criteria.add(Restrictions.ge(id, 6));//
            // 查询id大于等于6的记录，lt表小于,le表小于等于
            // criteria.addOrder(Order.asc(id));// 添加排序条件
 
            List<KnowledgeRelation> all = criteria.list();
 
            transaction.commit();
            return all;
        } catch (RuntimeException e) {
            // TODO: handle exception
            transaction.rollback();
            throw e;
        } finally {
            session.close();
        }
    }
 
  
   
}