1.hibernate多对一单向关系映射（外键永远会加在多的一方）
package yingjun.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
private int id;
private String name;
private int age;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package yingjun.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class Dream {
private int dreamid;
private String dream;
private Person person;
@Id
@GeneratedValue
public int getDreamid() {
return dreamid;
}
public void setDreamid(int dreamid) {
this.dreamid = dreamid;
}
public String getDream() {
return dream;
}
public void setDream(String dream) {
this.dream = dream;
}
public void setPerson(Person person) {
this.person = person;
}
@ManyToOne //建立多对一联系
@JoinColumn(name="personid")
public Person getPerson() {
return person;
}
}
create table Dream (
dreamid integer not null auto_increment,
dream varchar(255),
personid integer,
primary key (dreamid)
)
create table Person (
id integer not null auto_increment,
age integer not null,
name varchar(255),
primary key (id)
)
alter table Dream
add index FK3F397E3E07A4B5E (personid),
add constraint FK3F397E3E07A4B5E
foreign key (personid)
references Person (id)
2.hibernate一对多单向关系映射（外键永远会加在多的一方）
package yingjun.model;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
@Entity
public class Person {
private int id;
private String name;
private int age;
private Set<Dream> dream=new HashSet<Dream>();
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@OneToMany
@JoinColumn(name="personid")//要加这个字段 不然会用多对多的方式生产3张表
public Set<Dream> getDream() {
return dream;
}
public void setDream(Set<Dream> dream) {
this.dream = dream;
}
}
package yingjun.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class Dream {
private int dreamid;
private String dream;
@Id
@GeneratedValue
public int getDreamid() {
return dreamid;
}
public void setDreamid(int dreamid) {
this.dreamid = dreamid;
}
public String getDream() {
return dream;
}
public void setDream(String dream) {
this.dream = dream;
}
}
create table Dream (
dreamid integer not null auto_increment,
dream varchar(255),
personid integer,
primary key (dreamid)
)
create table Person (
id integer not null auto_increment,
age integer not null,
name varchar(255),
primary key (id)
)
alter table Dream
add index FK3F397E3E07A4B5E (personid),
add constraint FK3F397E3E07A4B5E
foreign key (personid)
references Person (id)
3.hibernate多对一（一对多）双向关系映射
package yingjun.model;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
@Entity
public class Person {
private int id;
private String name;
private int age;
private Set<Dream> dream=new HashSet<Dream>();
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@OneToMany(mappedBy="person") //mappedBy要加在One这方
public Set<Dream> getDream() {
return dream;
}
public void setDream(Set<Dream> dream) {
this.dream = dream;
}
}
package yingjun.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
@Entity
public class Dream {
private int dreamid;
private String dream;
private Person person;
@Id
@GeneratedValue
public int getDreamid() {
return dreamid;
}
public void setDreamid(int dreamid) {
this.dreamid = dreamid;
}
public String getDream() {
return dream;
}
public void setDream(String dream) {
this.dream = dream;
}
@ManyToOne
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
create table Dream (
dreamid integer not null auto_increment,
dream varchar(255),
person_id integer,
primary key (dreamid)
)
create table Person (
id integer not null auto_increment,
age integer not null,
name varchar(255),
primary key (id)
)
alter table Dream
add index FK3F397E3F8EABE73 (person_id),
add constraint FK3F397E3F8EABE73
foreign key (person_id)
references Person (id)
相关推荐
在Hibernate中，一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有另一个实体的引用，而双向一对一映射则意味着两个实体都可以互相引用。这种关联关系在数据库层面通常通过主键外键约束来实现，但...
在本章中，我们将深入探讨Hibernate中的关联映射，包括一对多、多对一以及多对多的关系。这些映射关系对于理解如何在Java应用程序中有效地管理数据库对象至关重要。 首先，我们来解决描述中提到的问题。`...
总结起来，Hibernate的单向多对多映射通过XML配置文件定义了实体之间的关系，使得在Java代码中处理数据库的多对多关联变得更加简单和直观。理解和熟练掌握这一映射方式，对于提升Java持久层开发的效率和质量至关重要...
包含《多对多双向关联映射》《多对一单向关联映射》《多对一双向关联映射》《一对多单向关联映射》等文档，并有图解及例子，非常适合新手学习，尤其是刚刚接触hibernate，对映射关系不清楚的。。。。
总结，一对多单向和双向映射是ORM框架中处理数据库关系的重要方式，它们各有优缺点，需要根据实际需求和项目规模来选择合适的设计。理解并熟练运用这些映射技术，对于提升Java应用程序的数据操作效率和代码质量具有...
“Hibernate 一对多，多对一，一对多双向关联”是指在Java持久化框架Hibernate中，实体间常见的三种关联关系。在数据库设计中，这种关联关系是常见的，例如一个用户可以有多个订单（一对多），一个订单对应一个用户...
Hibernate一对一关联概述 一对一关联分为两种类型：共享主键关联（Primary Key Join）和唯一外键关联（Unique Foreign Key Join）。在本例中，我们讨论的是后者，即通过一个独立的外键字段在两个表之间建立一对一...
在本文中，我们将详细介绍Hibernate一对一唯一外键关联映射的概念、配置方法和实践应用。 一对一唯一外键关联映射的概念 在Hibernate中，一对一唯一外键关联映射是指两个实体之间的关联关系，其中一个实体作为外键...
本篇文章将深入探讨Hibernate中注解的一对多、多对多和一对一关系映射。 ### 一对多关系 在现实生活中，例如一个班级有一个班主任，而班主任可以管理多个学生，这就是典型的“一对多”关系。在Hibernate中，我们...
综上所述，Hibernate提供了丰富的关联关系映射机制，包括一对一、一对多和多对多关联，每种关联又可以细分为单向和双向，以及基于主键和基于外键的不同实现方式。正确理解和选择合适的关联关系对于构建高效、可维护...
通过以上内容，我们对Hibernate中的一对多单向关联映射有了全面的理解，包括其配置方式、代码实现、使用技巧以及需要注意的细节。在实际项目开发中，正确理解和运用这些知识能够有效地提升数据操作的效率和代码的可...
总的来说，这篇博客和相关代码示例为开发者提供了一个理解和实现Hibernate中多对多单向关联的起点，帮助他们更好地处理复杂的数据库关系映射。学习和实践这部分内容对于提升Java后端开发能力，特别是使用Hibernate...
##### 单向一对多关联映射 在这种映射中，我们只在“一”方维护关联列表。例如，一个班级类（`Class`）可以维护一个学生列表（`List<Student>`），但学生类（`Student`）不持有班级的引用。 ```java public class ...
在探讨“Hibernate一对多双向”这一主题时，我们首先需要理解Hibernate框架以及它在Java开发中的重要性。Hibernate是一个开放源代码的对象关系映射（ORM）框架，它为Java应用程序提供了一种将对象模型与数据库模型相...
本篇文章将详细讲解"hibernate一对多与多对一"的关系映射概念，以及如何在实际开发中进行配置和使用。 首先，我们来看一下“一对多”关系。在现实世界中，这种关系可以对应到例如一个班级有多个学生，或者一个人...
本文旨在深入探讨Hibernate中的实体关联关系映射技术，主要包括一对一、一对多、多对多等不同类型的关联关系及其在实际开发中的应用技巧。通过本文的学习，开发者可以更好地理解和掌握Hibernate框架下的实体关联关系...