一个通用的Hibernate DAO

经过one-to-one和one-to-many测试没有问题，看直接复制到任何需要DAO的工程中使用
代码
强烈建议在实际使用中加个接口

BaseDAO.JAVA

package com.lusm.HibernateSessionFactory;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;

public class BaseDAO {
    /** *//**
     * 添加实体
     * @param obj，要添加的实体对象
     * @throws Exception
     */
    public void add(Object obj) throws Exception{
        Session session = null;
        try {
            session = HibernateSessionFactory.getSession();
            session.save(obj);
            session.beginTransaction().commit();
            if(session!=null){
                  session.close();
            }
        } catch (RuntimeException e) {
            session.beginTransaction().rollback();
            if(session!=null){
                  session.close();
            }
            throw e;
        }
    }
   
    /** *//**
     * 删除实体
     * @param obj，要删除的实体
     * @throws Exception
     */
    public void delete(Object obj) throws Exception{
        Session session = null;
        try {
            //取得session对象
            session =HibernateSessionFactory.getSession();
            //删除实体
            session.delete(obj);
            //提交事务
            session.beginTransaction().commit();
            if(session!=null){
                  session.close();
            }
        } catch (Exception e) {
            session.beginTransaction().rollback();//事务回滚
            if(session!=null){
                  session.close();
            }
            throw e;
        }
    }

    /** *//**
     * 更新实体
     * @param obj，要更新的实体
     * @throws Exception
     */
    public void update(Object obj) throws Exception{
        Session session=null;
        try {
            //取得session对象
            session=HibernateSessionFactory.getSession();
            //删除实体
            session.update(obj);
            //提交事务
            session.beginTransaction().commit();
            if(session!=null){
                  session.close();
            }
        } catch (Exception e) {
            session.beginTransaction().rollback();//事务回滚
            if(session!=null){
              session.close();
            }
            throw e;
        }
    }
   
    /** *//**
     * 根据指定的hql进行查询，并返回查询结果
     * @param hql，hql语句
     * @return 查询结果
     * @throws Exception
     */
    public List<?> findByHQL(String hql) throws Exception{
        try {
            Query queryObject =HibernateSessionFactory.getSession().createQuery(hql);
            return queryObject.list();
        } catch (Exception e) {
            throw e;
        }
    }
    /** *//**
     * 根据指定的实体类型和主键的值，查找实体对象
     * @param cls，实体的类
     * @param key，主键的值
     * @return，查找的实体对象
     * @throws Exception
     */
    public Object findById(String cls,Serializable key)
        throws Exception
    {
        try {
            Object instance = (Object) HibernateSessionFactory.getSession().get(cls, key);
            return instance;
        } catch (Exception e) {
            throw e;
        }
       
    }
}
HibernateSessionFactory.java 我就不发了，每个工程里都有

值得注意到是：
       写代码是必须考虑到效率，资源利用，第一，不要创建无谓的实例，第二，不要写没有必要的返回语句，第三，close是有目的的，不可以滥用，第四，必须考虑到哪一步出错的概率高，必须在下一步先做判断。

比如代码：
           /** *//**
     * 添加实体
     * @param obj，要添加的实体对象
     * @throws Exception
     */
    public void add(Object obj) throws Exception{
        Session ses=null;
        Transaction tx=null;
        try {
            //取得session对象
            ses=HibernateSessionFactory.getSession();
            //开始事务
            tx=ses.beginTransaction();
            //保存实体
            ses.save(obj);
            //提交事务
            tx.commit();
        } catch (Exception e) {
            tx.rollback();//事务回滚
            throw e;
        }finally{
            //关闭session
            HibernateSessionFactory.closeSession();
        }
    }
使用one-to-many中执行删除时， 你可以会遇到这样的错误

Exception in thread "main" org.hibernate.TransientObjectException: the detached instance passed to delete() had a null identifier
.........或者
Exception in thread "main" org.hibernate.TransientObjectException: the detached instance passed to delete() had a null identifier
    at org.hibernate.event.def.DefaultDeleteEventListener.onDelete(DefaultDeleteEventListener.java:63)
    at org.hibernate.impl.SessionImpl.fireDelete(SessionImpl.java:761)
    at org.hibernate.impl.SessionImpl.delete(SessionImpl.java:739)
    at com.lusm.HibernateSessionFactory.BaseDAO.delete(BaseDAO.java:44)
    at com.lusm.main.Del.main(Del.java:19)或
Exception in thread "main" org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:71)
    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:202)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:235)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:144)
    at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:297)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:27)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:985)
    at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:333)
    at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:106)
    at com.lusm.HibernateSessionFactory.BaseDAO.delete(BaseDAO.java:46)
    at com.lusm.main.Del.main(Del.java:18)
Caused by: java.sql.BatchUpdateException: Cannot delete or update a parent row: a foreign key constraint fails (`lusm/test1`, CONSTRAINT `test1_ibfk_1` FOREIGN KEY (`id`) REFERENCES `test` (`id`))
    at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:1669)
    at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1085)
    at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:58)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:195)
     9 more
原因是你的xml配置和数据库创建有问题
下面给出一个成功的例子
many

xml config
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd ">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="com.lusm.test.Test1" table="test1" catalog="lusm">
        <id name="sid" type="java.lang.Integer">
            <column name="sid" />
            <generator class="increment" />
        </id>
        <many-to-one name="test" class="com.lusm.test.Test" fetch="select" cascade="save-update" >
            <column name="id" not-null="true" />
        </many-to-one>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" />
        </property>
    </class>
</hibernate-mapping>
code
package com.lusm.test;

/** *//**
* Test1 generated by MyEclipse Persistence Tools
*/

public class Test1 implements java.io.Serializable {

    // Fields

    private Integer sid;
    private Test test;
    private String sname;

    // Constructors

    /** *//** default constructor */
    public Test1() {
    }

    /** *//** minimal constructor */
    public Test1(Test test) {
        this.test = test;
    }

    /** *//** full constructor */
    public Test1(Test test, String sname) {
        this.test = test;
        this.sname = sname;
    }

    // Property accessors

    public Integer getSid() {
        return this.sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public Test getTest() {
        return this.test;
    }

    public void setTest(Test test) {
        this.test = test;
    }

    public String getSname() {
        return this.sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

}
one

xml config
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd ">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="com.lusm.test.Test" table="test" catalog="lusm">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="increment" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="name" length="20" />
        </property>
        <set name="test1s" inverse="true">
            <key>
                <column name="id" not-null="true" />
            </key>
            <one-to-many class="com.lusm.test.Test1"/>
        </set>
    </class>
</hibernate-mapping>
code
package com.lusm.test;

import java.util.HashSet;
import java.util.Set;

/** *//**
* Test generated by MyEclipse Persistence Tools
*/

public class Test implements java.io.Serializable {

    // Fields

    private Integer id;
    private String name;
    private Set test1s = new HashSet(0);

    // Constructors

    /** *//** default constructor */
    public Test() {
    }

    /** *//** full constructor */
    public Test(String name, Set test1s) {
        this.name = name;
        this.test1s = test1s;
    }

    // Property accessors

    public Integer getId() {
        return this.id;
    }

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

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set getTest1s() {
        return this.test1s;
    }

    public void setTest1s(Set test1s) {
        this.test1s = test1s;
    }

}
db sql
create table `lusm`.`test1`(
`sid` INT not null auto_increment,
`id` INT not null,
`sname` varchar(20),
primary key (`sid`),
index(sid),
foreign key(id) references test(id) ON DELETE CASCADE ON UPDATE CASCADE
);
    create table `lusm`.`test`(
        `id` INT not null auto_increment,
       `name` VARCHAR(20),
        primary key (`id`)
    );
下面给出 该示例的两个测试类

insert
package com.lusm.main;

import com.lusm.HibernateSessionFactory.BaseDAO;
import com.lusm.test.Test;
import com.lusm.test.Test1;

public class Main {

    /** *//**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        Test test = new Test();

        test.setName("nihao");
        BaseDAO td = new BaseDAO();
        td.add(test);
       
        Test1 t1 = new Test1(test);
        Test1 t2 = new Test1(test);
        Test1 t3 = new Test1(test);
        t1.setSid(1);
        t2.setSid(2);
        t3.setSid(3);
        t1.setSname("nihao");
        t2.setSname("mfafs");
        t3.setSname("acncs");
       
        BaseDAO td1 = new BaseDAO();
        td1.add(t1);
        td1.add(t2);
        td1.add(t3);
              
    }
}
delete
package com.lusm.main;

import com.lusm.HibernateSessionFactory.BaseDAO;
import com.lusm.test.Test;

public class Del {

    /** *//**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        Test test = new Test();
        test.setId(1);
        BaseDAO bd = new BaseDAO();
        bd.delete(test);
    }
}