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
                (?, ?, ?)*/

    }
}