- 浏览: 205886 次
- 性别:
- 来自: 南京
文章分类
最新评论
-
dracularking:
ActionSupport就是个template
struts2 中 Actionsupport 的作用 -
编程的石头:
问题已经解决,谢谢!不过为何这样就可以了呢?直接用Struts ...
关于struts+extjs上传 弹出下载对话框问题 -
ninnd:
CREATE OR REPLACE TYPE ptest_ty ...
在Oracle中把Array类型作为参数传入存储过程 -
mornjn57:
LZ记录很全
<s:property>1 -
yulongxiang:
...
Hibernate 关联映射总结
弄了几天,终于做出Hibernate的第一个关联保存的例子出来了,还跑去广州购书中心看了一个下午的书,
还是感谢网友的帮助,让我弄懂了inverse和cascade这两个属性的使用。
package com.test.ORM;
import java.util.Set;
public class Student {
private int sid ;
private String sname ;
private String sage ;
private Set book;//用来接收、获取Book的对应一端中的<set name="就是这个名字">
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSage() {
return sage;
}
public void setSage(String sage) {
this.sage = sage;
}
public Set getBook() {
return book;
}
public void setBook(Set book) {
this.book = book;
}
}
<?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">
<hibernate-mapping>
<class name="com.test.ORM.Student" table="student">
<id name="sid" type="int" >
<column name="sid" not-null="true"/>
<generator class="increment"/>
</id>
<property name="sname" type="string">
<column name="sname" not-null="true"/>
</property>
<property name="sage" type="string">
<column name="sage" not-null="true"/>
</property>
<set name="book" table="book" inverse="false" cascade="all">//最重点的地方,inverse="false"表示双向关联,也就是关系由两端来控制.cascade="all"就是关联的级别,还有all就是说无论是一方所有的操作(sava、update、delete等)当然也有其他值的。另一方也跟这对应的改变。
<key column="sid" />
<one-to-many class="com.test.ORM.Book" />
</set>
</class>
</hibernate-mapping>
package com.test.ORM;
public class Book {
private int bid ;
private String bname ;
private String bprice ;
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public int getBid() {
return bid;
}
public void setBid(int bid) {
this.bid = bid;
}
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
public String getBprice() {
return bprice;
}
public void setBprice(String bprice) {
this.bprice = bprice;
}
}
<?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">
<hibernate-mapping>
<class name="com.test.ORM.Book" table="book">
<id name="bid" type="integer">
<column name="bid" not-null="true" />
<generator class="increment"/>
</id>
<property name="bname">
<column name="bname" sql-type="varchar(16)" not-null="true"/>
</property>
<property name="bprice">
<column name="bprice" sql-type="varchar(16)" not-null="true"/>
</property>
<many-to-one name="student" class="com.test.ORM.Student" fetch="select">//用来介绍一方中的students,呵呵,对应Book类中的private Student student;
<column name="sid" not-null="true"/>
</many-to-one>
</class>
</hibernate-mapping>
package com.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.test.ORM.Book;
import com.test.ORM.Student;
public class TestOneToMany {
/**
* @param 测试类
*/
public static void main(String[] args)throws Exception {
SessionFactory sf;
Session session;
Configuration config=new Configuration();
config.configure();
sf=config.buildSessionFactory();
session=sf.openSession();
Transaction ts=session.beginTransaction();
//new 两个对象,只要保存student,book就会自动保存了
Student student=new Student();
student.setSname("student2");
student.setSage("sage2");
Book book=new Book();
book.setBname("bname2");
book.setBprice("bprice2");
book.setStudent(student);
Set bookSet=new HashSet();
bookSet.add(book);
student.setBook(bookSet);
session.save(student);
ts.commit();
session.flush();
session.close();
}
}
要具体了解hibernate 还是去看下hibernate 的保存机制吧,包括OID,事务管理什么的
错误解析:
package com.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.test.ORM.Book;
import com.test.ORM.Student;
public class TestOneToMany {
/**
* @param 测试类
*/
public static void main(String[] args)throws Exception {
SessionFactory sf;
Session session;
Configuration config=new Configuration();
config.configure();
sf=config.buildSessionFactory();
session=sf.openSession();
Transaction ts=session.beginTransaction();
Student student=new Student();
student.setSname("student3");
student.setSage("sage3");
Book book=new Book();
Set bookSet=new HashSet();
for(int i=0;i<2;i++){
book.setBname("bname"+(2+i));
book.setBprice("bprice"+(2+i));
bookSet.add(book);
System.out.println(i);
}
student.setBook(bookSet);
session.save(student);
ts.commit();
session.flush();
session.close();
}
}
//Hibernate: select max(sid) from student
//Hibernate: select max(bid) from book
//Hibernate: insert into student (sname, sage, sid) values (?, ?, ?)
//Hibernate: insert into book (bname, bprice, sid, bid) values (?, ?, ?, ?)
//Hibernate: update book set sid=? where bid=?
//先插入student,然后插入book,再更新book中的sid,但如果你的sid不能为空not-null="true"的话,那么在插入book的时候就会出现异常了
还是感谢网友的帮助,让我弄懂了inverse和cascade这两个属性的使用。
package com.test.ORM;
import java.util.Set;
public class Student {
private int sid ;
private String sname ;
private String sage ;
private Set book;//用来接收、获取Book的对应一端中的<set name="就是这个名字">
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getSage() {
return sage;
}
public void setSage(String sage) {
this.sage = sage;
}
public Set getBook() {
return book;
}
public void setBook(Set book) {
this.book = book;
}
}
<?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">
<hibernate-mapping>
<class name="com.test.ORM.Student" table="student">
<id name="sid" type="int" >
<column name="sid" not-null="true"/>
<generator class="increment"/>
</id>
<property name="sname" type="string">
<column name="sname" not-null="true"/>
</property>
<property name="sage" type="string">
<column name="sage" not-null="true"/>
</property>
<set name="book" table="book" inverse="false" cascade="all">//最重点的地方,inverse="false"表示双向关联,也就是关系由两端来控制.cascade="all"就是关联的级别,还有all就是说无论是一方所有的操作(sava、update、delete等)当然也有其他值的。另一方也跟这对应的改变。
<key column="sid" />
<one-to-many class="com.test.ORM.Book" />
</set>
</class>
</hibernate-mapping>
package com.test.ORM;
public class Book {
private int bid ;
private String bname ;
private String bprice ;
private Student student;
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public int getBid() {
return bid;
}
public void setBid(int bid) {
this.bid = bid;
}
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
public String getBprice() {
return bprice;
}
public void setBprice(String bprice) {
this.bprice = bprice;
}
}
<?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">
<hibernate-mapping>
<class name="com.test.ORM.Book" table="book">
<id name="bid" type="integer">
<column name="bid" not-null="true" />
<generator class="increment"/>
</id>
<property name="bname">
<column name="bname" sql-type="varchar(16)" not-null="true"/>
</property>
<property name="bprice">
<column name="bprice" sql-type="varchar(16)" not-null="true"/>
</property>
<many-to-one name="student" class="com.test.ORM.Student" fetch="select">//用来介绍一方中的students,呵呵,对应Book类中的private Student student;
<column name="sid" not-null="true"/>
</many-to-one>
</class>
</hibernate-mapping>
package com.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.test.ORM.Book;
import com.test.ORM.Student;
public class TestOneToMany {
/**
* @param 测试类
*/
public static void main(String[] args)throws Exception {
SessionFactory sf;
Session session;
Configuration config=new Configuration();
config.configure();
sf=config.buildSessionFactory();
session=sf.openSession();
Transaction ts=session.beginTransaction();
//new 两个对象,只要保存student,book就会自动保存了
Student student=new Student();
student.setSname("student2");
student.setSage("sage2");
Book book=new Book();
book.setBname("bname2");
book.setBprice("bprice2");
book.setStudent(student);
Set bookSet=new HashSet();
bookSet.add(book);
student.setBook(bookSet);
session.save(student);
ts.commit();
session.flush();
session.close();
}
}
要具体了解hibernate 还是去看下hibernate 的保存机制吧,包括OID,事务管理什么的
错误解析:
package com.test;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.test.ORM.Book;
import com.test.ORM.Student;
public class TestOneToMany {
/**
* @param 测试类
*/
public static void main(String[] args)throws Exception {
SessionFactory sf;
Session session;
Configuration config=new Configuration();
config.configure();
sf=config.buildSessionFactory();
session=sf.openSession();
Transaction ts=session.beginTransaction();
Student student=new Student();
student.setSname("student3");
student.setSage("sage3");
Book book=new Book();
Set bookSet=new HashSet();
for(int i=0;i<2;i++){
book.setBname("bname"+(2+i));
book.setBprice("bprice"+(2+i));
bookSet.add(book);
System.out.println(i);
}
student.setBook(bookSet);
session.save(student);
ts.commit();
session.flush();
session.close();
}
}
//Hibernate: select max(sid) from student
//Hibernate: select max(bid) from book
//Hibernate: insert into student (sname, sage, sid) values (?, ?, ?)
//Hibernate: insert into book (bname, bprice, sid, bid) values (?, ?, ?, ?)
//Hibernate: update book set sid=? where bid=?
//先插入student,然后插入book,再更新book中的sid,但如果你的sid不能为空not-null="true"的话,那么在插入book的时候就会出现异常了
发表评论
-
hibernate的一级缓存和二级缓存
2016-08-01 13:33 393http://www.open-open.com/lib/vi ... -
函数Demo
2012-12-07 10:10 917函数写法: create or replace functio ... -
存储过程Demo
2012-12-07 10:08 984存储过程写法: create or replace proce ... -
java调用oracle有返回值的函数
2012-11-13 17:00 2602create or replace function myfu ... -
Hibernate的二级缓存和一级缓存有什么区别?
2012-11-02 10:06 1381在向大家详细介绍Hiber ... -
有关Hibernate延时加载与lazy机制
2012-11-02 10:00 874有关Hibernate延时加载与lazy机制 ... -
Hibernate n+1问题
2012-11-02 09:54 599Hibernate n+1问题 在S ... -
Statement和PrepareStatement有什么区别?
2012-11-02 09:36 2269Statement和PrepareStatement有什么区别 ... -
对Blob对象的处理
2010-07-21 14:26 1068//保存图片 public boolean savePh ... -
在Hibernate中实现Oracle的自动增长默认分类
2010-07-01 09:57 1396在Hibernate中实现Oracle的自动增长默认分类 ... -
HibernateDaoSupport类
2009-09-22 16:58 1212HibernateDaoSupport类(org.spring ... -
HQL
2009-09-17 10:06 14011. 查询整个映射对象所 ... -
hibernateTemplate的findByNamedQuery方法的使用
2009-09-16 16:41 3713hibernateTemplate 是 spring 提供吧, ... -
Hibernate 关联映射总结
2009-09-16 09:41 4374关联映射的本质: * 将关联关系映射到数据库,所谓的关 ... -
Hibernate中get( )和load( )的区别
2009-09-15 15:03 930get()和load()都用于查询,区别是: (1)get ... -
持久化对象的状态
2009-09-09 22:19 975瞬时对象(Translent Objects): 使用new操 ... -
HIbernate主键生成策略
2009-09-08 22:25 2098先来看看主键映射的标签: <id (1)name= ...
相关推荐
在实体类之间,Hibernate支持多种关联关系,包括一对一(One-to-One)、一对多(One-to-Many)和多对多(Many-to-Many)。本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,...
在Java的持久化框架Hibernate中,一对一(OneToOne)关系是一种常见的对象关系映射(ORM)配置,用于表示两个实体类之间的一种唯一关联。在这个场景中,“hibernate使用主键关联的一对一关系”指的是通过共享主键来...
在数据库设计中,这种关联关系是常见的,例如一个用户可以有多个订单(一对多),一个订单对应一个用户(多对一),而一个商品可以被多个订单购买,同时一个订单也可以包含多个商品(一对多双向关联)。这个标题暗示...
在Java的持久化框架Hibernate中,一对多关联映射是一种常见的关系映射方式,它用于表示一个实体(如用户)可以拥有多个关联实体(如订单)。在这个场景中,"一"通常代表父实体,"多"代表子实体。这篇博客文章...
在Java的持久化框架Hibernate中,一对一(One-to-One)关联映射是一种常见的关系数据库模型映射方式。这种关联通常发生在两个实体之间,且每个实体都只有一个对应的实例。本篇文章将详细探讨双向一对一主键关联映射...
### Hibernate映射一对多关联关系 #### 知识点概览 - **概念解析**:一对多(One-to-Many)关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**:创建具有一个实体与多个实体关联的域模型。 - **关系...
在Java的持久化框架Hibernate中,多对一(ManyToOne)关联关系是一种常见的对象关系映射(ORM)场景。这种关系通常出现在一个实体类拥有多条与另一个实体类相关的记录,而另一个实体类可能只有一条对应的记录。例如...
3. **级联保存**:在保存一个多对一关联时,我们通常需要确保双方都已存在。如果一方不存在,Hibernate会抛出异常。因此,保存操作通常需要先创建或加载一方实体,然后将多方实体的引用赋值给它,最后保存多方实体。...
在Java的持久化框架Hibernate中,一对多关系是常见的实体关联类型,特别是在处理数据库中的表与表之间的关联时。在这个“Hibernate一对多双向自身关联demo代码”中,我们将深入理解如何实现一个实体类与其自身进行一...
【标题】:“Hibernate多对一关联demo” 在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库操作。本教程将详细解释如何在Hibernate中实现多对一的关联关系,以及如何通过一个实际的示例...
本主题聚焦于“Hibernate双向一对一关联映射”的注解实现,这是一种高级的数据库设计模式,用于处理两个实体之间一对一的关系。 在Hibernate中,一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...
在Java的持久化框架Hibernate中,双向一对多关联映射是一种常见的关系映射方式,它模拟了数据库中的外键关联,使得一个实体可以拥有多个另一个实体的实例。在这个注解版的实现中,我们将深入探讨如何使用Hibernate的...
总结来说,Hibernate的一对多和多对一关联是数据库实体间关系映射的关键部分,它们提供了强大的工具来处理复杂的数据库交互。多对多关系和双向关联进一步扩展了这一功能,让数据管理更加灵活。在实际开发中,根据...
本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先,一对多关系在数据库中很常见,...
本文将深入探讨“Hibernate自身关联一对多实例(树形结构)”这一主题,这在构建具有层次结构的数据模型时尤其常见,例如组织结构、地区树或者商品分类等。 首先,我们需要理解Hibernate的核心概念。Hibernate允许...
本文将深入探讨如何使用Hibernate实现一对多的关联关系,并通过源代码实例进行详细解析,帮助初学者更好地理解和掌握这一核心概念。 在数据库中,一对多关联意味着一个表中的记录可以与另一个表中的多个记录相关联...
“Hibernate基于外键的一对多单向关联”这个标题指的是在Java持久化框架Hibernate中,如何通过外键实现一个实体类(如订单)与另一个实体类(如商品)之间的一对多关系,并且这种关联是单向的,即从订单端可以访问到...
### Hibernate关联关系(一对多) #### 一、概念与背景 在软件开发中,尤其是在数据库设计及ORM(对象关系映射)技术的应用中,“一对多”关系是非常常见的一种数据关联方式。例如,一个班级可以拥有多个学生,但每...
在Hibernate中,一对一的主键关联关系可以通过以下几种方式配置: 1. **注解配置**: 使用`@OneToOne`注解来声明一对一关系,同时通过`@PrimaryKeyJoinColumn`注解指定共享的主键列。例如: ```java @Entity ...