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

最新推荐文章于 2023-07-07 11:09:44 发布
最新推荐文章于 2023-07-07 11:09:44 发布
阅读量522 收藏
点赞数
分类专栏： 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) 中，一对一双向关联是一种关系映射，它允许两个实体类之间存在一对一的关系，并且每个实体都能引用对方。这种关联是双向的，意味着每个实体都可以通过自己的属性访问到另一个实体。...
Spring data jpa sort多属性排序问题
qq_34321710的博客
03-21 7841
在spring data for jpa 中，存在一个pageable接口，是对查询分页的一个利器。 pageable实现类的构造方法中有个Sort参数，可以按照列属性进行排序。通过查看Sort类的构造方法，我们对Sort这个类进行一下分析，Sort类中存在一下几个构造方法： 1.public Sort(Order… orders); 2.public Sort(List orders); 3.p...
JPA unidirection Relation Mapping(JPA关联映射)
月朔归汐
01-04 493
JPA关联映射分为：        单向关联：单向1-1、单向1-N、单向N-1、单向N-N；        双向关联：双向1-1、双向1-N、双向N-N；   一、单向关联： 单向1-1（unidirection 1-1） 应用场景：假设一个人仅对应一个地址，一个地址也仅对应一个人；实体定义：实体定义：Person:代表人实体； Address：代表地址实体；
对于JPA中实体类mappedBy的映射
最新发布
qq_56043285的博客
07-07 702
属性的值应该是关联关系的拥有方（拥有外键的一方）在对方实体类中关联字段的名称。它用于指定关联关系的反向端（非拥有方）是如何映射到数据库表结构的。注解时，拥有方（关系的拥有者）负责维护外键，并在数据库表中创建相应的列，而反向端（非拥有方）使用。通过以上步骤，你可以创建一个班级实体并将其与学生实体建立关联。由多的一方（也就是学生类）来维护他们的关系。另外，如果要实现级联删除、级联更新等操作，可以通过设置不同的。级联操作，保存班级实体时，相关的学生实体也会被保存。需要注意的是，上述代码中使用的是。
JPA 条件 排序 分页 查询
殇之何伤的博客
02-27 1175
Sort sort = new Sort(Sort.Direction.ASC, "id"); Pageable pageable = new PageRequest(0, 1, sort); List<RongProductSort> rongProductSortList=this.productSortRepository.findById(id...
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));
jpa的实体映射关系7种
02-23
JPA 提供了多种映射关系，使得开发者能够方便地处理不同类型的关联。下面我们将详细探讨标题中提到的七种映射关系： 1. **单向一对一**： 在这种关系中，一个实体只有一个对应实体与之关联，且只在一个方向上有...
JPA中的一对多双向关联与级联操作
04-05
在Java Persistence API (JPA) 中，一对多关联是一种常见的关系映射，它表示一个实体可以与多个其他实体相关联。这种关联在数据库层面通常通过外键实现，而在JPA中，我们通过注解来配置这种关系。这篇博客将深入探讨...
使用jpa映射关联和继承
05-06
**一、JPA关联映射** 1. **一对一（OneToOne）映射**：一个实体对象对应数据库中的一个记录。通过`@OneToOne`注解来实现，可以是单向或双向。`@JoinColumn`用于指定外键所在的字段，`@MapsId`则表明关联对象的主键...
JPA中的多对多双向关联实体定义与注解设置
04-05
在这个主题中，我们将深入探讨如何在JPA中定义和配置双向多对多关联实体，并通过注解进行设置。 首先，我们需要了解JPA中的几个关键注解： 1. `@Entity`：标记一个类作为JPA的实体类，使得该类可以被JPA管理并映射...
Jpa分页查询按照时间倒序排列做法以及Sort、PageRequest的方法更新
qq_42289085的博客
08-02 8142
1. 具体业务描述：以下代码块为查一个订单列表并且按照最近时间优先先查出来 @CrossOrigin @GetMapping() public ModelAndView list(@RequestParam(value = "page",defaultValue = "1") Integer page, @RequestPa...
Spring Hibernate JPA 联表查询 复杂查询
weixin_30360497的博客
07-02 1614
今天刷网，才发现： 1）如果想用hibernate注解，是不是一定会用到jpa的？ 是。如果hibernate认为jpa的注解够用，就直接用。否则会弄一个自己的出来作为补充。 2）jpa和hibernate都提供了Entity，我们应该用哪个，还是说可以两个一起用？ Hibernate的Entity是继承了jpa的，所以如果觉得jpa的不够用，直接使用hibernate的即可 正...
spring-data-jpa
热门推荐
既认准这条路，又何必在意要走多久
06-23 2万+
spring-data-jpa
Spring Data Jpa: 分页和排序
R28_11的专栏
03-29 1万+
之前我们学习了如何使用Jpa访问关系型数据库。通过Jpa大大简化了我们对数据库的开发工作。但是，之前的例子中我们只提到了最简单的CRUD（增删改查）操作。实际上，Spring Data Jpa对于分页以及排序的查询也有着完美的支持，接下来，我们来学习如何通过Pageable来对数据库进行分页查询。 添加maven依赖 首先我们需要引入Jpa，数据库直接使用hsqldb内存数据库就可
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查询方法
hy1255564202的博客
05-07 2735
JPA默认查询方法 findOne(id):查询指定id的数据 List findAll()：查询对应实体的所有数据 List findAll(Sort sort)：带排序的查询 Sort(Direction.DESC,String properties)，Direction指定排序方式，properties指定排序的字段 Sort(Direction direction, List pro...
jpa级联添加,在JPA级联的一个问题
weixin_39559382的博客
01-27 73
I have two entities called User and UserProfile in my datamodel. Here is how they are mapped.Code from User Entity:@OneToOne(cascade=CascadeType.ALL)@PrimaryKeyJoinColumnpublic UserProfile getUserProf...
关于jpa的mappedBy用法
coderping的博客
12-26 2493
mappedBy reference an unknown target entity property 对于这种错误，因为映射关系处理错误 @Entity @Table(name = "source_data") public class SourceData implements Serializable { /** * 对应table的信息 */ ...
Hibernate与Jpa的关系
你的爱是我走不出的银河！
09-10 893
我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
JPA关联映射与二级缓存实战
本章主要探讨了四种关联映射类型：多对一、一对多（单向和双向）、一对一以及多对多（双向），并且涵盖了JPA的二级缓存使用。 1. **多对一单向关联**： 这种关联映射通常表示为多个实例（"多"）关联到一个实例（...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值