JPA bidirection Relation Mapping(JPA双向关联映射)

最新推荐文章于 2023-07-07 11:09:44 发布
最新推荐文章于 2023-07-07 11:09:44 发布
阅读量529 收藏
点赞数
分类专栏： JPA 文章标签： jpa string generator class sun table
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhchjian/article/details/7182234
版权

一、bidirection Relation Mapping (1-1)

  • 应用场景：假设一个人仅有一个地址，一个地址也仅有一个人；
  • 实体类定义：Person:代表人实体； Address：代表地址实体。

        Address实体定义：

@Entity
@Table(name = "rm_address")
public class Address {
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "addressPKGen")
	@SequenceGenerator(name = "addressPKGen", sequenceName = "ADDRESS_PK_GEN", allocationSize = 1)
	@Column(name = "address_id", length = 11)
	private int addressId;

	@Column(length = 512)
	private String detail;

	@OneToOne(targetEntity = Person.class, cascade = CascadeType.ALL, fetch = FetchType.LAZY, optional = false, mappedBy = "address")
	private Person person;

	public Address() {

	}

	public Address(String detail) {
		this.detail = detail;
	}

	public Address(int addressId, String detail) {
		super();
		this.addressId = addressId;
		this.detail = detail;
	}

	public int getAddressId() {
		return addressId;
	}

	public void setAddressId(int addressId) {
		this.addressId = addressId;
	}

	public String getDetail() {
		return detail;
	}

	public void setDetail(String detail) {
		this.detail = detail;
	}

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}
}

        Person实体定义：

@Entity
@Table(name = "rm_person")
public class Person {

	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "personPKGen")
	@SequenceGenerator(name = "personPKGen", sequenceName = "PERSON_PK_GEN", allocationSize = 1)
	@Column(name = "person_id", length = 11)
	private int personId;

	@Column(length = 256)
	private String name;

	@Column(length = 11)
	private int age;

	@OneToOne(targetEntity = Address.class, cascade = CascadeType.ALL, fetch = FetchType.LAZY, optional=false)
	@JoinColumn(name="address_id", nullable=false)
	private Address address;

	public Person() {

	}

	public int getPersonId() {
		return personId;
	}

	public void setPersonId(int personId) {
		this.personId = personId;
	}

	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;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}
}

        在上面的实体定义中，Address和Person都有对方的引用，在Person实体中控制关联关系。在Address实体的person属性中，只采用@OneToOne修饰，并增加了MappedBy="address"，说明Address不控制关联关系； 在Person实体的address属性中，采用了@OneToOne 和 @JoinColumn来修饰该属性。

        测试代码：

public class Test {

	private static final EntityManagerFactory emf = Persistence
			.createEntityManagerFactory("qs");

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		EntityManager em = emf.createEntityManager();
		
		try{
			em.getTransaction().begin();
			
			Person sun = new Person();
			sun.setName("孙悟空");
			sun.setAge(500);
			sun.setAddress(new Address("花果山福地，水帘洞洞天"));
			
			em.persist(sun);
			
			Person zhu = new Person();
			zhu.setName("猪八戒");
			zhu.setAge(380);
			zhu.setAddress(new Address("高老庄"));
			
			em.persist(zhu);
			
			em.getTransaction().commit();
			
		}finally{
			em.close();
		}
	}
}

 

二、bidirection Relation Mapping (1-N  or N-1)  

  • 应用场景：假设一个人对应多个地址，一个地址只对应一个人；
  • 实体类定义：Person:代表人实体； Address：代表地址实体。

        Person实体定义：

@Entity
@Table(name = "rm_person")
public class Person {

	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "personPKGen")
	@SequenceGenerator(name = "personPKGen", sequenceName = "PERSON_PK_GEN", allocationSize = 1)
	@Column(name = "person_id", length = 11)
	private int personId;

	@Column(length = 256)
	private String name;

	@Column(length = 11)
	private int age;

	@OneToMany(targetEntity=Address.class, cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="person")
	private Set<Address> addresses = new HashSet<Address>();

	public Person() {

	}

	public int getPersonId() {
		return personId;
	}

	public void setPersonId(int personId) {
		this.personId = personId;
	}

	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;
	}

	public Set<Address> getAddresses() {
		return addresses;
	}

	public void setAddresses(Set<Address> addresses) {
		this.addresses = addresses;
	}
}


        Address实体的定义：

@Entity
@Table(name = "rm_address")
public class Address {
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "addressPKGen")
	@SequenceGenerator(name = "addressPKGen", sequenceName = "ADDRESS_PK_GEN", allocationSize = 1)
	@Column(name = "address_id", length = 11)
	private int addressId;

	@Column(length = 512)
	private String detail;

	@ManyToOne(targetEntity = Person.class, cascade = CascadeType.ALL, fetch = FetchType.LAZY, optional = false)
	@JoinColumn(name="person_id", nullable=false)
	private Person person;

	public Address() {

	}

	public Address(String detail) {
		this.detail = detail;
	}

	public Address(int addressId, String detail) {
		super();
		this.addressId = addressId;
		this.detail = detail;
	}

	public int getAddressId() {
		return addressId;
	}

	public void setAddressId(int addressId) {
		this.addressId = addressId;
	}

	public String getDetail() {
		return detail;
	}

	public void setDetail(String detail) {
		this.detail = detail;
	}

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}
}

       在上面的实体定义中，Address和Person都有对方的引用，在多的一端Address实体中控制关联关系。在Address实体的person属性中，只采用@ManyToOne和@JoinColumn修饰； 在Person实体的address属性中，采用了@OneToMany修饰该属性，并制定了MappedBy="person"，说明Person实体不控制关联关系。

测试代码：

public class Test {

	private static final EntityManagerFactory emf = Persistence
			.createEntityManagerFactory("qs");

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		EntityManager em = emf.createEntityManager();
		
		try{
			
			Address  address =	em.find(Address.class, 1);
			
			System.out.println("addressDetail: " + address.getDetail());
		
			System.out.println("PersonId: " + address.getPerson().getPersonId());
			System.out.println("PersonName: " + address.getPerson().getName());
			System.out.println("PersonAge: " + address.getPerson().getAge());
			
			/*em.getTransaction().begin();
			
			Person sun = new Person();
			sun.setName("孙悟空");
			sun.setAge(500);

			Address mountain = new Address("花果山福地，水帘洞洞天");
			Address load = new Address("取经之路");
			
			mountain.setPerson(sun);
			load.setPerson(sun);
			
			em.persist(mountain);
			em.persist(load);
			
			em.getTransaction().commit();*/
			
		}finally{
			em.close();
		}
	}
}


 

三、bidirection Relation Mapping (N-N)

  • 应用场景：假设一个人对应多个地址，一个地址也对应多个人；
  • 实体类定义：Person:代表人实体； Address：代表地址实体。

         Address实体定义：

@Entity
@Table(name = "rm_address")
public class Address {
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "addressPKGen")
	@SequenceGenerator(name = "addressPKGen", sequenceName = "ADDRESS_PK_GEN", allocationSize = 1)
	@Column(name = "address_id", length = 11)
	private int addressId;

	@Column(length = 512)
	private String detail;

	@ManyToMany(targetEntity=Person.class, cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="addresses")
	private Set<Person> persons = new HashSet<Person>();

	public Address() {

	}

	public Address(String detail) {
		this.detail = detail;
	}

	public Address(int addressId, String detail) {
		super();
		this.addressId = addressId;
		this.detail = detail;
	}

	public int getAddressId() {
		return addressId;
	}

	public void setAddressId(int addressId) {
		this.addressId = addressId;
	}

	public String getDetail() {
		return detail;
	}

	public void setDetail(String detail) {
		this.detail = detail;
	}

	public Set<Person> getPersons() {
		return persons;
	}

	public void setPersons(Set<Person> persons) {
		this.persons = persons;
	}

}

Person实体定义：

@Entity
@Table(name = "rm_person")
public class Person {

	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "personPKGen")
	@SequenceGenerator(name = "personPKGen", sequenceName = "PERSON_PK_GEN", allocationSize = 1)
	@Column(name = "person_id", length = 11)
	private int personId;

	@Column(length = 256)
	private String name;

	@Column(length = 11)
	private int age;

	@ManyToMany(targetEntity=Address.class, cascade=CascadeType.ALL, fetch=FetchType.LAZY)
	@JoinTable(
			name="rm_person2address", 
			joinColumns=@JoinColumn(name="person_id", nullable=false), 
			inverseJoinColumns=@JoinColumn(name="address_id", nullable=false))
	private Set<Address> addresses = new HashSet<Address>();

	public Person() {

	}

	public int getPersonId() {
		return personId;
	}

	public void setPersonId(int personId) {
		this.personId = personId;
	}

	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;
	}

	public Set<Address> getAddresses() {
		return addresses;
	}

	public void setAddresses(Set<Address> addresses) {
		this.addresses = addresses;
	}
}


上面2个实体中，都采用了@ManyToOne修饰，并在Person实体中采用了@JoinTable修饰，有Person端控制关联关系。

 

测试代码：

public class Test {

	private static final EntityManagerFactory emf = Persistence
			.createEntityManagerFactory("qs");

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		EntityManager em = emf.createEntityManager();
		
		try{
			em.getTransaction().begin();
			
			Address load = new Address("取经之路");
			
			Person sun = new Person();
			sun.setName("孙悟空");
			sun.setAge(500);
			sun.getAddresses().add(load);
			sun.getAddresses().add(new Address("花果山福地，水帘洞洞天"));

			Person zhu = new Person();
			zhu.setName("猪八戒");
			zhu.setAge(380);
			zhu.getAddresses().add(load);
			zhu.getAddresses().add(new Address("高老山"));
		
			em.persist(sun);
			em.persist(zhu);
			
			em.getTransaction().commit();
			
		}finally{
			em.close();
		}
		

	}

}

zhchjian
关注
专栏目录
JPA中的一对多双向关联与级联操作
04-05
在Java Persistence API (JPA) 中，一对多关联是一种常见的关系映射，它表示一个实体可以与多个其他实体相关联。这种关联在数据库层面通常通过外键实现，而在JPA中，我们通过注解来配置这种关系。这篇博客将深入探讨...
JPA中的多对多双向关联实体定义与注解设置
04-05
在这个主题中，我们将深入探讨如何在JPA中定义和配置双向多对多关联实体，并通过注解进行设置。 首先，我们需要了解JPA中的几个关键注解： 1. `@Entity`：标记一个类作为JPA的实体类，使得该类可以被JPA管理并映射...
JPA relations
i5g4nn的博客
05-15 446
JPA relations
JPA unidirection Relation Mapping(JPA关联映射)
月朔归汐
01-04 503
JPA关联映射分为：        单向关联：单向1-1、单向1-N、单向N-1、单向N-N；        双向关联：双向1-1、双向1-N、双向N-N；   一、单向关联： 单向1-1（unidirection 1-1） 应用场景：假设一个人仅对应一个地址，一个地址也仅对应一个人；实体定义：实体定义：Person:代表人实体； Address：代表地址实体；
hibernate JPA 双向多对多   bi-directional many-to-many association
weixin_33889665的博客
07-24 70
学生课程双向多对多: Subject.java//关系集合@ManyToMany(targetEntity=Student.class)@JoinTable(name="STUDENT_SUBJECT",joinColumns=@JoinColumn(name="SUBJECT_ID",referencedColumnName="ID"),inverseJoinColumn...
JPA单项多对一关联关系
u014268482的博客
07-02 427
多对一即n多1关系。 在从表中与主表有外键关系的列的get方法上添加@ManyToOne注解后，该属性则表示为外键，该外键关系为其属性类型对应的类型。用JoinColumn注解设置外键的列名。 示例代码如下: 主表实体代码: @Table(name="USER") @Entity public class User { private Integer id; priva...
JPA：mappedby与joincolmun
CSDNSTJ的专栏
10-15 1618
a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性，ManyToOne不存在该属性；  b) mappedBy标签一定是定义在the owned side(被拥有方的)，他指向the owning side(拥有方)； c) mappedBy的含义，应该理解为，拥有方能够自动维护 跟被拥有方的关系；     当然，如果从被拥有方，通过手工强行来维护
JPA中的一对一双向关联
04-05
在Java Persistence API (JPA) 中，一对一双向关联是一种关系映射，它允许两个实体类之间存在一对一的关系，并且每个实体都能引用对方。这种关联是双向的，意味着每个实体都可以通过自己的属性访问到另一个实体。...
13_jpa多对多双向关联实体定义与注解
03-25
"13_传智播客JPA详解"系列教程涵盖了JPA的诸多方面，而"13_传智播客JPA详解_JPA中的多对多双向关联实体定义与注解设置"这一部分则专门聚焦于多对多关联的实践。 在关系型数据库中，多对多关联是最为复杂的一种关系...
12_传智播客JPA详解_JPA中的一对一双向关联
03-25
本讲解将深入探讨JPA中的一对一双向关联特性，帮助开发者更好地理解和应用这一功能。 一对一双向关联是指在两个实体类之间存在一对一的关系，并且双方都能直接访问对方。这种关联关系在现实世界的例子中很常见，...
持久化API（JPA）系列(六)实体关系映射(ORM)之映射类型
chestnut
04-30 1482
ORM（Object-Relation-Map），其中Object表示实体Bean，Relation表示数据表，Map表示实体Bean与数据表的映射。 由于EJB3中的实体Bean采用JPA框架，因此这里的ORM就是指JPA映射。它的作用也类似于Hibernate、iBATIS、JDO、TopLink等持久化层框架中的实体关系映射。
对于JPA中实体类mappedBy的映射
最新发布
qq_56043285的博客
07-07 742
属性的值应该是关联关系的拥有方（拥有外键的一方）在对方实体类中关联字段的名称。它用于指定关联关系的反向端（非拥有方）是如何映射到数据库表结构的。注解时，拥有方（关系的拥有者）负责维护外键，并在数据库表中创建相应的列，而反向端（非拥有方）使用。通过以上步骤，你可以创建一个班级实体并将其与学生实体建立关联。由多的一方（也就是学生类）来维护他们的关系。另外，如果要实现级联删除、级联更新等操作，可以通过设置不同的。级联操作，保存班级实体时，相关的学生实体也会被保存。需要注意的是，上述代码中使用的是。
Spring data jpa sort多属性排序问题
qq_34321710的博客
03-21 7874
在spring data for jpa 中，存在一个pageable接口，是对查询分页的一个利器。 pageable实现类的构造方法中有个Sort参数，可以按照列属性进行排序。通过查看Sort类的构造方法，我们对Sort这个类进行一下分析，Sort类中存在一下几个构造方法： 1.public Sort(Order… orders); 2.public Sort(List orders); 3.p...
Spring Data Jpa: 分页和排序
R28_11的专栏
03-29 1万+
之前我们学习了如何使用Jpa访问关系型数据库。通过Jpa大大简化了我们对数据库的开发工作。但是，之前的例子中我们只提到了最简单的CRUD（增删改查）操作。实际上，Spring Data Jpa对于分页以及排序的查询也有着完美的支持，接下来，我们来学习如何通过Pageable来对数据库进行分页查询。 添加maven依赖 首先我们需要引入Jpa，数据库直接使用hsqldb内存数据库就可
JPA 条件 排序 分页 查询
殇之何伤的博客
02-27 1192
Sort sort = new Sort(Sort.Direction.ASC, "id"); Pageable pageable = new PageRequest(0, 1, sort); List<RongProductSort> rongProductSortList=this.productSortRepository.findById(id...
JPA查询方法
hy1255564202的博客
05-07 2793
JPA默认查询方法 findOne(id):查询指定id的数据 List findAll()：查询对应实体的所有数据 List findAll(Sort sort)：带排序的查询 Sort(Direction.DESC,String properties)，Direction指定排序方式，properties指定排序的字段 Sort(Direction direction, List pro...
Springboot 使用JPA对数据进行排序 new Sort(new Sort.Order(Sort.Direction.DESC, "id"))过期处理方法
john_1023的博客
05-24 1万+
可以使用 Sort.by() 进行先排序，再分页 Sort.Order order=new Sort.Order(Sort.Direction.DESC, "id"); PageRequest request = PageRequest.of(page-1,size,Sort.by(order));
spring-data-jpa
热门推荐
既认准这条路，又何必在意要走多久
06-23 2万+
spring-data-jpa
Springboot 之 使用JPA对数据进行排序
知识林www.zslin.com
10-21 2万+
本文章来自【知识林】在网站系统的开发过程中经常会用到排序操作，下面就我个人的理解介绍一下使用强大的JPA是如何进行排序的。基础搭建 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1
JPA关联映射与二级缓存实战
本章主要探讨了四种关联映射类型：多对一、一对多（单向和双向）、一对一以及多对多（双向），并且涵盖了JPA的二级缓存使用。 1. **多对一单向关联**： 这种关联映射通常表示为多个实例（"多"）关联到一个实例（...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值