2. 程式人生 > >JDBC上關於資料庫中多表操作一對多關係和多對多關係的實現方法--轉

JDBC上關於資料庫中多表操作一對多關係和多對多關係的實現方法--轉

阿新 • • 發佈：2018-11-06

 

原文地址----

https://www.cnblogs.com/pangguoming/p/7028322.html

黑馬程式設計師

我們知道，在設計一個Java bean的時候，要把這些BEAN 的資料存放在資料庫中的表結構，然而這些資料庫中的表直接又有些特殊的關係，例如員工與部門直接有一對多的關係，學生與老師直接又多對多的關係，那麼這些表的關係如何表示呢？
首先在建立資料庫的時候就應該建立這樣的對應關係。
一對多 ，只要建立兩個表就能建立這樣的關係，因為你可以把多方的那個表設定一個Foreign Key 屬性 ，下面是一個部門和員工的表結構關係
在MySQL 資料庫上應該這樣建立表結構：

1

2

3

4

5

6

7

8

9

10

11

12

create table department(

id int primary key,

name varchar(100)

);

 

create table employee(

id int primary key,

name varchar(100),

salary float(8,2),

dept_id int,

constraint dept_id_fk 

foreign key (dept_id) references department(id)//這個其實是約束條件，不是表格的屬性值。

);

　　在java 程式的javabean中應該如何做呢 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

public class Department {

    private Integer id;

    private String name;

    private Set<Employee> emps = new HashSet<Employee>(); //????????????????????????????Set????

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Set<Employee> getEmps() {

        return emps;

    }

 

    public void setEmps(Set<Employee> emps) {

        this.emps = emps;

    }

 

    @Override

    public String toString() {

        return "Department [emps=" + emps + ", id=" + id + ", name=" + name +

        "]";

    }

}

 

 

public class Employee {

    private Integer id;

    private String name;

    private Float salary;

 

    // private Department dept = new Department();

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Float getSalary() {

        return salary;

    }

 

    public void setSalary(Float salary) {

        this.salary = salary;

    }

 

    @Override

    public String toString() {

        return "Employee [id=" + id + ", name=" + name + ", salary=" + salary +

        "]";

    }

}

　　在DAO層 如何實現增加 查詢資料呢？增加一個部門和查詢一個部門的時候要不要顯示員工呢?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

public class DeparmentDao {

    private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());

 

    public void addDepartment(Department dept) {

        try {

            //??????????

            String sql = "insert into department values(?,?)";

            Object[] params = { dept.getId(), dept.getName() };

            qr.update(sql, params);

 

            //???????????????????

            Set<Employee> emps = dept.getEmps();

 

            if ((emps != null) && (emps.size() > 0)) {

                for (Employee e : emps) {

                    sql = "insert into employee values(?,?,?,?)";

                    params = new Object[] {

                            e.getId(), e.getName(), e.getSalary(), dept.getId()

                        };

                    qr.update(sql, params);

                }

            }

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

 

    //??????????????????

    public List<Department> findDepts(boolean lazy) {

        try {

            //???????

            String sql = "select * from department";

            List<Department> depts = qr.query(sql,

                    new BeanListHandler<Department>(Department.class));

 

            if ((depts != null) && (depts.size() > 0)) {

                for (Department dept : depts) {

                    if (lazy) {

                        //??

                        sql = "select id from employee where dept_id=?";

                    } else {

                        //??

                        sql = "select * from employee where dept_id=?";

                    }

 

                    List<Employee> emps = qr.query(sql,

                            new BeanListHandler<Employee>(Employee.class),

                            dept.getId());

 

                    for (Employee e : emps) {

                        dept.getEmps().add(e);

                    }

                }

            }

 

            return depts;

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

 

    //??????????????????.????????

    public List<Department> findDepts() {

        return findDepts(true);

    }

}

　　

 

多對多的關係

下面以老師和學生的關係來說明這個結構
資料庫中：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

create table teacher(

id int primary key,

name varchar(100),

salary float(8,2)

);

 

create table student(

id int primary key,

name varchar(100),

grade varchar(100)

);

 

create table teacher_student(

t_id int,

s_id int,

primary key(t_id,s_id),

constraint t_id_fk foreign key(t_id) references teacher(id),

constraint s_id_fk foreign key(s_id) references student(id)

);

　　如何寫javabean 和 dao呢 ？

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

public class Teacher {

    private Integer id;

    private String name;

    private Float salary;

    private Set<Student> stus = new HashSet<Student>();

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public Float getSalary() {

        return salary;

    }

 

    public void setSalary(Float salary) {

        this.salary = salary;

    }

 

    public Set<Student> getStus() {

        return stus;

    }

 

    public void setStus(Set<Student> stus) {

        this.stus = stus;

    }

}

 

 

public class Student {

    private Integer id;

    private String name;

    private String grade;

 

    public Integer getId() {

        return id;

    }

 

    public void setId(Integer id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public String getGrade() {

        return grade;

    }

 

    public void setGrade(String grade) {

        this.grade = grade;

    }

 

    @Override

    public String toString() {

        return "Student [grade=" + grade + ", id=" + id + ", name=" + name +

        "]";

    }

}

 

 

public class TeacherDao {

    private QueryRunner qr = new QueryRunner(JdbcUtil.getDataSource());

 

    public void addTeacher(Teacher t) throws SQLException {

        //????????

        String sql = "insert into teacher values(?,?,?)";

        Object[] params = { t.getId(), t.getName(), t.getSalary() };

        qr.update(sql, params);

 

        //????????

        //?3??

        Set<Student> stus = t.getStus();

 

        if ((stus != null) && (stus.size() > 0)) {

            for (Student s : stus) {

                sql = "insert into student values(?,?,?)";

                params = new Object[] { s.getId(), s.getName(), s.getGrade() };

                qr.update(sql, params);

                sql = "insert into teacher_student values(?,?)";

                params = new Object[] { t.getId(), s.getId() };

                ;

                qr.update(sql, params);

            }

        }

    }

 

    public List<Teacher> findTeacher(boolean lazy) throws SQLException {

        String sql = "select * from teacher";

        List<Teacher> ts = qr.query(sql,

                new BeanListHandler<Teacher>(Teacher.class));

 

        if ((ts != null) && (ts.size() > 0)) {

            for (Teacher t : ts) {

                if (lazy) {

                    sql = "select id from student where id in (select s_id from teacher_student where t_id=?)";

                } else {

                    sql = "select * from student where id in (select s_id from teacher_student where t_id=?)";

                }

 

                List<Student> stus = qr.query(sql,

                        new BeanListHandler<Student>(Student.class), t.getId());

 

                for (Student s : stus) {

                    t.getStus().add(s);

                }

            }

        }

 

        return ts;

    }

}

　　工具表工具

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

public class JdbcUtil {

    private static DataSource ds;

    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

 

    static {

        try {

            InputStream in = JdbcUtil.class.getClassLoader()

                                           .getResourceAsStream("dbcpconfig.properties");

            Properties props = new Properties();

            props.load(in);

 

            BasicDataSourceFactory factory = new BasicDataSourceFactory();

            ds = factory.createDataSource(props);

        } catch (Exception e) {

            throw new ExceptionInInitializerError(e);

        }

    }

 

    public static DataSource getDataSource() {

        return ds;

    }

 

    public static Connection getConnection() throws SQLException {

        Connection conn = tl.get();

 

        if (conn == null) {

            conn = ds.getConnection();

            tl.set(conn);

        }

 

        return conn;

    }

 

    public static void startTransaction() throws SQLException {

        Connection conn = tl.get();

 

        if (conn == null) {

            conn = ds.getConnection();

            tl.set(conn);

        }

 

        conn.setAutoCommit(false);

    }

 

    public static void rollback() throws SQLException {

        Connection conn = tl.get();

 

        if (conn == null) {

            conn = ds.getConnection();

            tl.set(conn);

        }

 

        conn.rollback();

    }

 

    public static void commit() throws SQLException {

        Connection conn = tl.get();

 

        if (conn == null) {

            conn = ds.getConnection();

            tl.set(conn);

        }

 

        conn.commit();

        tl.remove();

    }

 

    public static void release(ResultSet rs, Statement stmt, Connection conn) {

        if (rs != null) {

            try {

                rs.close();

            } catch (Exception e) {

                e.printStackTrace();

            }

 

            rs = null;

        }

 

        if (stmt != null) {

            try {

                stmt.close();

            } catch (Exception e) {

                e.printStackTrace();

            }

 

            stmt = null;

        }

 

        if (conn != null) {

            try {

                conn.close();

            } catch (Exception e) {

                e.printStackTrace();

            }

 

            conn = null;

        }

    }

}

　　

dbcpconfig.properties的檔案 中內容
#連線設定
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/day15  #這個是你的資料庫地址
username=root #這個是你的使用者名稱
password=sorry # 這個是你 密碼


#<!-- 初始化連線 -->
initialSize=10

#最大連線數量
maxActive=20

#<!-- 最大空閒連線 -->
maxIdle=6

#<!-- 最小空閒連線 -->
minIdle=3

#<!-- 超時等待時間以毫秒為單位 6000毫秒/1000等於60秒 -->
maxWait=60000


#JDBC驅動建立連線時附帶的連線屬性屬性的格式必須為這樣：[屬性名=property;] 
#注意："user" 與 "password" 兩個屬性會被明確地傳遞，因此這裡不需要包含他們。
connectionProperties=useUnicode=true;characterEncoding=utf8

#指定由連線池所建立的連線的自動提交（auto-commit）狀態。
defaultAutoCommit=true

#driver default 指定由連線池所建立的連線的只讀（read-only）狀態。
#如果沒有設定該值，則“setReadOnly”方法將不被呼叫。（某些驅動並不支援只讀模式，如：Informix）
defaultReadOnly=

#driver default 指定由連線池所建立的連線的事務級別（TransactionIsolation）。
#可用值為下列之一：（詳情可見javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=REPEATABLE_READ

相關推薦

JDBC上關於資料庫中多表操作一對多關係和多對多關係的實現方法--轉

  原文地址---- https://www.cnblogs.com/pangguoming/p/7028322.html 黑馬程式設計師 我們知道，在設計一個Java bean的時候，要把這些BEAN 的資料存放在資料庫中的表結構，然而這些資料庫中的表直接又有些特殊

查詢資料庫中某表的欄位名和欄位型別

mysql： 1. 查詢資料庫中的所有表：show tables; 2. 查詢表中的欄位名和欄位型別： show columns from table_name(表名)；                 &n

資料庫基礎 四張圖理解資料庫之第三張 資料庫連線 JDBC 理解 多表操作（附帶相關資源）第三天

JDBC JDBC： 概述： Java Data Base Connectivity，Java資料庫連線 就是Java程式碼操作不同資料庫（DBMS）。 JDBC就是Java定義的用來操作不同資料庫的規範，本質就是一些介面和類。

（十二）Hibernate中的多表操作（1）：單向多對一

art 保存 int gen round t對象 情況 映射文件 拋出異常 由“多”方可知“一”方的信息，比如多個員工使用同一棟公寓，員工可以知道公寓的信息，而公寓無法知道員工的信息。 案例一： pojo類 public class Department {

（十四）Hibernate中的多表操作（4）：單向一對一

odin utf-8 lds () clas string 方式 rdb style 案例一： 註解方式實現一對一 UserBean.java package bean; import java.io.Serializable; import javax.pers

資料庫中某個表中的某個欄位的值是用逗號隔開的多個值，根據逗號拆分並從另一個表中查出資料返回

有兩個表A，B,表結構如下： A表 B表 關聯關係說明如下： （1）A.hospital_catalog=B.id （2）A表中hospital_catalog欄位的值是以 逗號 “,” 隔開，且兩邊用中括號“[ ]”包起，

Django day08 多表操作 (四) 一對多, 多對多連續跨表查詢

一對多 # 基於雙下劃線的一對多查詢 # 查詢出版社為上海出版社的所有圖書 # ret = Publish.objects.filter(name='上海出版社').values('book__name', 'book__price') # print(ret)

Django - ORM 資料庫操作 - 多表操作

目錄 一、建立多表關係結構 二、一對多 and 一對一 表關係的記錄操作 1、 增（兩種方式） 方式一、create方式建立，指定欄位名傳輸資料 方式二、獲取外來鍵表物件id，給類定義的關係變數，賦值查詢到的物件 2、改（兩種方式） 方式一、獲取物件，修改後save方法儲

MyBatis中的多表操作情形一：一對一(方式1：一條sql語句查詢，MyBatis3.0可以用association和collection標籤)

MyBatis支援多表操作，即可以將資料庫中多表的關係對映到物件之間的關係中 表與表之間的關係可以有：一對一，一對多，多對多 關係一演示案例：人和身份證是一對一的，分別建兩個表person和card，其中person的cardid欄位外來鍵關聯card的id，

使用Setup Factory 打包軟體，安裝時自動建立資料庫及資料庫中的表（效果類似sql server中的附加資料庫操作）

前提：已安裝Setup Fatory軟體、我使用的是 安裝工廠永樂漢化版，需要的請自行下載安裝 下面只列出關鍵性步驟，黃色字型較為關鍵，是一個出錯點   步驟一（關鍵）：生成資料庫備份檔案，以及建表sql指令碼，和bat命令檔案 備份資料庫，生成檔案1，.bak檔

資料庫多表操作事務處理

一、主要思路 在需要同時插入多條資料時，這其中可能是同一個表的多條記錄，也可能是多個不同表之間的資料同時更新。對此，我們需要保證其中的原子性和一致性，做到要麼全部操作都能全部成功完成，否則全部不操作。 我們可以通過SQL的事務來對相關資料庫操作進行處理，在開始conn.se

mysql使用federated引擎實現遠端訪問資料庫（跨網路同時操作兩個資料庫中的表）

問題： 這裡假設我需要在IP1上的database1上訪問IP2的database資料庫內的table2表 方法： 這裡database作為本地資料庫需要開啟federated引擎才可以訪問遠端的database內的表，具體開啟方法如下： 本地IP1資料庫DATABASE

DBCC大全集之（適用版本MS SQLServer 2008 R2）----DBCC DBREINDEX對指定資料庫中的表重新生成一個或多個索引

DBCC DBREINDEX 重新生成表的一個索引或為表定義的所有索引。通過允許動態重新生成索引，可以重新生成強制 PRIMARY KEY 或 UNIQUE 約束的索引，而不必刪除並重新建立這些約束。這意味著無需瞭解表的結構或其約束，即可重新生成索引。這可能在將資料大容量複製到表中以後發生。 DBCC

Python中使用SQLAlchemy連線Mysql資料庫（單表操作）

一，SQLAlchemy的安裝 使用 $ easy_install sqlalchemy 或 $ pip install sqlalchemy 如果出現什麼錯，就進去root使用者下進行安裝試試，或者網上查查 >>>

【JAVAEE學習筆記】hibernate03：多表操作，級聯練習:添加聯系人

row tac 默認值 rac user except pro intra com 一、一對多|多對一 1、關系表達 　表中的表達 　　 　　實體中的表達 　　 　　orm元數據中表達 　　　　一對多 <!-- 集合,一對多關系,在配置文件中配置 -

java dbcp連接池，大數據處理循環多表操作插入事例

als postgresq postgres map() err manage fas space false 基礎連接池類： package com.yl.sys.dao; import java.io.InputStream;import java.sql.Connec

Hibernate筆記3--多表操作-導航查詢

test ransac mod 多表 private getc als 級聯 默認 一.一對多操作 1.構造實體類及編寫配置文件: 一方: 1 // 一個Customer對應多個linkman 2 private Set&l

MySQL之多表操作

cnblogs lec 外連接 自然連接 中軟 outer esc convert not in 前言：之前已經針對數據庫的單表查詢進行了詳細的介紹：MySQL之增刪改查，然而實際開發中業務邏輯較為復雜，需要對多張表進行操作，現在對多表操作進行介紹。 前提：為方便後面的操作

Hibernate的多表操作

nsa 執行 添加數據 什麽事 為什麽 -s 使用 一次 class 一.一對多 1.表設計:主外鍵關聯 2.持久類設計:一方持有多方的set集合,多方持有一方的對象 3.配置文件:一方配置級聯操作;一方放棄外鍵維護 二.多對多關系: 1

Django多表操作

輸入 ask __str__ models field pla 多對多 model class 多表操作：以book，publish, author為例 　　一對多：一旦確定一對多的關系，在多的一方(book)創建關聯字段publish_id 　　多對多：一旦確定多對多的