五、hibernate表與表之間的關係（一對多關係）

阿新 • • 發佈：2018-12-24

資料庫表與表之間的關係

一對多：一個學校可以有多個學生，一個學生只能有一個學校

多對多：一個學生可以有多個老師，一個老師可以教多個學生

一對一：一個人只能有一個身份證號，一個身份證號只能找到一個人

一對多關係

建立學生和學校表

create table school(
	sch_id int PRIMARY KEY auto_increment ,
	sch_name VARCHAR(30),
	sch_address VARCHAR(200)
);

create table student(
	sid int PRIMARY KEY auto_increment,
	s_sch int ,
	sname VARCHAR(30),
	FOREIGN KEY(s_sch) REFERENCES school(sch_id)
);

根據表建立實體類和對映檔案

一的一方

School.java

 1 package com.qf.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class School {
 7     private long sch_id;
 8     private String sch_name;
 9     private String sch_address;
10     //一個學校有多個學生，應該是一對多關係中多的一方的集合，hibernate預設使用set集合 

11     private Set<Student> stus = new HashSet<Student>();
12     
13     //get、set方法
14     public long getSch_id() {
15         return sch_id;
16     }
17     public void setSch_id(long sch_id) {
18         this.sch_id = sch_id;
19     }
20     public String getSch_name() {
21 
         return sch_name;
22     }
23     public void setSch_name(String sch_name) {
24         this.sch_name = sch_name;
25     }
26     public String getSch_address() {
27         return sch_address;
28     }
29     public void setSch_address(String sch_address) {
30         this.sch_address = sch_address;
31     }
32     public Set<Student> getStus() {
33         return stus;
34     }
35     public void setStus(Set<Student> stus) {
36         this.stus = stus;
37     }
38     
39     @Override
40     public String toString() {
41         return "School [sch_id=" + sch_id + ", sch_name=" + sch_name + ", sch_address=" + sch_address + ", stus=" + stus
42                 + "]";
43     }
44     public School() {
45         super();
46     }
47     
48 }

View Code

School.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 配置表與實體的對映關係 -->
	<class name="com.qf.entity.School" table="school">
		<id name="sch_id" column="sch_id">
			<!-- 主鍵生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="sch_name" column="sch_name"/>
		<property name="sch_address" column="sch_address"/>
		
		<!-- name:多的一方的集合屬性的名稱 -->
		<set name="stus"  >
			<!-- column:多的一方表的外來鍵名稱-->
			<key column="s_sch"></key>
			<!-- class:多的一方的類的全路徑 -->
			<one-to-many  class="com.qf.entity.Student"/>	
		</set>
	</class>
</hibernate-mapping>

多的一方

Student.java

 1 package com.qf.entity;
 2 
 3 public class Student {
 4 
 5     private Long sid;
 6     private int s_sch;
 7     private String sname;
 8     //一個學生只能有一個學校
 9     private School sch;
10 
11     public Student() {
12         super();
13     }
14     
15     public Long getSid() {
16         return sid;
17     }
18     public void setSid(Long sid) {
19         this.sid = sid;
20     }
21     public int getS_sch() {
22         return s_sch;
23     }
24     public void setS_sch(int s_sch) {
25         this.s_sch = s_sch;
26     }
27     public String getSname() {
28         return sname;
29     }
30     public void setSname(String sname) {
31         this.sname = sname;
32     }
33     public School getSch() {
34         return sch;
35     }
36     public void setSch(School sch) {
37         this.sch = sch;
38     }
39     @Override
40     public String toString() {
41         return "Student [sid=" + sid + ", s_sch=" + s_sch + ", sname=" + sname + ", sch=" + sch + "]";
42     }
43     
44 }

View Code

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 配置表與實體的對映關係 -->
	<class name="com.qf.entity.Student" table="student">
		<id name="sid" column="sid">
			<!-- 主鍵生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="sname" column="sname"/>
		<!-- 
			name:一的一方的物件的屬性
			class:一的一方的物件全路徑
			column:多的一方表的外來鍵名稱
		 -->
		<many-to-one name="sch" class="com.qf.entity.School" column="s_sch"></many-to-one>
	</class>
</hibernate-mapping>

配置核心配置檔案hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url" >jdbc:mysql:///test02</property>
		<property name="hibernate.connection.username" >root</property>
		<property name="hibernate.connection.password" >root</property>
		<property name="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</property>
		
		<property name="hibernate.hbm2ddl.auto" >update</property>
		<property name="hibernate.show_sql" >true</property>
		<property name="hibernate.format_sql" >true</property>
		
		<mapping resource="com/qf/entity/School.hbm.xml"/>
		<mapping resource="com/qf/entity/Student.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

測試類

TestDemo.java

 1 package com.qf.test;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.Transaction;
 5 import org.junit.Test;
 6 
 7 import com.qf.entity.School;
 8 import com.qf.entity.Student;
 9 import com.qf.util.SessionFactoryUtil;
10 
11 public class TestDemo {
12     @Test
13     public void test() {
14         Session session = SessionFactoryUtil.getSession();
15         Transaction tx = session.beginTransaction();
16 
17         School sch1 = new School();
18         sch1.setSch_name("懷遠一中");
19         School sch2 = new School();
20         sch2.setSch_name("包集中學");
21         
22         Student stu1 = new Student();
23         stu1.setSname("張三");
24         Student stu2 = new Student();
25         stu2.setSname("李四");
26         Student stu3 = new Student();
27         stu3.setSname("王五");
28 
29         stu1.setSch(sch1);
30         stu2.setSch(sch2);
31         stu3.setSch(sch1);
32         sch1.getStus().add(stu1);
33         sch1.getStus().add(stu3);
34         sch2.getStus().add(stu2);
35         
36         session.save(stu1);
37         session.save(stu2);
38         session.save(stu3);
39         session.save(sch1);
40         session.save(sch2);
41         
42         tx.commit();
43     }
44 }

檢視資料庫結果

student表

sid	sname	s_sch
1	張三	1
2	李四	2
3	王五	1

school表

sch_id	sch_name	sch_address
1	懷遠一中
2	包集中學

級聯操作

級聯，指的是操作一個物件的同時操作該物件相關聯的物件

級聯分類

級聯儲存或者更新

級聯刪除

級聯儲存或者更新

1. 操作一的一方

修改一的一方的對映檔案

School.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 配置表與實體的對映關係 -->
	<class name="com.qf.entity.School" table="school">
		<id name="sch_id" column="sch_id">
			<!-- 主鍵生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="sch_name" column="sch_name"/>
		<property name="sch_address" column="sch_address"/>
		
		<!-- name:多的一方的集合屬性的名稱 -->
		<set name="stus" cascade="save-update">
			<!-- column:多的一方表的外來鍵名稱-->
			<key column="s_sch"></key>
			<!-- class:多的一方的類的全路徑 -->
			<one-to-many class="com.qf.entity.Student"/>	
		</set>
	</class>
</hibernate-mapping>

測試程式碼

測試方法

 1 @Test
 2 /**
 3  *儲存學校是否會儲存學生資訊
 4  *儲存的主體是學校，所以在學校的對映檔案中新增級聯配置
 5  *<set name="stus" cascade="save-update">
 6  */
 7 public void test() {
 8     Session session = SessionFactoryUtil.getSession();
 9     Transaction tx = session.beginTransaction();
10 
11     School sch1 = new School();
12     sch1.setSch_name("包集中學");
13     
14     Student stu1 = new Student();
15     stu1.setSname("李四");
16 
17     stu1.setSch(sch1);
18     sch1.getStus().add(stu1);
19     
20     session.save(sch1);
21     
22     tx.commit();
23 }

檢視資料庫中結果　　
- 　　
  student表
  
  sid sname s_sch
  
  1 李四 1
  
  school表
  
  sch_id sch_name sch_address
  
  1 包集中學

2. 操作多的一方

操作多的一方的對映檔案

Student.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 配置表與實體的對映關係 -->
	<class name="com.qf.entity.Student" table="student">
		<id name="sid" column="sid">
			<!-- 主鍵生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="sname" column="sname"/>
		<!-- 
			name:一的一方的物件的屬性
			class:一的一方的物件全路徑
			column:多的一方表的外來鍵名稱
		 -->
		<many-to-one cascade="save-update" name="sch" class="com.qf.entity.School" column="s_sch"></many-to-one>
	</class>
</hibernate-mapping>

測試程式碼

測試方法　

@Test
/**
 *儲存學生是否會儲存學校資訊
 *儲存的主體是學生，所以在學生的對映檔案中新增級聯配置
 *<many-to-one cascade="save-update" name="sch" class="com.qf.entity.School" column="s_sch"/>
 */
public void test() {
	Session session = SessionFactoryUtil.getSession();
	Transaction tx = session.beginTransaction();

	School sch1 = new School();
	sch1.setSch_name("懷遠一中");
	
	Student stu1 = new Student();
	stu1.setSname("張三");

	stu1.setSch(sch1);
	sch1.getStus().add(stu1);
	
	session.save(stu1);
	
	tx.commit();
}

檢視資料庫中結果
- 　　
  student表
  
  sid sname s_sch
  
  1 張三 1
  
  school表
  
  sch_id sch_name sch_address
  
  1 懷遠一中

3. 可以在多的一方和一的一方分別配置級聯，這樣操作一的一方、多的一方，同時都會操作另一方

 1 @Test
 2 /**
 3  *儲存學校是否會儲存學生資訊
 4  *儲存的主體是學校，所以在學校的對映檔案中新增級聯配置
 5  *<set name="stus" cascade="save-update">
 6  */
 7 public void test() {
 8     Session session = SessionFactoryUtil.getSession();
 9     Transaction tx = session.beginTransaction();
10 
11     School sch1 = new School();
12     sch1.setSch_name("包集中學");
13     
14     Student stu1 = new Student();
15     stu1.setSname("李四");
16     Student stu2 = new Student();
17     stu2.setSname("王五");
18     Student stu3 = new Student();
19     stu3.setSname("張三");
20 
21     stu1.setSch(sch1);
22     sch1.getStus().add(stu2);
23     sch1.getStus().add(stu3);
24     
25     /*
26      * 學校插入一條記錄，學生插入三條記錄
27      * 因為儲存stu1，級聯儲存sch1，儲存sch1，級聯儲存stu2、stu3
28      */
29     session.save(stu1);
30     /*
31      * 學生插入一條記錄
32      * 因為儲存stu2，stu2並沒有其它關聯的，所以只儲存stu2
33      */
34     //session.save(stu2);
35     /*
36      * 學校插入一條記錄，學生插入兩條記錄
37      * 因為儲存sch1，級聯儲存stu2、stu3
38      */
39     //session.save(sch1);
40     
41     tx.commit();
42 }

級聯刪除

通常jdbc操作資料庫情況下，如果要刪除表中學校資訊，直接刪除學校是無法成功的，必須先將該學校下所有的學生資訊刪除完，才能刪除學校資訊

級聯刪除可以讓我們在刪除學校的同時級聯刪除相關的學生資訊

1. 配置級聯刪除之前測試

 1 @Test
 2 public void delete() {
 3     Session session = SessionFactoryUtil.getSession();
 4     Transaction tx = session.beginTransaction();
 5     
 6     /*
 7      * 先查詢再刪除
 8      */
 9     School school = session.get(School.class, 1L);
10     session.delete(school);
11     
12     tx.commit();
13 }

console輸出

Hibernate: 
    select
        school0_.sch_id as sch_id1_0_0_,
        school0_.sch_name as sch_name2_0_0_,
        school0_.sch_address as sch_addr3_0_0_ 
    from
        school school0_ 
    where
        school0_.sch_id=?
Hibernate: 
    update
        student 
    set
        s_sch=null 
    where
        s_sch=?
Hibernate: 
    delete 
    from
        school 
    where
        sch_id=?

結論

刪除學校資訊時，預設先修改學生資訊的外來鍵（置為null），再刪除學校資訊

hibernate刪除一對多關係中一的一方某記錄資訊時，預設先將多的一方引用一的一方相關資訊的外來鍵置為null，再刪除一的一方記錄資訊

2. 配置刪除學校時級聯刪除學生

因為刪除主體是學校，所以需要在學校的對映檔案中做級聯刪除配置<set name="stus" cascade="delete">

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<!-- 配置表與實體的對映關係 -->
	<class name="com.qf.entity.School" table="school">
		<id name="sch_id" column="sch_id">
			<!-- 主鍵生成策略 -->
			<generator class="native"></generator>
		</id>
		<property name="sch_name" column="sch_name"/>
		<property name="sch_address" column="sch_address"/>
		
		<!-- name:多的一方的集合屬性的名稱 -->
		<set name="stus" cascade="delete">
			<!-- column:多的一方表的外來鍵名稱-->
			<key column="s_sch"></key>
			<!-- class:多的一方的類的全路徑 -->
			<one-to-many class="com.qf.entity.Student"/>	
		</set>
	</class>
</hibernate-mapping>

測試方法（必須先查詢再刪除，如果自己建立物件刪除的話，自己建立的物件裡資訊可能不全，例如school中可能沒有學生集合資訊）

@Test
public void delete() {
	Session session = SessionFactoryUtil.getSession();
	Transaction tx = session.beginTransaction();
	
	/*
	 * 先查詢再刪除
	 */
	School school = session.get(School.class, 1L);
	session.delete(school);
	
	tx.commit();
}

console輸出

Hibernate: 
    select
        school0_.sch_id as sch_id1_0_0_,
        school0_.sch_name as sch_name2_0_0_,
        school0_.sch_address as sch_addr3_0_0_ 
    from
        school school0_ 
    where
        school0_.sch_id=?
Hibernate: 
    select
        stus0_.s_sch as s_sch3_1_0_,
        stus0_.sid as sid1_1_0_,
        stus0_.sid as sid1_1_1_,
        stus0_.sname as sname2_1_1_,
        stus0_.s_sch as s_sch3_1_1_ 
    from
        student stus0_ 
    where
        stus0_.s_sch=?
Hibernate: 
    update
        student 
    set
        s_sch=null 
    where
        s_sch=?
Hibernate: 
    delete 
    from
        student 
    where
        sid=?
Hibernate: 
    delete 
    from
        student 
    where
        sid=?
Hibernate: 
    delete 
    from
        student 
    where
        sid=?
Hibernate: 
    delete 
    from
        school 
    where
        sch_id=?

結論　　
- 刪除學校資訊時級聯刪除了相關學生資訊

3. 刪除學生資訊級聯刪除學校資訊（並不符合常理，一般不會使用）

配置學生對映檔案
- <many-to-one name="sch" cascade="delete" class="com.qf.entity.School" column="s_sch"/>

維護關係inverse

inverse主要作用是指定哪一方來維護關係

取值是boolean，預設inverse="false"

如果一方的對映檔案中設定為true，說明在對映關係中讓另一方來維護關係；如果為false，就自己來維護關係

只能在一的一方設定

測試方法

　　2號學生本來是2號學校的，改變成1號學校

@Test
public void test() {
	Session session = SessionFactoryUtil.getSession();
	Transaction tx = session.beginTransaction();
	
	Student stu = session.get(Student.class, 2L);
	School sch = session.get(School.class, 1L);
	
	stu.setS_sch(2);	
	sch.getStus().add(stu);
	
	tx.commit();
}

1.不設定，使用預設值

School.hbm.xml

<set name="stus" cascade="save-update delete" inverse="false" >
	<!-- column:多的一方表的外來鍵名稱-->
	<key column="s_sch"></key>
	<!-- class:多的一方的類的全路徑 -->
	<one-to-many class="com.qf.entity.Student"/>	
</set>

Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.s_sch as s_sch3_1_0_ from student student0_ where student0_.sid=?
Hibernate: select school0_.sch_id as sch_id1_0_0_, school0_.sch_name as sch_name2_0_0_, school0_.sch_address as sch_addr3_0_0_ from school school0_ where school0_.sch_id=?
Hibernate: select stus0_.s_sch as s_sch3_1_0_, stus0_.sid as sid1_1_0_, stus0_.sid as sid1_1_1_, stus0_.sname as sname2_1_1_, stus0_.s_sch as s_sch3_1_1_ from student stus0_ where stus0_.s_sch=?
Hibernate: update student set sname=?, s_sch=? where sid=?
Hibernate: update student set s_sch=? where sid=?

2.設定另一方維護關係

School.hbm.xml

<set name="stus" cascade="save-update delete" inverse="true" >
	<!-- column:多的一方表的外來鍵名稱-->
	<key column="s_sch"></key>
	<!-- class:多的一方的類的全路徑 -->
	<one-to-many class="com.qf.entity.Student"/>	
</set>

Hibernate: select student0_.sid as sid1_1_0_, student0_.sname as sname2_1_0_, student0_.s_sch as s_sch3_1_0_ from student student0_ where student0_.sid=?
Hibernate: select school0_.sch_id as sch_id1_0_0_, school0_.sch_name as sch_name2_0_0_, school0_.sch_address as sch_addr3_0_0_ from school school0_ where school0_.sch_id=?
Hibernate: select stus0_.s_sch as s_sch3_1_0_, stus0_.sid as sid1_1_0_, stus0_.sid as sid1_1_1_, stus0_.sname as sname2_1_1_, stus0_.s_sch as s_sch3_1_1_ from student stus0_ where stus0_.s_sch=?
Hibernate: update student set sname=?, s_sch=? where sid=?

結論：

設定另一方維護關係時，少傳送一次更新語句
inverse="true"指的是由雙向關聯另一方維護該關聯，己方不維護該關聯
Inverse預設為false，雙向關係的兩端都能控制，會造成一些問題（更新的時候會因為兩端都控制關係，於是重複更新），可以在一端將inverse值設為true

五、hibernate表與表之間的關係（一對多關係）

資料庫表與表之間的關係一對多：一個學校可以有多個學生，一個學生只能有一個學校多對多：一個學生可以有多個老師，一個老師可以教多個學生一對一：一個人只能有一個身份證號，一個身份證號只能找到一個人一對多關係建立學生和學校表 create table school( sc

資料庫中表與表之間建立關係（一對多、多對多）

一、一對多的關係例：公司與員工的關係，公司為一，公司員工為多，需要在多方建立外來鍵指向一方的主鍵。一對多讓兩個實體類之間相互表示 (1)一個公司裡面有多個員工。 private Set<yuangong> yuangongSet=new HashSet

hibernate關聯關係（一對多、多對一）

1.什麼是關聯關係？關聯關係是指兩個實體或者表有相互關聯，比如在學生表中，學生表有班級id，那麼學生表中的班級id就關聯班級表中班級Id欄位。因此關聯關係，可以看成是一種外來鍵關係。 2.為什麼要有關聯關係？為了實現級聯操作，刪除班級中某個學生，會連帶刪除學生表中的

SSM實現多表連線查詢（一對多關聯）

SSM 各種配置資訊就不再贅述，之前一篇寫過。表1 對應的 pojo - - - 表1 欄位 id、name List<Two>是表2 查詢返回來的結果集表2 對應的 pojo ---- 表2 欄位 id、name

JPA總結——實體關係對映（一對多@OneToMany）

表address中的customer_id為customer表中的id的值，通過customer_id可以找到相應的customer的記錄。將表customer對映為CustomerEO實體，程式碼如下： @Entity @Table(name="customer") public clas

hibernate HQL 分頁關聯查詢（一對多單向，多對一雙向,多對多）

HQL的分頁 1.首先我們準備好實體類： package cn.happy.hibernate04pagelist; import cn.happy.hibernate03hql.conEmp; import java.util.Date; /** * Creat

六、資料庫之表與表之間的關係

表1 foreign key 表2 則表1的多條記錄對應表2的一條記錄，即多對一利用foreign key的原理我們可以製作兩張表的多對多，一對一關係多對多：表1的多條記錄可以對應表2的一條記錄表2的多條記錄也可以對應表1的一條

多表查詢、外來鍵、表與表之間的關係

外來鍵通常在實際工作中，資料庫中表格都不是獨立存在的，且表與表之間是有種聯絡的，比如兩張表格，一張為分類表category，一張為商品表product。在分類表中有兩個資訊，cid、cname，商品表中有三個資料資訊pid、name、price。兩張表要想有著某種聯絡

Hibernate Day03 表與表之間的關係一對多的關係之間的配置對映

在配置對映檔案時下圖關係為一對多的情況首先在多的一方放入一的屬性。在一的一方放入多的集合。在hibernate中採用set集合下圖為客戶對應多個聯絡人在對應的實體類中新增的程式碼如下：：這是在多的一方的實體類中插入的程式碼這是在一的一方的實體類中新增的程式碼如下圖：

十、表與表之間的常見關係及ER圖

表與表之間的常見關係及ER圖一、常見關係一對多: 使用者和訂單分類和商品多對多: 訂單和商品學生和課程一對一: 丈夫和妻子二、ER圖（E-實體

MYSQL--表與表之間的關係、修改表的相關操作

表與表之間的操作：　　如果所有資訊都在一張表中：　　　　1、表的結構不清晰　　　　2、浪費硬碟空間　　　　3、表的擴充套件性變得極差（致命的缺點）　　　　確立表與表之間的關係。一定要換位思考（必須在兩者考慮清楚之後才能得出結論）　　以員工和部門為例：　　　　員工：一個

python學習筆記 day44 表與表之間的關係

1. 表與表之間的關係：一對多；一對一；多對多；表與表之間怎麼建立一對一的關係呢，可以使用外來鍵約束+唯一約束；有兩種方式： 1.利用主鍵，一張表的主鍵只能有一個，所以這張表就可以滿足唯一，另一張表跟前面那張表的主鍵關聯的欄位設定為外來鍵，並且該外來鍵欄

Hibernate_day03---表與表關係建立、一對多配置及操作、多對多配置及操作

一、表與表關係建立思路一對多關係關係舉例：（1）分類和商品關係。一個分類裡面有多個商品，一個商品只能屬於一個分類（2）公司和員工關係一個公司有多個員工，每個員工屬於一個公司一對多建表：通過外來鍵建立關係圖示：多對多關係關係舉例

mysql學習【第6篇】：資料庫之表與表之間的關係資料庫之表與表之間的關係

資料庫之表與表之間的關係表1 foreign key 表2 則表1的多條記錄對應表2的一條記錄，即多對一

資料庫設計(表與表之間的3種關係)

表與表之間一般存在三種關係，即一對一，一對多，多對多關係。下面分別就三種關係講解資料庫相關設計的思路和思考過程； (1)一對一關係例如，下面的一張表，儲存了人的相關資訊，有男有女，要求查處所有的夫妻。 sql程式碼: CREATE TABLE

Hibernate學習筆記（四）—— 表與表的關係

一、一對多|多對一 1.1 關係表達 1.1.1 表中的表達　　建表原則：在多的一方建立外來鍵指向一的一方的主鍵。　　 1.1.2 實體中的表達　　　　　　【客戶實體】 public class Customer { private Long cus

資料庫表與表之間的關係

表與表之間的關係一對一關係在這種關係中，父表中的每一條記錄最多與子表中的一條記錄相關聯，在實際工作中，一對一關係使用的很少，因為存在一對一關係的兩個表可以簡單地合成一個表一對多關係這是最普通和常見的關係。在這種關係中，父表的每一條記錄都可以與子表中多條記錄相關聯，但

資料庫之表與表之間的關係

表1 foreign key 表2 則表1的多條記錄對應表2的一條記錄，即多對一利用foreign key的原理我們可以製作兩張表的多對多，一對一關係多對多：表1的多條記錄可以對應表2的一條記錄表2的多條記錄也可以對應表1的一條記錄一對一：

表與表之間關係 --------實體與實體之間關係

表與表之間關係

表與表之間關系回顧

至少 tab 通過 col 一個 otto width 字段聯系人 ------------------siwuxie095 表與表之間關系回顧 1、一對多（1） 1）場景：分類和商品的關系 2）描述

五、hibernate表與表之間的關係（一對多關係）

一對多關係

建立學生和學校表

根據表建立實體類和對映檔案

一的一方

多的一方

配置核心配置檔案hibernate.cfg.xml

測試類

檢視資料庫結果

級聯操作

級聯儲存或者更新

級聯刪除

維護關係inverse

相關推薦