ORM进阶之Hibernate中关系映射

ORM进阶之 ORM简介

ORM进阶之Hibernate简介及框架搭

ORM进阶之Hibernate的三大对象

ORM进阶之Hibernate中对象的三大状态解析

ORM进阶之Hibernate中一对一的关系映射

映射可以说是在hibernate中非常重要的一个内容，通过映射可以让程序员不再思考复杂的sql语句，而是更加的专注于业务逻辑的实现。映射通过一个xml配置文件完成并且我们可以对他进行修改！下边我们来看一下如何完成映射的!

单表映射

每个实体对应一张表，跟其他的实体没有关联关系，这是最简单的一种方式，下边我们看一下，如何通过实体映射到数据库中。我们的实体User的代码

<span style="font-size:18px;">/**
 * User实体
 * @author hongjie
 *
 */
public class User {
   //主键
   private int id;
   //用户名
   private String username;
   //密码
   private String  passwords;
   public int getId() {
      return id;
   }
   public void setId(intid) {
      this.id = id;
   }
   public String getUsername() {
      return username;
   }
   public void setUsername(Stringusername) {
      this.username = username;
   }
   public String getPasswords() {
      return passwords;
   }
   public void setPasswords(Stringpasswords) {
      this.passwords = passwords;
   }
}</span>

映射文件的代码User.hbm.xml 的代码

<span style="font-size:18px;"><?xml version="1.0"?>
<!DOCTYPE hibernate-mappingPUBLIC
   "-//Hibernate/Hibernate Mapping DTD3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--package   对应实体所在包 -->
<hibernate-mappingpackage="com.tgb.domain">
<!-- table 为映射到数据库中的表名 ， 默认与实体名一致 -->
   <class name="User" table="t_users">
      <id name="id" type="java.lang.Integer">
         <generator class="native"/>
      </id>
      <property name="username"/>
      <property name="passwords"/>
   </class>
</hibernate-mapping></span>

通过这样的简单的两个配置文件，就能将我们的实体映射到数据库中了!这也是最简单的一种映射方式。但是在实际中很少有所有的实体之间都没有关系的。

一对一关系映射

还有一种一对一的关系，比如说一个用户只能有一个***信息，我们要把***信息单独存储，这样我们的用户实体和***实体就是一个一对一的关系，肯定是先有人，然后才有***信息，所以用户应该为主，***信息为从，用户维护者***信息。hibernate的一对一关系有两种形式，一种是共享主键方式，另一种是唯一外键方式.。我们该怎么来表示这样关系呢！ 看一下代码。

共享主键方式

顾名思义，就是一个人的两条记录使用同一个主键，当我们创建了用户后，在创建***信息时，他会自动去取他对应的用户信息的主键。这样就可以使用同一个主键了。
下边我们看一下代码，

package com.tgb.domain;
/**
 * User实体
 * @author hongjie
 *
 */
public class User {
	//主键
	private int id;
	//用户名
	private String username;
	//密码
	private String  passwords;
	//卡信息
	private Card card;
	
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPasswords() {
		return passwords;
	}
	public void setPasswords(String passwords) {
		this.passwords = passwords;
	}
}

</pre><pre name="code" class="html">public class Card {
	//主键
	private int cardId;
	//***信息 
	private String cardInfo;
	//用户信息
	private User user;
	
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public int getCardId() {
		return cardId;
	}
	public void setCardId(int cardId) {
		this.cardId = cardId;
	}
	public String getCardInfo() {
		return cardInfo;
	}
	public void setCardInfo(String cardInfo) {
		this.cardInfo = cardInfo;
	}
	
	
}

上边是两个实体的的代码，我们可以看到在user中具有card的引用，在card中也有user的引用，这样为双向关联，根据其中任何一个信息，都可以取到另一个信息。看一下我们配置文件的代码

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package   对应实体所在包 -->
<hibernate-mapping package="com.tgb.domain">
<!-- 	table 为映射到数据库中的表名 ， 默认与实体名一致 -->
	<class name="User" table="t_users" >
		<id name="id" type="java.lang.Integer">
			<generator class="native"/>
		</id>
		<property name="username"/>
		<property name="passwords"/>
		<!-- card关联， cascade="all" 对user的所有操作 都进行级联操作 -->
		<one-to-one name="card" class="Card" cascade="all"></one-to-one>
	</class>
</hibernate-mapping>

</pre><pre name="code" class="html"><?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package   对应实体所在包 -->
<hibernate-mapping package="com.tgb.domain">
<!-- 	table 为映射到数据库中的表名 ， 默认与实体名一致 -->
	<class name="Card" table="t_card" >
		<id name="id" type="java.lang.Integer">
			<generator class="foreign"><!--使用主键关联，引用User对应表的主键作为自己的主键-->   
                    <param name="property">user</param><!--此处的user必须和下面配置的one-to-one的name属性一样 -->   
                </generator>  
		</id>
		<property name="cardInfo"/>
        <!-- 用户属性，constrained在这里必须为true 这里使用的是双向关联映射，要不然会有重复数据读。 -->
		<one-to-one name="user" class="User" constrained="true"></one-to-one>
	</class>
</hibernate-mapping>

通过上边的配置文件，我们就创建好了一个一对一的唯一主键关联映射。下边我们在看一下一对一的另一种实现方式外键关联。

外键关联

我们pojo类，还是上边的那两个类，我们只是修改了配置文件，配置文件如下

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package   对应实体所在包 -->
<hibernate-mapping package="com.tgb.domain">
<!-- 	table 为映射到数据库中的表名 ， 默认与实体名一致 -->
	<class name="User" table="t_users" >
		<id name="id" type="java.lang.Integer">
			<generator class="native"/>
		</id>
		<property name="username"/>
		<property name="passwords"/>
<!-- 		持有card 的属性，  -->
	    <one-to-one name="card" class="Card" fetch="join" cascade="all" ></one-to-one>   
	</class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- package   对应实体所在包 -->
<hibernate-mapping package="com.tgb.domain">
<!-- 	table 为映射到数据库中的表名 ， 默认与实体名一致 -->
	<class name="Card" table="t_card" >
		<id name="id" type="java.lang.Integer">
			<generator class="foreign"><!--使用主键关联，引用User对应表的主键作为自己的主键-->   
                    <param name="property">user</param><!--此处的user必须和下面配置的one-to-one的name属性一样 -->   
                </generator>  
		</id>
		<property name="cardInfo"/>
<!-- 		该为多对一unique 设置为true，这样就保证了唯一性。 -->
         <many-to-one name="user" class="User" unique="true" ></many-to-one>  
	</class>
</hibernate-mapping>

可以看到我们只是简单的修改了一下配置文件，就把他变成了唯一外键约束了。这样也可以实现一对一映射。 下篇博客将为大家讲解多对一映射，敬请期待。