1.Customer的映射
<hibernate-mapping package="mypack">
<class name="Customer" table="CUSTOMERS" schema="dbo" catalog="Temp" dynamic-insert="true" dynamic-update="true">
<id name="id"><!-- 主键 -->
<generator class="identity" /><!-- 自动增长? -->
</id>
<property name="name" />
<property name="sex" access="field"/><!-- access="filed"让Hibernate 直接访问sex 而不是调getSex() -->
<!-- 一对多,一个客户有多个订单 -->
<set name="orders" inverse="true" cascade="save-update">
<key column="CUSTOMER_ID"></key>
<one-to-many class="mypack.Order"/>
</set>
<!-- totalPrice是派生属性,运行时才能得到 -->
<property name="totalPrice" formula="(select sum(o.PRICE) from ORDERS o where o.CUSTOMER_ID=ID)"/>
<!-- 如果一个字段中有空格要用''引起来 -->
<property name="description" type="text" column="[CUSTOMER DESCRIPTION]"></property>
</class>
</hibernate-mapping>
2.Order的映射
<hibernate-mapping package="mypack">
<class name="Order" table="ORDERS" schema="dbo" catalog="Temp" dynamic-insert="true" dynamic-update="true">
<id name="id">
<generator class="identity"/>
</id>
<property name="orderNumber" column="ORDER_NUMBER"/>
<property name="price"/>
<!-- 多对一,多个订单可以属于同一个人 -->
<many-to-one
name="customer"
column="CUSTOMER_ID"
class="Customer"
not-null="true"
/>
</class>
</hibernate-mapping>
3.Customer.java
public class Customer implements Serializable {
private Long id;
private String firstname;
private String lastname;
private char sex;
private Set orders=new HashSet();
private double avgPirce;
private double totalPrice;
private String description;//描述
public Customer() {
}
//在构造方法中就进行初史化
public Customer(String firstname,String lastname,char sex,Set orders,String description){
this.firstname=firstname;
this.lastname=lastname;
this.sex=sex;
this.orders=orders;
this.description=description;
}
public double getAvgPirce() {
return avgPirce;
}
public void setAvgPirce(double avgPirce) {
this.avgPirce = avgPirce;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public double getTotalPrice() {
return totalPrice;
}
public void setTotalPrice(double totalPrice) {
this.totalPrice = totalPrice;
}
public String getName(){
return this.firstname+" "+this.lastname;
}
public void setName(String name){
// 将传进来的名字进行分解
StringTokenizer st=new StringTokenizer(name);
this.firstname=st.nextToken();
this.lastname=st.nextToken();
}
public Set getOrders() {
return orders;
}
public void setOrders(Set orders) {
this.orders = orders;
calculatePrice();
}
public void calculatePrice(){
double avgPrice=0.0;
double totalPrice=0.0;
int count=0;
if(getOrders()!=null){
Iterator iter=this.orders.iterator();
while(iter.hasNext()){
double orderPrice=((Order)iter.next()).getPrice();
totalPrice +=orderPrice;
count++;
}
}
avgPrice=totalPrice/count;
this.setAvgPirce(avgPrice);
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
if(sex!='男'&&sex!='女'){
throw new IllegalArgumentException("性别错误!");
}
this.sex = sex;
}
}
4.Order.java
public class Order {
private Long id;
private String orderNumber;
private double price;
private Customer customer;
public Order(){
}
public Order(String orderNumber,double price,Customer customer) {
this.orderNumber=orderNumber;
this.price=price;
this.customer=customer;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getOrderNumber() {
return orderNumber;
}
public void setOrderNumber(String orderNumber) {
this.orderNumber = orderNumber;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
5.测试
public class BusServer {
public static SessionFactory sessionFactory;
static{
try{
Configuration cfg=new Configuration();
sessi.configure().buildSessionFactory();
}catch(Exception ex){
ex.printStackTrace();
}
}
//保存客户信息
public void saveCustomer(Customer customer){
Session session=sessionFactory.openSession();
Transaction tr=null;
try{
tr=session.beginTransaction();
session.save(customer);
tr.commit();
}catch(Exception ex){
if(tr!=null){
tr.rollback();
}
ex.printStackTrace();
}finally{
session.close();
}
}
public static void main(String[]args){
BusServer bus=new BusServer();
Customer customer=new Customer("Laosan","Zhang",'M',new HashSet(),"A good citizen!");
Order order1=new Order("Order001",100,customer);
Order order2=new Order("Order002",200,customer);
customer.getOrders().add(order1);
customer.getOrders().add(order2);
bus.saveCustomer(customer);
//因为配置了表之间的关系,Hibernate会自动将Order1,Order2保存至表中
分享到:
相关推荐
本篇文章将详细讲解"hibernate一对多与多对一"的关系映射概念,以及如何在实际开发中进行配置和使用。 首先,我们来看一下“一对多”关系。在现实世界中,这种关系可以对应到例如一个班级有多个学生,或者一个人...
本项目“hibernate一对多项目”旨在演示如何在JavaWeb应用中使用Hibernate处理一对多的关系映射。这里我们将深入探讨 Hibernate 的一对多关系、配置以及在实际项目中的应用。 首先,一对多关系在数据库中很常见,...
本实例将深入探讨Hibernate中的三种基本关联关系:一对一(One-to-One)、一对多(One-to-Many)以及多对多(Many-to-Many)的实现方式。 1. **一对一关联**: 一对一关联通常出现在两个实体之间存在唯一对应关系...
标题中的“hibernate一对多实例”指的是在Java编程中使用Hibernate框架处理数据库关系时的一对多关联映射。Hibernate是Java领域中的一个流行对象关系映射(ORM)框架,它允许开发者用面向对象的方式操作数据库,从而...
hibernate 一对多和多对一的理解 自己的个人看法 大家也来看看
**标题:“Hibernate双向一对多经典实例”** 在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库操作,使得开发者能够用面向对象的方式处理数据。本实例将聚焦于Hibernate中的一对多关系...
在标准的关系型数据库设计中,一对多关系意味着一个表中的记录可以与另一个表中的多个记录相关联。例如,一个部门可以有多名员工,而每个员工只属于一个部门。在Hibernate中实现这种关系,我们不一定要依赖主键作为...
1. **关联类型:** Hibernate支持四种基本的关联类型,包括一对一(OneToOne)、一对多(OneToMany)、多对一(ManyToOne)和多对多(ManyToMany)。本主题将主要聚焦在一对一和一对多关联。 2. **关联的方向性:**...
在一对多关联中,一个实体可以与多个其他实体相关联。例如,一个部门可以有多个员工,而每个员工只能属于一个部门。在Hibernate中,我们使用`@OneToMany`注解来表示这种关系。同样,关联可以是单向或双向的,可以...
1. 一对多映射(One-to-Many): 在这种关系中,一个实体(父实体)可以与多个其他实体(子实体)相关联。在Hibernate中,我们通常使用`@OneToMany`注解来表示这种关系。例如,一个学生可以有多个课程,而一门课程...
而在“一对多”关系中,一个实体的单个实例可以与多个其他实体实例相关联。Hibernate通过其灵活的映射机制,使得开发者能够轻松地在实体类之间建立这两种关联关系。 ### 实例解析 #### 数据库表结构 本示例中,...
在Java的持久化框架Hibernate中,一对多关系是数据库中常见的关联类型,它表示一个实体可以与多个其他实体相关联。在这个"hibernate 一对多,两个实例项目"中,我们将深入探讨如何在实际开发中应用这种关系,并通过...
1. **一对多关系**: 在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多关系。在Hibernate中,我们使用`@OneToMany`注解来表示这种关系。例如,在`Teacher`类中,我们可以...
这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料,开发者能够深入理解如何在Java应用中利用Hibernate来处理...
标题"Hibernate双向一对多"指的是Hibernate框架中的一个重要关系映射概念,即在一个实体类中,一个实例可以与多个另一个实体类的实例相关联,而在另一个实体类中,每个实例也可以关联到该实体类的一个实例。...
在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系数据库模型映射方式,用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射,并通过实际例子解析相关...
在这个“Struts+Hibernate一对多的管理系统”项目中,我们将深入理解这两个框架如何协同工作,构建出一个具备一对多关系的数据管理应用。在Java Web开发中,一对多关系非常常见,比如在一个用户可以拥有多个订单的...
在本章中,我们将深入探讨Hibernate中的关联映射,包括一对多、多对一以及多对多的关系。这些映射关系对于理解如何在Java应用程序中有效地管理数据库对象至关重要。 首先,我们来解决描述中提到的问题。`...
一、Hibernate一对多关系 在现实世界中,一对多关系很常见,例如一个班级可以有多名学生。在数据库中,这对应于一个表(如班级表)有一条记录可以关联多条记录(如学生表)。在Hibernate中,我们通过配置XML文件来...