Hibernate关联关系映射之一对多双向映射

一对多映射有两种，一种是单向的，另一种的多向。我们一般是使用双向的，所以我就写写一对多的双向映射。

还是想昨天一样举个例子来说明：作者《===》作品，还是对数据进行增删改查。

我们一般是把外键建立在多方的，一个作者对应多个作品。

这个前一篇的差不多。我就主要写写有差异的地方吧！

还是要建立数据库表，

 create table t_author(
 id bigint primary key auto_increment,
 authorName varchar(20)
 );
 
 create table t_book(
 id bigint primary key auto_increment,
 bookName varchar(20),
 fk_author_id int
 );

实体：

Author.java

 package com.cy.beans;
 
 import java.io.Serializable;
 import java.util.HashSet;
 import java.util.Set;
 
 public class Author implements Serializable {
     private static final long serialVersionUID = 1L;
 
     private long id;
     private String authorName;
     private Set<Book> books=new HashSet<Book>();
 
     public Author(){
 
     }
 
     public long getId() {
         return id;
     }
 
     public void setId(long id) {
         this.id = id;
     }
 
     public String getAuthorName() {
         return authorName;
     }
 
     public void setAuthorName(String authorName) {
         this.authorName = authorName;
     }
 
     public Set<Book> getBooks() {
         return books;
     }
 
     public void setBooks(Set<Book> books) {
         this.books = books;
     }
 
     @Override
     public String toString() {
         return "Author [id=" + id + ", authorName=" + authorName +
                 ", books=" + books + "]";
     }
 
 }

Book.java

 package com.cy.beans;
 
 import java.io.Serializable;
 
 public class Book implements Serializable {
 
     private static final long serialVersionUID = 1L;
 
     private long id;
     private String bookName;
     private Author author;
     public long getId() {
         return id;
     }
     public void setId(long id) {
         this.id = id;
     }
     public String getBookName() {
         return bookName;
     }
     public void setBookName(String bookName) {
         this.bookName = bookName;
     }
     public Author getAuthor() {
         return author;
     }
     public void setAuthor(Author author) {
         this.author = author;
     }
     @Override
     public String toString() {
         return "Book [id=" + id + ", bookName=" + bookName + ", author="
                 + author + "]";
     }
 
 }

持久层和业务层都与之前的差不多。

主要映射文件有所改变：

主对象：Author.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.cy.beans.Author" table="t_author" catalog="j2ee">   <!-- catalog数据库 -->
 
               <id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
                   <column name="id"></column><!-- 此行的ID，为表字段ID -->
                   <generator class="increment"></generator><!-- 给id指定生成策略 -->
               </id>
 
               <property name="authorName" type="java.lang.String">
                  <column name="authorName"></column>
               </property>
 
          <!--lazy :lazy是延时的意思，如果lazy=true，那么就是说数据库中关联子表的信息在hibernate容器启动的时候不会加载，而是在你真正的访问到字表非标识字段的时候，才会去加载。
                                                 反之，如果lazy=false的话，就是说，子表的信息会同主表信息同时加载
                    Hibernate3.x,lazy默认是true;
                    -->
          <!-- inverse:hibernate双向关系中的基本概念。inverse的真正作用就是指定由哪一方来维护之间的关联关系。当一方中指定了“inverse=false”（默认），那么那一方就有责任负责之间的关联关系 -->
 
     <set name="books" table="t_book" cascade="all" inverse="true" lazy="false"><!-- set映射节点 -->
              <key column="fk_author_id"></key><!-- 外键 -->
              <one-to-many class="com.cy.beans.Book"/><!--one-to-mang节点  -->
     </set>
     </class>
 
     </hibernate-mapping>

从对象：Book.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.cy.beans.Book" table="t_book" catalog="j2ee">   <!-- catalog数据库 -->
 
               <id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
                   <column name="id"></column><!-- 此行的ID，为表字段ID -->
                   <generator class="increment"></generator><!-- 给id指定生成策略 -->
               </id>
 
               <property name="bookName" type="java.lang.String">
                     <column name="bookName"></column>
               </property>
               <!--  access：属性值读取方式field, property
               1，property：这是默认值，表明hibernate通过set和get方法来访问类的属性。这是优先的推荐方式。你必须为这个属性设置get和set方法，hibernate才能访问到。否则会报错的。
               2，field：表明hibernate通过java的反射机制直接访问类的属性。你可以不给这个属性设置get和set属性。 、
               fk_author_id  ：字段名；
               not-null  :外键不为空
               author   ：many-to-one
               -->
         <many-to-one name="author" class="com.cy.beans.Author" cascade="none" access="property" column="fk_author_id" not-null="true"></many-to-one>
     </class>
     </hibernate-mapping>

在hibernate.cfg.xml里添加

 <mapping resource="com/cy/xmls/Book.hbm.xml"/>
 <mapping resource="com/cy/xmls/Author.hbm.xml"/>

测试：

 package com.cy.action;
 
 import java.util.HashSet;
 import java.util.Set;
 
 import com.cy.beans.Author;
 import com.cy.beans.Book;
 import com.cy.beans.Person;
 import com.cy.server.IAuthorServer;
 import com.cy.server.IPersonServer;
 import com.cy.server.impl.AuthorServerImpl;
 import com.cy.server.impl.PersonServerImpl;
 
 public class AuthorAction {
 
     public static void main(String[] args) {
 //        saveAuthor(); 添加
         updateAuthor();//修改
     }
 
     private static void updateAuthor() {
         IAuthorServer ps=new AuthorServerImpl();
         Author p=ps.getAuthor(Author.class, Long.valueOf(1));//查询
         p.setAuthorName("1111");
         ps.updateAuthor(p);
 
         /*Hibernate:
             select
                 author0_.id as id1_2_0_,
                 author0_.authorName as authorNa2_2_0_
             from
                 j2ee.t_author author0_
             where
                 author0_.id=?
 
                 如果在Author.hbm.xml里没有设置lazy="false"，那么下面这个select就不会执行
         Hibernate:
             select
                 books0_.fk_author_id as fk_autho3_2_0_,
                 books0_.id as id1_3_0_,
                 books0_.id as id1_3_1_,
                 books0_.bookName as bookName2_3_1_,
                 books0_.fk_author_id as fk_autho3_3_1_
             from
                 j2ee.t_book books0_
             where
                 books0_.fk_author_id=?
 
         Hibernate:
             update
                 j2ee.t_author
             set
                 authorName=?
             where
                 id=?
         Hibernate:
             update
                 j2ee.t_book
             set
                 bookName=?,
                 fk_author_id=?
             where
                 id=?*/
 
     }
 
     private static void saveAuthor() {
         Author a = new Author();
         Book b1 = new Book();
         Book b2 = new Book();
 
         a.setAuthorName("kitty");
         b1.setBookName("book1");
         b2.setBookName("book2");
 
         IAuthorServer server = new AuthorServerImpl();
         Set<Book> books = new HashSet<Book>();
         books.add(b2);
         books.add(b1);
         b1.setAuthor(a);
         b2.setAuthor(a);
         a.setBooks(books);
         server.saveAuthor(a);
 
         /*Hibernate:
             select
                 max(id)
             from
                 t_author
         Hibernate:
             select
                 max(id)
             from
                 t_book
         Hibernate:
             insert
             into
                 j2ee.t_author
                 (authorName, id)
             values
                 (?, ?)
         Hibernate:
             insert
             into
                 j2ee.t_book
                 (bookName, fk_author_id, id)
             values
                 (?, ?, ?)
         Hibernate:
             insert
             into
                 j2ee.t_book
                 (bookName, fk_author_id, id)
             values
                 (?, ?, ?)*/
 
     }
 }