初学Hibernate--(2)配置Hibernate+多对一实体映像

-----------配置Hibernate-------------------------

Hibernate可以使用XML或属性档案来配置SessionFactory，预设的配置文件名称为hibernate.cfg.xml或hibernate.properties。
　上一个主题中所示范的为使用XML文件的方式，一个XML文件的例子如下：

hibernate.cfg.xml

<?xml version='1.0' encoding='big5'?>

<!DOCTYPE hibernate-configuration

    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

 

<hibernate-configuration>

 

    <session-factory>

 

        <!-- 显示实际操作数据库时的SQL -->

        <property name="show_sql">true</property>

        <!-- SQL方言，这边设定的是MySQL -->

        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

        <!-- JDBC驱动程序 -->

        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>

        <!-- JDBC URL -->

        <property name="connection.url">jdbc:mysql://localhost/HibernateTest</property>

        <!-- 数据库使用者 -->

        <property name="connection.username">caterpillar</property>

        <!-- 数据库密码 -->

        <property name="connection.password">123456</property>

 

        <!-- 对象与数据库表格映像文件 -->

        <mapping resource="onlyfun/caterpillar/User.hbm.xml"/>

        <mapping resource="onlyfun/caterpillar/Item.hbm.xml"/>

 

    </session-factory>

 

</hibernate-configuration>

　使用XML文件进行配置时，可以在当中指定对象与数据库表格的映像文件位置，XML配置文件的位置必须在CLASSPATH的设定中，例如单机执行时主 程序的位置，或是Web程序的WEB-INF/classes中，我们使用下面的方式来读入XML文件以配置Hibernate：

SessionFactory sf = new Configuration().configure().buildSessionFactory();

　Configuration表示Java对象与数据库表格映像的集合，并用于之后建立SessionFactory，之后Configuration就不再有作用。预设的XML文件名称是hibernate.cfg.xml，您也可以指定文件的名称，例如：

SessionFactory sf = new Configuration()

    .configure("db.cfg.xml")

    .buildSessionFactory();

　除了使用XML文件进行配置，我们也可以使用属性档案进行配置，文件名称是hibernate.properties，一个例子如下：

hibernate.properties

hibernate.show_sql = true

hibernate.dialect = net.sf.hibernate.dialect.MySQLDialect

hibernate.connection.driver_class = com.mysql.jdbc.Driver

hibernate.connection.url = jdbc:mysql://localhost/HibernateTest

hibernate.connection.username = caterpillar

hibernate.connection.password = 123456

　hibernate.properties的位置必须在CLASSPATH的设定中，例如单机执行时主程序的位置，或是Web程序的WEB-INF/classes中，而为了要取得对象至数据库表格的映像文件，我们必须在程序中如下加载：

Configuration cfg = new Configuration()

    .addClass(onlyfun.caterpillar.User.class)

    .addClass(onlyfun.caterpillar.Item.class);

　这么一来，程序会自动加载onlyfun/caterpillar/User.hbm.xml与onlyfun/caterpillar/Item.hbm.xml，完成Hibernate配置之后，我们可以如下取得SessionFactory：

SessionFactory sessions = cfg.buildSessionFactory();
 
 
------------------------多对一实体映像------------------------

一个实体简单的说就是在数据库中拥有一个表格的对象，并拥有自已的数据库识别（database identity），之前介绍的Component对象并不是实体，它没有自已的数据库识别，具体的话，它没有id属性，Hibernate并不会赋予它id值。
　实体与实体之间的关系有：一对一、多对一、一对多、多对多。其中多对一算是最常见的实体关系，举个简单的例子，假设您在撰写一个宿舍管理系统，一般来 说，房客与房间之间的关系就是一种多对一的关系，因为一间房间可以分配给多个人（学生宿舍啦，一般应该都是二到八个人不等吧！看学校的环境了）。
　用程序来表示的话，首先看看Room类别的撰写，我们只简单的设定地址属性于其中：

Room.java

package onlyfun.caterpillar;

 

public class Room {

    private long id;

    private String address;

  

    public long getId() {

        return id;

    }

    public void setId(long id) {

        this.id = id;

    }  

   public String getAddress() {

       return address;

   }

   public void setAddress(String address) {

       this.address = address;

   }

}

　注意这个类别与Component对象不同的是，它拥有id属性，在储存至数据库，Hibernate会赋予值给它；房客的话我们设计一个User类别：

User.java

package onlyfun.caterpillar;

 

public class User {

    private long id;

    private String name;

    private Room room;

  

    public long getId() {

        return id;

    }

    public void setId(long id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

  

    public Room getRoom() {

        return room;

    }

    

    public void setRoom(Room room) {

        this.room = room;

    }

}

　在Java中，一个Room对象可以被多个User对象参考，也就是说User对Room的关系是多对一的关系，我们也可以反过来设计Room对 User的关系，将其设计为一对多，这在下一个主题中讨论，现阶段我们先关注多对一的映射，我们的Room映射文件Room.hbm.xml很简单，如下：

Room.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.Room" table="ROOM">

 

        <id name="id" column="ROOM_ID">

            <generator class="increment"/>

        </id>

 

        <property name="address" type="string"/>

    </class>

 

</hibernate-mapping>

　再来是User.hbm.xml的撰写，我们使用<many-to-one>来设定多对一映射关系，如下：

User.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

 

<hibernate-mapping>

 

    <class name="onlyfun.caterpillar.User" table="USER">

 

        <id name="id" column="USER_ID">

            <generator class="increment"/>

        </id>

 

        <property name="name">

            <column name="NAME" length="16" not-null="true"/>

        </property>

    

        <many-to-one name="room"

                     column="ROOM_ID"

                     class="onlyfun.caterpillar.Room"/>

    </class>

 

</hibernate-mapping>

　与User对应的USER表格是透过ROOM_ID的值参考至ROOM表格，当然，最重要的别忘了在hibernate.cfg.xml中指定映像文件的位置与名称：

hibernate.cfg.xml

<?xml version='1.0' encoding='big5'?>

<!DOCTYPE hibernate-configuration

    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

 

<hibernate-configuration>

 

    <session-factory>

 

        ......

 

        <!-- 对象与数据库表格映像文件 -->

        <mapping resource="Room.hbm.xml"/>

        <mapping resource="User.hbm.xml"/>

 

    </session-factory>

 

</hibernate-configuration>

　我们用下面这个程序简单的测试一下储存的结果：

HibernateTest.java

import onlyfun.caterpillar.*;

import net.sf.hibernate.*;

import net.sf.hibernate.cfg.*;

 

public class HibernateTest {

    public static void main(String[] args) throws HibernateException {

        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

    

        Room room1 = new Room();

        room1.setAddress("NTU-M8-419");

        Room room2 = new Room();

        room2.setAddress("NTU-G3-302");

      

        User user1 = new User();

        user1.setName("bush");

        user1.setRoom(room1);

      

        User user2 = new User();

        user2.setName("caterpillar");

        user2.setRoom(room1);

      

        User user3 = new User();

        user3.setName("momor");

        user3.setRoom(room2);

      

        Session session = sessionFactory.openSession();

        Transaction tx= session.beginTransaction();

      

        session.save(room1);

        session.save(room2);

        session.save(user1);

        session.save(user2);

        session.save(user3);

 

        tx.commit();

        session.close();

 

        sessionFactory.close();

    }

}

　直接来看看储存在数据库中是什么样子：

mysql> select * from USER;

+---------+-------------+---------+

| USER_ID | NAME        | ROOM_ID |

+---------+-------------+---------+

|       1 | bush        |       1 |

|       2 | caterpillar |       1 |

|       3 | momor       |       2 |

+---------+-------------+---------+

3 rows in set (0.00 sec)

 

mysql> select * from ROOM;

+---------+------------+

| ROOM_ID | address    |

+---------+------------+

|       1 | NTU-M8-419 |

|       2 | NTU-G3-302 |

+---------+------------+

2 rows in set (0.00 sec)