在hibernate中，有几种不同的映射文件，这几种映射文件各有特点，set在前面已经说过，这种映射关系多的一方中没有顺序关系，并且其中也不允许有重复的值，但是在list中，这两个刚好相反，list允许有重复的值，并且多的一方数据在持久化到数据中时也强调了数据的顺序，而bag中和了list和set的特点，bag允许有不用的值，但是这些值之间没有顺序，而map是一种键值对的结构，根据值得不同情况，又可以分为两种，一种情况是map的value可以直接对应到数据库中的字段类型，例如string，int，char,boolean等等，还有一种map的value本身是一个实体类，那么value 将被持久化到另外一个数据库表中。下面将对上面所说的情况来一一说明。
List类型，以房子和房间为例，下面是两个类的代码
public class House {
private int id;
private String location;
private List rooms;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public List getRooms() {
return rooms;
}
public void setRooms(List rooms) {
this.rooms = rooms;
}
}public class Room {
private String id;
private String number;
private House house;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public House getHouse() {
return house;
}
public void setHouse(House house) {
this.house = house;
}
}
下面是两个类的映射文件。
House.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.House" table="house">
<id name="id" column="id" type="int">
<generator class="increment"></generator>
</id>
<property name="location" column="location" type="java.lang.String"></property>
<list name="rooms" table="rooms" cascade="all" >
<key column="house_id"></key>
<index column="index_"></index>
<one-to-many class="com.example.domain.Room"/>
</list>
</class>
</hibernate-mapping>
room.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.Room" table="rooms">
<id name="id" column="id" type="string">
<generator class="uuid"></generator>
</id>
<property name="number" column="number" type="string"></property>
<many-to-one name="house" class="com.example.domain.House" column="house_id"></many-to-one>
</class>
</hibernate-mapping>下面是测试的代码
public class ListTest {
/**
* @param args
*/
public static void main(String[] args) {
Session session = HibernateSessionFactory.openSession();
Transaction tx = session.beginTransaction();
House house = new House();
house.setLocation("ShiShou city,Hb Province,China");
house.setRooms(new ArrayList());
Room roomA = new Room();
roomA.setNumber("510");
Room roomB = new Room();
roomB.setNumber("502");
house.getRooms().add(roomA);
house.getRooms().add(roomB);
try
{
session.save(house);
tx.commit();
}
catch(Exception ex)
{
ex.printStackTrace();
if(tx != null)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}
下面是数据库表的截图，可以看出index_的值分别为0,1表示了房间510和502的先后插入。
Bag类型，仍然以house和room为例，
bag和list在程序的编写上极为相似，所以在House类和room类都不要修改，但是需要说明的是，我们前面所说的set和list在java都有对应的类或者接口，在hibernate中使用list来模拟bag，所以room类中，不要任何的修改，因此我们需要修改的就只是House.hbm.xml文件了，下面是House.hbm.xml.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.House" table="house">
<id name="id" column="id" type="int">
<generator class="increment"></generator>
</id>
<property name="location" column="location" type="java.lang.String"></property>
<bag name="rooms" table="rooms" cascade="all">
<key column="house_id"></key>
<one-to-many class="com.example.domain.Room"/>
</bag>
</class>
</hibernate-mapping>
对比两个运行的结果，就可以看出bag中并没有记录数据插入的顺序。
Map映射文件
第一种情况，这种情况下map的key-value中的value为可以直接映射到数据库中的类型，例如string（数据库中为char,varchar等）。下面以班级为例，班级中有students， 类型为map<String,String>,下面是banji类的代码
package com.example.domain;
import java.util.HashMap;
import java.util.Map;
public class Banji {
private String id;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private Map <String,String> students = new HashMap<String,String>();
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Map<String, String> getStudents() {
return students;
}
public void setStudents(Map<String, String> students) {
this.students = students;
}
}
在map的value为string等类型的时候只需要配置一个hbm.xml文件即可。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.Banji" table="banji">
<id name="id" column="id" type="string">
<generator class="uuid"></generator>
</id>
<property name="name" column="name" type="string"></property>
<map name="students" >
<key column="banji_id" ></key>
<index column="stu_id" type="string"></index>
<element column="stu_name" type="string"></element>
</map>
</class>
</hibernate-mapping>
下面是测试的代码：
public class Map1Test {
public static void main(String[] args) {
Session session = HibernateSessionFactory.openSession();
Transaction tx = session.beginTransaction();
Banji banji = new Banji();
banji.getStudents().put("101001", "zhangsan");
banji.getStudents().put("101002", "lisi");
banji.getStudents().put("101003", "wangwu");
try
{
session.save(banji);
tx.commit();
}
catch(Exception ex)
{
ex.printStackTrace();
if(tx != null)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}
另一种map映射的情况是map的value是一个实体类，即在数据库字段中没有与之相对应的。下面以Club和Player为例说明。下面是pojo类代码
public class Club {
private String id;
private String name;
private Map<String,String> field = new HashMap<String,String>();
private Map<String ,Player> team = new HashMap<String,Player>();
public Map<String, String> getField() {
return field;
}
public void setField(Map<String, String> field) {
this.field = field;
}
public Map<String, Player> getTeam() {
return team;
}
public void setTeam(Map<String, Player> team) {
this.team = team;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.example.domain;
public class Player {
private String id;
private String number;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private Club club;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public Club getClub() {
return club;
}
public void setClub(Club club) {
this.club = club;
}
}
下面是两个hbm.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.Club" table="club">
<id name="id" column="id" type="string">
<generator class="uuid"></generator>
</id>
<property name="name" column="name" type="string"></property>
<map name="team" table="player" cascade="all">
<key column="team_id"></key>
<index column="number" type="string"></index>
<one-to-many class="com.example.domain.Player" />
</map>
</class>
</hibernate-mapping>
那么在map当中，value为一个实体类，那么这种映射本质上还是一种一对多的关系，所以使用了one-to-many标签。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.example.domain.Player" table="player">
<id name="id" column="id" type="string">
<generator class="uuid"></generator>
</id>
<property name="name" column="name" type="string"></property>
<many-to-one name="club" class="com.example.domain.Club" column="team_id" cascade="none"></many-to-one>
</class>
</hibernate-mapping>
那么在另一端相对应的就是many-to-one.
下面是测试代码，
import java.util.HashSet;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.example.domain.Club;
import com.example.domain.IdCard;
import com.example.domain.Player;
import com.example.domain.Student;
import com.example.domain.Team;
import com.example.util.HibernateSessionFactory;
public class Test {
public static void main(String args[])
{
Club club = new Club();
club.setName("Heat");
Player LBJ = new Player();
LBJ.setClub(club);
LBJ.setName("LBJ");
club.getTeam().put("6", LBJ);
Session session = HibernateSessionFactory.openSession();
Transaction tx = session.beginTransaction();
try
{
session.save(club);
tx.commit();
}
catch(Exception ex)
{
ex.printStackTrace();
if(tx != null)
{
tx.rollback();
}
}
finally
{
session.close();
}
}
}
306
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
