Hibernate（六）：映射一对多关联关系、双向一对多映射
2024-05-04 06:18:17
在领域模型中，类与类之间最普通的关系就是关联关系。
在UML中，关联是有方向的：
例如：Customer与Order，一个用户能发出多个订单，而一个订单只能属于一个用户。
- 单向关联
1）从Order到Customer的关联是多对一关联；
定义Customer：
1 package com.dx.hibernate.onetomany;
2
3 public class Customer {
4 private Integer customerId;
5 private String customerName;
6
7 public Customer() {
8 }
9
10 public Customer(String customerName) {
11 super();
12 this.customerName = customerName;
13 }
14
15 public Integer getCustomerId() {
16 return customerId;
17 }
18
19 public void setCustomerId(Integer customerId) {
20 this.customerId = customerId;
21 }
22
23 public String getCustomerName() {
24 return customerName;
25 }
26
27 public void setCustomerName(String customerName) {
28 this.customerName = customerName;
29 }
30 }<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2017-5-24 12:02:56 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping><class name="com.dx.hibernate.onetomany.Customer" table="CUSTOMER"><id name="customerId" type="java.lang.Integer"><column name="CUSTOMER_ID" /><generator class="native" /></id><property name="customerName" type="java.lang.String"><column name="CUSTOMER_NAME" /></property></class> </hibernate-mapping>
定义Order：
package com.dx.hibernate.onetomany;public class Order {private Integer orderId;private String orderName;private Customer customer;public Integer getOrderId() {return orderId;}public void setOrderId(Integer orderId) {this.orderId = orderId;}public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}public Customer getCustomer() {return customer;}public void setCustomer(Customer customer) {this.customer = customer;}
}<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Generated 2017-5-24 12:02:56 by Hibernate Tools 3.5.0.Final --> <hibernate-mapping><class name="com.dx.hibernate.onetomany.Order" table="ORDERS"><id name="orderId" type="java.lang.Integer"><column name="ORDER_ID" /><generator class="assigned" /></id><property name="orderName" type="java.lang.String"><column name="ORDER_NAME" /></property><many-to-one name="customer" class="com.dx.hibernate.onetomany.Customer"><column name="CUSTOMER_ID" /></many-to-one></class> </hibernate-mapping>
初始化项目时，生成sql语句：
Hibernate: create table CUSTOMER (CUSTOMER_ID integer not null auto_increment,CUSTOMER_NAME varchar(255),primary key (CUSTOMER_ID) ) engine=InnoDB Hibernate: create table ORDERS (ORDER_ID integer not null auto_increment,ORDER_NAME varchar(255),CUSTOMER_ID integer,primary key (ORDER_ID) ) engine=InnoDB Hibernate: alter table ORDERS add constraint FKkdbly1ij6f4kqh378kfne6ilx foreign key (CUSTOMER_ID) references CUSTOMER (CUSTOMER_ID)
测试代码1：
package com.dx.hibernate.onetomany;import static org.junit.Assert.fail;import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;public class TestMain {private SessionFactory sessionFactory = null;private Session session = null;private Transaction transaction = null;@Beforepublic void init() {StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder().configure().build();Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE).build();sessionFactory = metadata.getSessionFactoryBuilder().build();session = sessionFactory.getCurrentSession();transaction = session.beginTransaction();}@Testpublic void test() {Customer customer = new Customer("customer1");Order order1 = new Order("order1", customer);Order order2 = new Order("order2", customer);session.save(customer);session.save(order1);session.save(order2);}@Afterpublic void destory() {transaction.commit();session.close();sessionFactory.close();}
}测试执行sql:
Hibernate: insert intoCUSTOMER(CUSTOMER_NAME) values(?) Hibernate: insert intoORDERS(ORDER_NAME, CUSTOMER_ID) values(?, ?) Hibernate: insert intoORDERS(ORDER_NAME, CUSTOMER_ID) values(?, ?)
测试代码2：
@Testpublic void test() {Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName());System.out.println(order.getCustomer().getCustomerName());}测试结果：
测试通过，且查询语句为：
Hibernate: selectorder0_.ORDER_ID as ORDER_ID1_1_0_,order0_.ORDER_NAME as ORDER_NA2_1_0_,order0_.CUSTOMER_ID as CUSTOMER3_1_0_ fromORDERS order0_ whereorder0_.ORDER_ID=? order1 Hibernate: selectcustomer0_.CUSTOMER_ID as CUSTOMER1_0_0_,customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ fromCUSTOMER customer0_ wherecustomer0_.CUSTOMER_ID=? customer1
测试代码3：
@Testpublic void test() {Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName());//System.out.println(order.getCustomer().getCustomerName());
session.close();System.out.println(order.getCustomer().getCustomerName());}测试结果不通过，执行sql语句:
Hibernate: selectorder0_.ORDER_ID as ORDER_ID1_1_0_,order0_.ORDER_NAME as ORDER_NA2_1_0_,order0_.CUSTOMER_ID as CUSTOMER3_1_0_ fromORDERS order0_ whereorder0_.ORDER_ID=? order1
测试4：
修改Order.hbm.xml
<many-to-one name="customer" class="com.dx.hibernate.onetomany.Customer" fetch="join"><column name="CUSTOMER_ID" /></many-to-one>
测试代码：
Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName());System.out.println(order.getCustomer().getCustomerName());
测试通过，打印的sql语句：
Hibernate: selectorder0_.ORDER_ID as ORDER_ID1_1_0_,order0_.ORDER_NAME as ORDER_NA2_1_0_,order0_.CUSTOMER_ID as CUSTOMER3_1_0_,customer1_.CUSTOMER_ID as CUSTOMER1_0_1_,customer1_.CUSTOMER_NAME as CUSTOMER2_0_1_ fromORDERS order0_ left outer joinCUSTOMER customer1_ on order0_.CUSTOMER_ID=customer1_.CUSTOMER_ID whereorder0_.ORDER_ID=?
测试代码5：
修改Order.hbm.xml
<many-to-one name="customer" class="com.dx.hibernate.onetomany.Customer" fetch="join"><column name="CUSTOMER_ID" /></many-to-one>
测试代码：
Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName());System.out.println(order.getCustomer().getCustomerName());session.close();System.out.println(order.getCustomer().getCustomerName());
测试不通过。
2）从Customer到Order的关联是一对多关联。
Order.java
1 package com.dx.hibernate.onetomany;
2
3 public class Order {
4 private Integer orderId;
5 private String orderName;
6
7 public Order() {
8 super();
9 }
10
11 public Order(String orderName) {
12 super();
13 this.orderName = orderName;
14 }
15
16 public Integer getOrderId() {
17 return orderId;
18 }
19
20 public void setOrderId(Integer orderId) {
21 this.orderId = orderId;
22 }
23
24 public String getOrderName() {
25 return orderName;
26 }
27
28 public void setOrderName(String orderName) {
29 this.orderName = orderName;
30 }
31
32 }View Code
Order.hbm.xml
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <!-- Generated 2017-5-25 22:09:21 by Hibernate Tools 3.5.0.Final --> 5 <hibernate-mapping> 6 <class name="com.dx.hibernate.onetomany.Order" table="ORDERS"> 7 <id name="orderId" type="java.lang.Integer"> 8 <column name="ORDER_ID" /> 9 <generator class="native" /> 10 </id> 11 <property name="orderName" type="java.lang.String"> 12 <column name="ORDER_NAME" /> 13 </property> 14 </class> 15 </hibernate-mapping>
View Code
Customer.java
1 package com.dx.hibernate.onetomany;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class Customer {
7 private Integer customerId;
8 private String customerName;
9 private List<Order> orders = new ArrayList<Order>();
10
11 public Customer() {
12 }
13
14 public Customer(String customerName) {
15 super();
16 this.customerName = customerName;
17 }
18
19 public Integer getCustomerId() {
20 return customerId;
21 }
22
23 public void setCustomerId(Integer customerId) {
24 this.customerId = customerId;
25 }
26
27 public String getCustomerName() {
28 return customerName;
29 }
30
31 public void setCustomerName(String customerName) {
32 this.customerName = customerName;
33 }
34
35 public List<Order> getOrders() {
36 return orders;
37 }
38
39 public void setOrders(List<Order> orders) {
40 this.orders = orders;
41 }
42 }View Code
Customer.hbm.xml
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <!-- Generated 2017-5-25 22:09:21 by Hibernate Tools 3.5.0.Final --> 5 <hibernate-mapping> 6 <class name="com.dx.hibernate.onetomany.Customer" table="CUSTOMER"> 7 <id name="customerId" type="java.lang.Integer"> 8 <column name="CUSTOMER_ID" /> 9 <generator class="native" /> 10 </id> 11 <property name="customerName" type="java.lang.String"> 12 <column name="CUSTOMER_NAME" /> 13 </property> 14 <list name="orders" inverse="false" table="ORDERS" lazy="true"> 15 <key> 16 <column name="CUSTOMER_ID" /> 17 </key> 18 <list-index></list-index> 19 <one-to-many class="com.dx.hibernate.onetomany.Order" /> 20 </list> 21 </class> 22 </hibernate-mapping>
TestMain.java
package com.dx.hibernate.onetomany;import static org.junit.Assert.fail;import java.util.List;import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.query.Query;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;public class TestMain {private SessionFactory sessionFactory = null;private Session session = null;private Transaction transaction = null;@Beforepublic void init() {StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder().configure().build();Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE).build();sessionFactory = metadata.getSessionFactoryBuilder().build();session = sessionFactory.getCurrentSession();transaction = session.beginTransaction();}@SuppressWarnings("deprecation")@Testpublic void test() {Order order1 = new Order("order1");Order order2 = new Order("order2");Customer customer = new Customer("customer1");customer.getOrders().add(order1);customer.getOrders().add(order2);session.save(customer);session.save(order1);session.save(order2);Customer customerFetch = (Customer) session.get(Customer.class, 1);System.out.println(customerFetch.getCustomerName());System.out.println(customerFetch.getOrders().size());}@Afterpublic void destory() {transaction.commit();session.close();sessionFactory.close();}
}测试结果：通过，打印信息如下：
INFO: HHH10001501: Connection obtained from JdbcConnectionAccess [org.hibernate.engine.jdbc.env.internal.JdbcEnvironmentInitiator$ConnectionProviderJdbcConnectionAccess@320e400] for (non-JTA) DDL execution was not in auto-commit mode; the Connection 'local transaction' will be committed and the Connection will be set into auto-commit mode. Hibernate: create table CUSTOMER (CUSTOMER_ID integer not null auto_increment,CUSTOMER_NAME varchar(255),primary key (CUSTOMER_ID)) engine=InnoDB Hibernate: create table ORDERS (ORDER_ID integer not null auto_increment,ORDER_NAME varchar(255),CUSTOMER_ID integer,orders_ORDER integer,primary key (ORDER_ID)) engine=InnoDB Hibernate: alter table ORDERS add constraint FKkdbly1ij6f4kqh378kfne6ilx foreign key (CUSTOMER_ID) references CUSTOMER (CUSTOMER_ID) Hibernate: insert intoCUSTOMER(CUSTOMER_NAME) values(?) Hibernate: insert intoORDERS(ORDER_NAME) values(?) Hibernate: insert intoORDERS(ORDER_NAME) values(?) customer1 2 Hibernate: updateORDERS setCUSTOMER_ID=?,orders_ORDER=? whereORDER_ID=? Hibernate: updateORDERS setCUSTOMER_ID=?,orders_ORDER=? whereORDER_ID=?
- 双向关联
Order.java
1 package com.dx.hibernate.onetomany;
2
3 public class Order {
4 private Integer orderId;
5 private String orderName;
6 private Customer customer;
7
8 public Order() {
9 super();
10 }
11
12 public Order(String orderName) {
13 super();
14 this.orderName = orderName;
15 }
16
17 public Integer getOrderId() {
18 return orderId;
19 }
20
21 public void setOrderId(Integer orderId) {
22 this.orderId = orderId;
23 }
24
25 public String getOrderName() {
26 return orderName;
27 }
28
29 public void setOrderName(String orderName) {
30 this.orderName = orderName;
31 }
32
33 public Customer getCustomer() {
34 return customer;
35 }
36
37 public void setCustomer(Customer customer) {
38 this.customer = customer;
39 }
40
41 }View Code
Order.hbm.xml
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <!-- Generated 2017-5-25 22:09:21 by Hibernate Tools 3.5.0.Final --> 5 <hibernate-mapping> 6 <class name="com.dx.hibernate.onetomany.Order" table="ORDERS"> 7 <id name="orderId" type="java.lang.Integer"> 8 <column name="ORDER_ID" /> 9 <generator class="native" /> 10 </id> 11 <property name="orderName" type="java.lang.String"> 12 <column name="ORDER_NAME" /> 13 </property> 14 <many-to-one name="customer" class="com.dx.hibernate.onetomany.Customer" lazy="proxy"> 15 <column name="CUSTOMER_ID"></column> 16 </many-to-one> 17 </class> 18 </hibernate-mapping>
View Code
Customer.java
1 package com.dx.hibernate.onetomany;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class Customer {
7 private Integer customerId;
8 private String customerName;
9 private List<Order> orders = new ArrayList<Order>();
10
11 public Customer() {
12 }
13
14 public Customer(String customerName) {
15 super();
16 this.customerName = customerName;
17 }
18
19 public Integer getCustomerId() {
20 return customerId;
21 }
22
23 public void setCustomerId(Integer customerId) {
24 this.customerId = customerId;
25 }
26
27 public String getCustomerName() {
28 return customerName;
29 }
30
31 public void setCustomerName(String customerName) {
32 this.customerName = customerName;
33 }
34
35 public List<Order> getOrders() {
36 return orders;
37 }
38
39 public void setOrders(List<Order> orders) {
40 this.orders = orders;
41 }
42 }View Code
Customer.hbm.xml
1 <?xml version="1.0"?> 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 4 <!-- Generated 2017-5-25 22:09:21 by Hibernate Tools 3.5.0.Final --> 5 <hibernate-mapping> 6 <class name="com.dx.hibernate.onetomany.Customer" table="CUSTOMER"> 7 <id name="customerId" type="java.lang.Integer"> 8 <column name="CUSTOMER_ID" /> 9 <generator class="native" /> 10 </id> 11 <property name="customerName" type="java.lang.String"> 12 <column name="CUSTOMER_NAME" /> 13 </property> 14 <list name="orders" inverse="false" table="ORDERS" lazy="true"> 15 <key> 16 <column name="CUSTOMER_ID" /> 17 </key> 18 <list-index></list-index> 19 <one-to-many class="com.dx.hibernate.onetomany.Order" /> 20 </list> 21 </class> 22 </hibernate-mapping>
View Code
测试1
1 package com.dx.hibernate.onetomany;
2
3 import static org.junit.Assert.fail;
4
5 import java.util.List;
6
7 import org.hibernate.Session;
8 import org.hibernate.SessionFactory;
9 import org.hibernate.Transaction;
10 import org.hibernate.boot.Metadata;
11 import org.hibernate.boot.MetadataSources;
12 import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
13 import org.hibernate.boot.registry.StandardServiceRegistry;
14 import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
15 import org.hibernate.query.Query;
16 import org.junit.After;
17 import org.junit.Before;
18 import org.junit.Test;
19
20 public class TestMain {
21 private SessionFactory sessionFactory = null;
22 private Session session = null;
23 private Transaction transaction = null;
24
25 @Before
26 public void init() {
27 StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder().configure().build();
28 Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().applyImplicitNamingStrategy(ImplicitNamingStrategyComponentPathImpl.INSTANCE).build();
29
30 sessionFactory = metadata.getSessionFactoryBuilder().build();
31 session = sessionFactory.getCurrentSession();
32 transaction = session.beginTransaction();
33 }
34
35 @SuppressWarnings("deprecation")
36 @Test
37 public void test() {
38 Order order1 = new Order("order1");
39 Order order2 = new Order("order2");
40 Customer customer = new Customer("customer1");
41 customer.getOrders().add(order1);
42 customer.getOrders().add(order2);
43
44 session.save(customer);
45 session.save(order1);
46 session.save(order2);
47
48 Customer customerFetch = (Customer) session.get(Customer.class, 1);
49
50 System.out.println(customerFetch.getCustomerName());
51 System.out.println(customerFetch.getOrders().size());
52
53 }
54
55 @After
56 public void destory() {
57 transaction.commit();
58 session.close();
59 sessionFactory.close();
60 }
61 }View Code
测试打印信息：
Hibernate: create table CUSTOMER (CUSTOMER_ID integer not null auto_increment,CUSTOMER_NAME varchar(255),primary key (CUSTOMER_ID)) engine=InnoDB Hibernate: create table ORDERS (ORDER_ID integer not null auto_increment,ORDER_NAME varchar(255),CUSTOMER_ID integer,orders_ORDER integer,primary key (ORDER_ID)) engine=InnoDB Hibernate: alter table ORDERS add constraint FKkdbly1ij6f4kqh378kfne6ilx foreign key (CUSTOMER_ID) references CUSTOMER (CUSTOMER_ID) Hibernate: insert intoCUSTOMER(CUSTOMER_NAME) values(?) Hibernate: insert intoORDERS(ORDER_NAME, CUSTOMER_ID) values(?, ?) Hibernate: insert intoORDERS(ORDER_NAME, CUSTOMER_ID) values(?, ?) customer1 2 Hibernate: updateORDERS setCUSTOMER_ID=?,orders_ORDER=? whereORDER_ID=? Hibernate: updateORDERS setCUSTOMER_ID=?,orders_ORDER=? whereORDER_ID=?
测试2：
@Testpublic void testUpdate(){Customer customerFetch = (Customer) session.get(Customer.class, 1);customerFetch.getOrders().listIterator().next().setOrderName("ABC");}测试输出：
Hibernate: selectcustomer0_.CUSTOMER_ID as CUSTOMER1_0_0_,customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ fromCUSTOMER customer0_ wherecustomer0_.CUSTOMER_ID=? Hibernate: selectorders0_.CUSTOMER_ID as CUSTOMER3_1_0_,orders0_.ORDER_ID as ORDER_ID1_1_0_,orders0_.orders_ORDER as orders_O4_0_,orders0_.ORDER_ID as ORDER_ID1_1_1_,orders0_.ORDER_NAME as ORDER_NA2_1_1_,orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ fromORDERS orders0_ whereorders0_.CUSTOMER_ID=? Hibernate: updateORDERS setORDER_NAME=?,CUSTOMER_ID=? whereORDER_ID=?
测试3：
@Testpublic void testRemove() {Customer customerFetch = (Customer) session.get(Customer.class, 2);Order order = customerFetch.getOrders().listIterator().next();session.remove(order);}测试输出：
Hibernate: selectcustomer0_.CUSTOMER_ID as CUSTOMER1_0_0_,customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ fromCUSTOMER customer0_ wherecustomer0_.CUSTOMER_ID=? Hibernate: selectorders0_.CUSTOMER_ID as CUSTOMER3_1_0_,orders0_.ORDER_ID as ORDER_ID1_1_0_,orders0_.orders_ORDER as orders_O4_0_,orders0_.ORDER_ID as ORDER_ID1_1_1_,orders0_.ORDER_NAME as ORDER_NA2_1_1_,orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ fromORDERS orders0_ whereorders0_.CUSTOMER_ID=? Hibernate: delete fromORDERS whereORDER_ID=?
转载于:https://www.cnblogs.com/yy3b2007com/p/6898489.html
Hibernate（六）：映射一对多关联关系、双向一对多映射相关推荐
- （转）Hibernate框架基础——一对多关联关系映射
http://blog.csdn.net/yerenyuan_pku/article/details/52746413 上一篇文章Hibernate框架基础--映射集合属性详细讲解的是值类型的集合(即 ...
- （转）Hibernate关联映射——一对多（多对一）
http://blog.csdn.net/yerenyuan_pku/article/details/70152173 Hibernate关联映射--一对多(多对一) 我们以客户(Customer)与 ...
- java 中映射关系_java – 在Hibernate中映射一对多的关系？
我有两个表,一个用户表和一个user_avatar表.对于每个用户,user_avatar表中有3条记录,适用于3种大小的头像(大,中,小). user_avatar表具有userId列,该列引用Us ...
- （八）Hibernate的一对多关联关系
一.概述 例如,以客户(Customer)和订单(Order)为例,一个客户能有多个订单,一个订单只能有一个客户. 从Customer到Order是一对多关联,在java类中的面向对象设计应该一个Cu ...
- hibernate映射一对多双向关联关系实例
在电子商务应用中,经常会有这样的需求:根据给定的客户,得到该客户的所有订单:根据给定的订单,得到该订单的所属客户.对于这种双向关联的情况,在Hibernate应用中,也有人叫多对一双向关联,只是叫法不 ...
- Hibernate的一对多关联关系（单向和双向）
在领域模型中,类与类之间最普遍的关系就是关联关系.在 UML 中,关联是有方向的.以 Customer 和 Order 为例:一个用户能发出多个订单, 而一个订单只能属于一个客户.从 Order 到 ...
- hibernate 的一对多关联关系映射配置
hibernate 是操作实体类: 表是一对多的关系,当创建这2个实体的时候 在一的一方定义一个多的一方的集合 在多的一方定义一个一的一方的对象 表是多对多的关系,当创建这2个实体的时候 在互相中都有 ...
- Hibernate关联映射（一对多/多对多）
版权声明:翀版 https://blog.csdn.net/biggerchong/article/details/84340105 3. Hibernate关联映射 上接Hibernate持久化类 ...
- hibernate映射-单向n-n关联关系
(学习记录,错误不足之处,请您耐心指正^_^) hibernate映射-多对多关联关系 n-n关联必须使用连接表才能完成, 一.代码示例: {类文件↓} Category.class 1 packag ...
- hibernate注释映射_Hibernate一对多映射示例注释
hibernate注释映射 Today we will look into One To Many Mapping in Hibernate. We will look into Hibernate ...
最新文章
- WCF服务一：WCF服务简介
- 拿transformer做E2E全景分割，这个通用框架霸榜挑战赛，南大、港大联合提出
- Laravel+Angularjs+D3打造可视化数据,RESTful+Ajax
- JavaScript 原型继承
- new Date(2019-05-10 08:00:00) 格式在IE内核或者低版本浏览器中显示NaN或者Invalid Date的问题...
- html背景图片压缩显示,css背景图片在浏览器缩小时为什么下面出现了白色的
- caffe源码分析:blob.hpp分析
- 【Laravel-海贼王系列】第十三章，路由控制器解析
- SSH详解以及免密登录配置，深入理解
- ajax each 多级联动,jQuery多级联动效果
- 内存管理, 对象的生命周期
- Kotlin 新版来了，支持跨平台！
- 0x02 如何安装【XPS 查看器】？超简单哦！
- android xml 设置半透明
- 批量删除新浪微博及自动发布微博
- 同一个无线局域网（wifi）内，两台电脑无法通过ip通信
- 了解云桌面，看这一篇文章就够了
- java linux 字体设置_linux下面java字体的设置
- 【Cesium】根据两点坐标获取Heading(朝向)，Pitch(俯仰角)和模型矩阵
- mac如何升级node版本
热门文章
- pandas.iloc, pandas.loc用法
- php upload 缓存_thinkphp Upload上传文件在客户端生成的临时文件$_FILES['file']['tmp_name']...
- Try using .loc[row_indexer,col_indexer] = value instead
- 机器学习---分类、回归、聚类、降维的区别
- Machine Learning Basics（要点）
- Caffe学习：使用pycaffe定义网络
- Ubuntu[16.04/18.04/20.04] arm 下修改本地源 sources.list 为国内镜像
- 如何开发神经网络来预测汽车保险支出
- python resize重置大小
- 2021-06-27循环控制 mapSet