一对多映射有两种，一种是单向的，另一种的多向。我们一般是使用双向的，所以我就写写一对多的双向映射。
还是想昨天一样举个例子来说明：作者《===》作品，还是对数据进行增删改查。
我们一般是把外键建立在多方的，一个作者对应多个作品。
这个前一篇的差不多。我就主要写写有差异的地方吧！
还是要建立数据库表，
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
(?, ?, ?)*/ }
}