上篇写了一对一,那么在这篇我们讲一对多,那么在表中的一对多,是使用外键关联,通过一张表的一个键另一个表的外键来建立一多关系;
而在类中表示为一个类中有一个集合属性包含对方类的很多对象,而在另一个类中,只包含前术类的一个对象,从而实现一对多关系的建立!
而在Hibernate中采用的是Set类型集合,而使用<one-to-many>主<many-to-one>来实现,好了,我们来看一下:
首先看看表结构!
customer表:
create
table
customers
(
ID bigint not null primary key auto_increment,
userName varchar ( 20 )
);
(
ID bigint not null primary key auto_increment,
userName varchar ( 20 )
);
Order表:
create
table
orders
(
ID bigint not null primary key auto_increment,
customers_ID bigint , -- 应该为customers(ID)外键
orderDescription varchar ( 50 ) -- 订单描述
);
(
ID bigint not null primary key auto_increment,
customers_ID bigint , -- 应该为customers(ID)外键
orderDescription varchar ( 50 ) -- 订单描述
);
有了上面简单的客户表与订单表,来建立一个Project!~并且添加Hibernate~并由上面二张表生成Beans,主键都是native类型~自动递增!
我们将 自动生成的Customer.java Bean添加一个SET属性,代码如下:
Customers.java
package fengyan.Hibernate;
import java.util.HashSet;
import java.util.Set;
/** */ /**
*Authod: fengyan
* date: 2006-12-30 01:02
*/
public class Customers implements java.io.Serializable {
// Fields
private Long id;
private String userName;
// 必须定义一个Set集合类型的属性以及它的get和set方法,
// 它持有一个Customers对象所发出的所有订单的引用
private Set orders = new HashSet();
// Constructors
public Set getOrders() {
return orders;
}
public void setOrders(Set orders) {
this .orders = orders;
}
/** */ /** default constructor */
public Customers() {
}
/** */ /** full constructor */
public Customers(String userName) {
this .userName = userName;
}
// Property accessors
public Long getId() {
return this .id;
}
public void setId(Long id) {
this .id = id;
}
public String getUserName() {
return this .userName;
}
public void setUserName(String userName) {
this .userName = userName;
}
}
package fengyan.Hibernate;
import java.util.HashSet;
import java.util.Set;
/** */ /**
*Authod: fengyan
* date: 2006-12-30 01:02
*/
public class Customers implements java.io.Serializable {
// Fields
private Long id;
private String userName;
// 必须定义一个Set集合类型的属性以及它的get和set方法,
// 它持有一个Customers对象所发出的所有订单的引用
private Set orders = new HashSet();
// Constructors
public Set getOrders() {
return orders;
}
public void setOrders(Set orders) {
this .orders = orders;
}
/** */ /** default constructor */
public Customers() {
}
/** */ /** full constructor */
public Customers(String userName) {
this .userName = userName;
}
// Property accessors
public Long getId() {
return this .id;
}
public void setId(Long id) {
this .id = id;
}
public String getUserName() {
return this .userName;
}
public void setUserName(String userName) {
this .userName = userName;
}
}
为Order.java Bean 去掉cid(CustomerID)并添加一个Customer属性,代码如下:
Orders.java
package fengyan.Hibernate;
/** */ /**
*Authod: fengyan
* date: 2006-12-30 01:02
*/
public class Orders implements java.io.Serializable {
// Fields
private Long id;
// private Long customersId;
private String orderDescription;
// 添加一个Customers属性,用来引用一个订单对象所属的客户对象
private Customers customer;
// Constructors
public Customers getCustomer() {
return customer;
}
public void setCustomer(Customers customer) {
this .customer = customer;
}
/** */ /** default constructor */
public Orders() {
}
public Orders(String description)
{
this .orderDescription = description;
}
// Property accessors
public Long getId() {
return this .id;
}
public void setId(Long id) {
this .id = id;
}
public String getOrderDescription() {
return this .orderDescription;
}
public void setOrderDescription(String orderDescription) {
this .orderDescription = orderDescription;
}
}
package fengyan.Hibernate;
/** */ /**
*Authod: fengyan
* date: 2006-12-30 01:02
*/
public class Orders implements java.io.Serializable {
// Fields
private Long id;
// private Long customersId;
private String orderDescription;
// 添加一个Customers属性,用来引用一个订单对象所属的客户对象
private Customers customer;
// Constructors
public Customers getCustomer() {
return customer;
}
public void setCustomer(Customers customer) {
this .customer = customer;
}
/** */ /** default constructor */
public Orders() {
}
public Orders(String description)
{
this .orderDescription = description;
}
// Property accessors
public Long getId() {
return this .id;
}
public void setId(Long id) {
this .id = id;
}
public String getOrderDescription() {
return this .orderDescription;
}
public void setOrderDescription(String orderDescription) {
this .orderDescription = orderDescription;
}
}
修改Customer.hbm.xml映射文件:
<?
xml version="1.0" encoding="GBK"
?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
< class name ="fengyan.Hibernate.Customers" table ="customers" catalog ="study" >
< id name ="id" type ="java.lang.Long" >
< column name ="ID" />
< generator class ="native" />
</ id >
< property name ="userName" type ="java.lang.String" >
< column name ="userName" length ="20" />
</ property >
<!-- name集合属性orders
table对应的表名
cascade 级联关系,当保存或更新时会级联保存与这个Customers对象相关联的所有Orders对象
inverse=true是将 控权抛出(给Orders) -->
< set name ="orders" table ="orders" cascade ="save-update" inverse ="true" >
< key column ="customers_ID" ></ key > <!-- 表字段 -->
< one-to-many class ="fengyan.Hibernate.Orders" /> <!-- 关联的类 -->
</ set >
</ class >
</ hibernate-mapping >
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
< class name ="fengyan.Hibernate.Customers" table ="customers" catalog ="study" >
< id name ="id" type ="java.lang.Long" >
< column name ="ID" />
< generator class ="native" />
</ id >
< property name ="userName" type ="java.lang.String" >
< column name ="userName" length ="20" />
</ property >
<!-- name集合属性orders
table对应的表名
cascade 级联关系,当保存或更新时会级联保存与这个Customers对象相关联的所有Orders对象
inverse=true是将 控权抛出(给Orders) -->
< set name ="orders" table ="orders" cascade ="save-update" inverse ="true" >
< key column ="customers_ID" ></ key > <!-- 表字段 -->
< one-to-many class ="fengyan.Hibernate.Orders" /> <!-- 关联的类 -->
</ set >
</ class >
</ hibernate-mapping >
修改Order.hbm.xml,内容如下:
<?
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 ="fengyan.Hibernate.Orders" table ="orders" catalog ="study" >
< id name ="id" type ="java.lang.Long" >
< column name ="ID" />
< generator class ="native" />
</ id >
< property name ="orderDescription" type ="java.lang.String" >
< column name ="orderDescription" length ="50" />
</ property >
<!-- name属性名
class对应的类
column对应的表字段 -->
< many-to-one name ="customer" class ="fengyan.Hibernate.Customers" column ="customers_ID" ></ many-to-one >
</ class >
</ hibernate-mapping >
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
< class name ="fengyan.Hibernate.Orders" table ="orders" catalog ="study" >
< id name ="id" type ="java.lang.Long" >
< column name ="ID" />
< generator class ="native" />
</ id >
< property name ="orderDescription" type ="java.lang.String" >
< column name ="orderDescription" length ="50" />
</ property >
<!-- name属性名
class对应的类
column对应的表字段 -->
< many-to-one name ="customer" class ="fengyan.Hibernate.Customers" column ="customers_ID" ></ many-to-one >
</ class >
</ hibernate-mapping >
然后我们建立一个CustomersDAO操作类
package
fengyan.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class CustomersDAO {
public void save(Customers customer)
{
Session session = HibernateSessionFactory.getSession(); // 会话
try
{
Transaction tx = session.beginTransaction(); // 事物
session.save(customer); // 保存
tx.commit(); // 提交事物
}
catch (Exception e)
{
System.out.println( " DAO has Errors: " + e);
}
finally
{
session.close(); // 关闭会话
}
}
}
import org.hibernate.Session;
import org.hibernate.Transaction;
public class CustomersDAO {
public void save(Customers customer)
{
Session session = HibernateSessionFactory.getSession(); // 会话
try
{
Transaction tx = session.beginTransaction(); // 事物
session.save(customer); // 保存
tx.commit(); // 提交事物
}
catch (Exception e)
{
System.out.println( " DAO has Errors: " + e);
}
finally
{
session.close(); // 关闭会话
}
}
}
再来建立一个Servlet MyServlet.java代码如下:
package
fengyan.Hibernate;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyServlet c
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyServlet c
发表评论
-
Hibernate框架核心组件
2011-06-03 21:27 751在Hibernate框架简述 中,演示了一个简单的Hib ... -
Hibernate 表关系描述之ManyToMany
2011-06-03 21:24 794上篇写了一对一,那么在这篇我们讲一对多,那么在表中的一对 ... -
Hibernate 表关系描述之OneToOne
2011-06-03 21:21 999在数据库领域中,数据表和数据表之间关系一般可以分为如下几种: ... -
Hibernate数据查询
2011-06-03 21:20 717Hibernate Query Language(HQL) C ...
相关推荐
标题中的"onetomany-hibernate"指的是Hibernate框架中的一对多关系映射,这是一种数据库表之间的关联类型。在Java的Hibernate框架中,这种映射允许一个实体(类)与多个其他实体之间建立联系,比如一个学生可以有多...
4. **关系映射**:注解如`@ManyToOne`, `@OneToMany`, `@OneToOne`, `@ManyToMany`等,它们在实体类的属性上声明,描述实体间的关联关系。 **标签解析** "源码"和"工具"这两个标签暗示了讨论可能涉及实际代码示例...
由于没有具体的描述内容,我们只能推测这个博客涵盖了关于Hibernate的使用,以及在实际项目中如何实施OneToMany关系的实践指导。 标签“源码”表明该压缩包可能包含了示例代码,这些代码可以用于演示如何在Java项目...
除了继承关系,描述中还提到了Hibernate的关联映射,这是另一个核心概念: - **一对一(One-to-One)映射**:一个实体与另一个实体有唯一的关系,例如一个人只有一个身份证。可以使用`@OneToOne`注解实现,可以是...
在Java开发领域,Hibernate是一个非常流行的Object-Relational Mapping(ORM)框架,它允许开发者将Java对象映射到关系数据库的表中,从而简化了数据库操作。本话题将深入探讨如何利用Hibernate配置E-R(实体-关系)...
一对多关联是指在数据库中,一个表的记录可以与另一个表中的多个记录相关联,这种关系在Hibernate中通过`@OneToMany`注解来表示。例如,一个用户可以有多个订单,那么用户实体(User)与订单实体(Order)之间就存在...
Hibernate Annotation是一套用于声明式地配置Java持久化对象与数据库表之间映射关系的注解API,它属于Hibernate框架的一部分。在处理一对多关系时,Hibernate Annotation提供了便捷的方式来表达实体之间的关联。本文...
“Hibernate ORM - 一对多双向连接表关联关系”这个标题指出我们要讨论的是Hibernate ORM框架中的一种特定数据库关联模型,即一对多的双向关联。在Hibernate中,ORM(对象关系映射)是一种技术,它允许我们用面向...
Hibernate 3中的注解机制使得开发者能够更直观地在Java类中描述数据库模型,减少了XML配置文件的使用,提升了开发效率。通过熟练掌握这些注解,开发者可以更好地运用Hibernate进行数据持久化操作,实现高效、灵活的...
Hibernate关系映射是Java开发中一种重要的对象关系映射(ORM)技术,它允许开发者用面向对象的方式处理数据库操作,极大地提高了开发效率。本篇将深入探讨Hibernate关系映射的核心概念、配置和常见实践,以帮助你更...
Hibernate提供了不同的集合映射方式,如@OneToMany、@ManyToOne、@ManyToMany等,用于描述这些关系。 5. **Hibernate_Component**:这部分可能包含了Hibernate组件映射的示例。组件是对象的一部分,可以被嵌入到...
以下是关于“Hibernate关系映射”的详细解释。 1. 一对一关系映射: Hibernate支持一对一(One-to-One)关系映射,这种关系通常存在于具有唯一性的关联表中。通过在实体类中使用`@OneToOne`注解,我们可以定义一对...
通过以上描述,我们可以看到Struts2、Hibernate和Spring在多表操作中的协同工作,使得开发者可以更加专注于业务逻辑,而不是底层的数据库操作。理解并熟练掌握这三大框架的集成,对于Java Web开发人员来说至关重要。
【描述】提到的链接是一个CSDN博客文章,详细介绍了某个Hibernate关系映射的实例。根据描述,我们可以推测这个教程可能涉及了如何通过Hibernate配置和代码实现数据库表之间的关联,例如一对一、一对多、多对一或多对...
【标题】与【描述】提及的是“Hibernate面试题专栏”,主要涵盖了全面的Hibernate面试题、笔试题以及相关问题,这表明我们将要讨论的是Java领域中著名的对象关系映射框架——Hibernate的相关知识。Hibernate是一个...
在处理这样的关系时,Hibernate提供了多种映射策略,例如使用`@OneToMany`和`@ManyToOne`注解。在"一"端的实体类中,我们可以定义一个集合属性,并用`@OneToMany`注解标记,指定目标实体类和关联字段。在"多"端的...
在Hibernate中,这种关系可以通过`@OneToMany`注解实现。例如,User类可能会有如下注解: ```java @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; ...
3. **注解映射**:实体类中的属性通过注解与数据库字段对应,例如`@Entity`表示这是一个实体类,`@Id`标识主键,`@ManyToOne`或`@OneToMany`用于描述多对一或一对多的关系。 4. **映射文件**:如果不想使用注解,...
描述中的"包括一对一 一对多 和多对多"提到了Hibernate中三种常见的关联关系映射。一对一(One-to-One)、一对多(One-to-Many)和多对多(Many-to-Many)是实体间的关系类型,它们在数据库设计中广泛存在,并且...
描述中的“Hibernate期末作业之连接表(一对多/多对一)”进一步指出,不仅会涉及一对多的关系,还可能包含多对一的关联。多对一关系是与一对多关系相反的情况,即多个实体可以关联到一个单一的实体。在实际的数据库...