经过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);
}
}
相关推荐
HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao 通用HibernateDao ...
总的来说，这个资源为开发者提供了一个高效的工具，通过使用Hibernate和通用DAO模式，可以快速构建数据访问层，同时保持代码的整洁和可维护性。在开发Java Web应用程序时，正确理解和运用这种模式，能大大提高开发...
`HibernateDao.java`是Hibernate框架中一个常见的数据访问对象（DAO，Data Access Object）类，它的主要职责是封装对数据库的操作，提供一套面向对象的接口，使得业务逻辑层可以无需关心底层SQL语句，直接通过对象...
Haha.Hibernate SprintSideExt 通用HibernateDAO 文章资源 详见：http://blog.csdn.net/lijun7788/article/details/6658847
**Hibernate原生通用DAO**是基于Hibernate框架设计的一种简化数据访问操作的方式，它模仿了Spring框架中的`HibernateTemplate`类，旨在提供一个简单易用的DAO（Data Access Object）层，方便开发人员进行数据库操作...
由于没有具体的文件列表，我们无法详细讨论每个文件的内容，但根据标题和描述，我们可以推断这是一个关于使用Hibernate4创建通用DAO和Service的教程或资源，旨在帮助Java开发者理解和应用这种模式来提高开发效率。...
本文将围绕“Hibernate超级通用DAO”这一主题，深入探讨如何构建一个功能强大的DAO层，实现包括增、删、改、查以及多条件模糊查询在内的各种功能。 首先，Hibernate是一个流行的Java ORM（对象关系映射）框架，它...
1. **接口定义**：首先，定义一个通用的DAO接口，如`BaseDao<T>`，其中T代表任何数据实体类型。接口中包含增删改查（CRUD）的基本方法，如`save()`, `update()`, `delete()`, `findById()`等。 2. **实现接口**：...
spring集成hibernate通用dao，泛型，server都可以调用
为了解决这个问题，我们可以通过设计一个通用的Hibernate DAO来减少重复工作。 1. **通用Dao的设计思想** - **继承机制**：创建一个基类AbstractHibernateDao，其中包含常用的CRUD（Create, Read, Update, Delete...
创建一个DAO接口，定义所有需要的方法，然后创建一个实现该接口的类，如`UserDaoImpl`，在这个实现类中使用Hibernate API完成实际的数据库操作。 5. **泛型DAO**： 为了进一步提高代码的复用性，可以使用泛型来...
通用dao,简单全面,所有dao都可以继承这个dao.
一个基本的HibernateDAO实现通常包含以下部分： - 数据库连接配置：通过Hibernate的SessionFactory创建，这是所有Session的工厂。 - Session管理：在需要进行数据库操作的方法内打开Session，完成后关闭Session，...
**hibernate通用DAO（Data Access Object）**是软件开发中的一个重要概念，它主要用于数据库操作的抽象，使得业务逻辑层可以无需关注具体的SQL语句，从而实现数据访问的解耦。在Java EE应用中，Hibernate作为一款...
在这种情况下，"hibernate不是泛型的通用DAo1"可能提供了一个无需继承的DAO实现。例如，`DynamicDao`可能是一个非泛型接口，它包含了一些基本的CRUD操作，可以直接被任何类实现，而不需要指定特定的实体类型。`...
Java源代码 一个简单的通用DAO实现 （基于hibernate）面向应用层按POJO类缓存hibernate的session对象.使用举例： DAO dao = DAOFactory.getDAO(POJO.class);//获得一个全局类单例的DAO实例 dao.save(pojo); 你也可以...
2. 创建一个`HibernateDAO`类，作为所有实体的通用DAO实现，包含与数据库交互的通用逻辑。 ```java public class HibernateDAO<T> { private SessionFactory sessionFactory; public HibernateDAO...
【标题】"Hibernate泛型Dao"是针对Java开发中的数据持久化框架Hibernate的一个高级应用，主要目的是为了提高代码的复用性和简洁性。在传统的Hibernate使用中，针对每个实体类，我们都需要创建一个对应的Dao（Data ...