Hibernate 对象映射

最新推荐文章于 2022-02-12 19:40:27 发布
最新推荐文章于 2022-02-12 19:40:27 发布
阅读量442 收藏
点赞数
分类专栏： java 文章标签： java


延迟加载与即时加载

例如Person类和Email类是一对多关系，如果设为即时加载，当加载Person时，会自动加载Email，如果设置为延迟加载，当第一次调用person.getEmails()时才会执行SQL语句加载Email
注解配置时，@OnetToMany(Fetch = FetchType.EAGER)为即时加载，Fetch = FetchType.LAZY为延迟加载
延迟加载和即时加载的策略适用于所有一对多、多对一、多对多等所有的实体关系

一般来说，延迟加载要比即时加载节省资源，但是如果处理不当，延迟加载容易抛出LazyInitializationException异常，解决当方法有两种，一种是在Session关闭之前调用一下，person.getEmails()方法，强迫Hibernate加载数据，这是最常用的方式，还有一种是延迟Session的范围，使Session关闭前完成所有的业务逻辑，在web程序中有些工具也能延长Session的范围，例如Spring的OpenSessionInViewFilter，能把Session扩大到所有的web资源，包括Servlet层、JSP层、DAO层、Service层


单边一对多

一方有集合属性，包含多个多方，而多方没有一方的引用
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. import  javax.persistence.*;  
  2.   
  3.   
  4. //“一"方  
  5. @Entity  
  6. @Table(name="tb_person")  
  7. public  class Person{  
  8.     @Id  
  9.     @GeneratedValue(strategy = GenerationType.AUTO)  
  10.     private Integer id;  
  11.   
  12.   
  13.     private String name;  
  14.   
  15.   
  16.     @OneToMany(fetch = FetchType.EAGER,targetEntity = Email.class,cascade={  
  17.         CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE, CascadeType.REFRESH  
  18.     })  
  19.     @JoinColumns(value={@JoinColumn(name="person_id",referencedColumnName="id")})  
  20.     @OrderBy(value = email desc")  
  21.     private List<Email> emails = new ArrayList<Email>();  
  22.     //在email对应的表中产生一个person_id字段，引用person标的id  
  23.     // referencedColumnName指的是实体类的关联列，默认为主键，可省略  
  24.   
  25.   
  26.     //setter、getter略  
  27. }  
  28.   
  29.   
  30. //“多"方  
  31. @Entity  
  32. @Table(name="tb_email")  
  33. public  class Email{  
  34.     @Id  
  35.     @GeneratedValue(strategy = GenerationType.AUTO)  
  36.     private Integer id;  
  37.   
  38.   
  39.     private String email;  
  40.   
  41.   
  42.     //setter、getter略  
  43. }  
import  javax.persistence.*;


//“一"方
@Entity
@Table(name="tb_person")
public  class Person{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;


	private String name;


	@OneToMany(fetch = FetchType.EAGER,targetEntity = Email.class,cascade={
		CascadeType.PERSIST, CascadeType.REMOVE, CascadeType.MERGE, CascadeType.REFRESH
	})
	@JoinColumns(value={@JoinColumn(name="person_id",referencedColumnName="id")})
	@OrderBy(value = email desc")
	private List<Email> emails = new ArrayList<Email>();
	//在email对应的表中产生一个person_id字段，引用person标的id
	// referencedColumnName指的是实体类的关联列，默认为主键，可省略


	//setter、getter略
}


//“多"方
@Entity
@Table(name="tb_email")
public  class Email{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;


	private String email;


	//setter、getter略
}


[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <hibernate-mapping  package="com.clf.hibernate.bean">  
  2.     <class  name="Person" table="tb_person">  
  3.         <id name="id" column="id">  
  4.             <generator class="native">  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <bag name="emails" cascade="all" lazy="false" where="email like %@%" order-by="email">  
  8.             <key column="email_id"></key>  
  9.             <one-to-many class="com.clf.hibernate.bean.Email" />  
  10.         </bag>  
  11.     </class>  
  12. </ hibernate-mapping >  
  13.   
  14.   
  15. <hibernate-mapping  package="com.clf.hibernate.bean">  
  16.     <class  name="Email" table="tb_eamil">  
  17.         <id name="id" column="id">  
  18.             <generator class="native">  
  19.         </id>  
  20.         <property name="email"/>  
  21.     </class>  
  22. </ hibernate-mapping >  
<hibernate-mapping  package="com.clf.hibernate.bean">
	<class  name="Person" table="tb_person">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="name"/>
		<bag name="emails" cascade="all" lazy="false" where="email like %@%" order-by="email">
			<key column="email_id"></key>
			<one-to-many class="com.clf.hibernate.bean.Email" />
		</bag>
	</class>
</ hibernate-mapping >


<hibernate-mapping  package="com.clf.hibernate.bean">
	<class  name="Email" table="tb_eamil">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="email"/>
	</class>
</ hibernate-mapping >



如果集合属性使用的是Set而非List，则XML配置时需要使用<set>标签而不是<bag>标签，而且不能使用order-by属性
JPA(Java Persistence API)要求实体类必须为POJO，而不能为String等基本类型，换句话说，电子邮件必须封装为Email对象，即使它只有一个String属性
而XML配置允许直接使用String作为实体类，而不需要封装成一个Email对象
配置改动如下
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <bag name="emails" cascade="all" lazy="false" where="email like %@%" order-by="email">  
  2.         <key column="email_id"></key>  
  3.         <element type="String" column="email" />  
  4. </bag>  
<bag name="emails" cascade="all" lazy="false" where="email like %@%" order-by="email">
		<key column="email_id"></key>
		<element type="String" column="email" />
</bag>


单边多对一

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //“一"方  
  2. @Entity  
  3. @Table(name = "tb_table")  
  4. public class Type{  
  5.     @Id  
  6.     @GeneratedValue(strategy = GenerationType.AUTO)  
  7.     private Integer id;  
  8.       
  9.     @Column(unique = true)  
  10.     private String name;  
  11.     //setter、getter方法略  
  12. }  
  13. //“多"方  
  14. @Entity  
  15. @Table(name = tb_article")  
  16. public class Article{  
  17.     @Id  
  18.     @GeneratedValue(strategy = GenerationType.AUTO)  
  19.     private Integer id;  
  20.   
  21.   
  22.     @ManyToOne(cascade = {CascadeType.PERSIST},fetch = FetchType.EAGER)  
  23.     @JoinColumn(name = "type_id")  
  24.     Private Type type;  
  25.     //在article表总产生一个type_id字段，引用type表中的id字段  
  26.   
  27.   
  28.     @Column(columnDefinition = "text")  
  29.     private String content;  
  30.   
  31.   
  32.     private String name;  
  33.   
  34.   
  35.     //setter、getter方法略  
  36. }  
//“一"方
@Entity
@Table(name = "tb_table")
public class Type{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;
	
	@Column(unique = true)
	private String name;
	//setter、getter方法略
}
//“多"方
@Entity
@Table(name = tb_article")
public class Article{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;


	@ManyToOne(cascade = {CascadeType.PERSIST},fetch = FetchType.EAGER)
	@JoinColumn(name = "type_id")
	Private Type type;
	//在article表总产生一个type_id字段，引用type表中的id字段


	@Column(columnDefinition = "text")
	private String content;


	private String name;


	//setter、getter方法略
}


[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class  name="Type" table="tb_type">  
  2.         <id name="id" column="id">  
  3.             <generator class="native">  
  4.         </id>  
  5.         <property name="name"/>  
  6. </class>  
  7.   
  8.   
  9. <class  name="Article" table="tb_article">  
  10.         <id name="id" column="id">  
  11.             <generator class="native">  
  12.         </id>  
  13.         <property name="name"/>  
  14.         <property name="content"/>  
  15.         <many-to-one name = "type" column = "type_id" cascade = "persist" lazy="false" not-found="ignore">  
  16.         </ many-to-one >  
  17. </class>  
<class  name="Type" table="tb_type">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="name"/>
</class>


<class  name="Article" table="tb_article">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="name"/>
		<property name="content"/>
		<many-to-one name = "type" column = "type_id" cascade = "persist" lazy="false" not-found="ignore">
		</ many-to-one >
</class>


双边多对一、一对多

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. //“一"方  
  2. @Entity  
  3. @Table(name = "tb_class")  
  4. public class Clazz{  
  5.     @Id  
  6.     @GeneratedValue(strategy = GenerationType.AUTO)  
  7.     private Integer id;  
  8.   
  9.   
  10.     private String name;  
  11.       
  12.     //使用反向配置（@ManyToOne不存在该属性），双边关系中，控制权一般交给多方，定义在被拥有方，指向拥有方，拥有方能够级联地维护被拥有方的关系。因此这里没有配置数据库的外键，而只配置了一个mappedBy属性，告诉Hibernate，配置信息要到Student类的“clazz"属性中找  
  13.     @OneToMany(mappedBy = "clazz")  
  14.     private List<Student> students;  
  15.   
  16.   
  17.     //setter、getter方法略  
  18. }  
  19.   
  20.   
  21. //“多"方  
  22. @Entity  
  23. @Table(name = "tb_student")  
  24. public class Student{  
  25.     @Id  
  26.     @GeneratedValue(strategy = GenerationType.AUTO)  
  27.     private Integer id;  
  28.   
  29.   
  30.     @ManyToOne(cascade = {CascadeType.PERSIST},fetch = FetchType.EAGER)  
  31.     @JoinColumn(name = "class_id")  
  32.     Private Clazz clazz;  
  33.     //在student表总产生一个class_id字段，引用class表中的id字段  
  34.   
  35.   
  36.     private String sex;  
  37.   
  38.   
  39.     private String name;  
  40.   
  41.   
  42.     //setter、getter方法略  
  43. }  
//“一"方
@Entity
@Table(name = "tb_class")
public class Clazz{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;


	private String name;
	
	//使用反向配置（@ManyToOne不存在该属性），双边关系中，控制权一般交给多方，定义在被拥有方，指向拥有方，拥有方能够级联地维护被拥有方的关系。因此这里没有配置数据库的外键，而只配置了一个mappedBy属性，告诉Hibernate，配置信息要到Student类的“clazz"属性中找
	@OneToMany(mappedBy = "clazz")
	private List<Student> students;


	//setter、getter方法略
}


//“多"方
@Entity
@Table(name = "tb_student")
public class Student{
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id;


	@ManyToOne(cascade = {CascadeType.PERSIST},fetch = FetchType.EAGER)
	@JoinColumn(name = "class_id")
	Private Clazz clazz;
	//在student表总产生一个class_id字段，引用class表中的id字段


	private String sex;


	private String name;


	//setter、getter方法略
}


[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class  name="Clazz" table="tb_class">  
  2.         <id name="id" column="id">  
  3.             <generator class="native">  
  4.         </id>  
  5.         <property name="name"/>  
  6.         <bag name="students" inverse="true" cascade="all">  
  7.             <key column="class_id"/>  
  8.             <one-to-many class="com.clf.hibernate.bean.Student"/>  
  9.         </bag>  
  10. </class>  
  11.   
  12.   
  13. <class  name="Student" table="tb_student">  
  14.         <id name="id" column="id">  
  15.             <generator class="native">  
  16.         </id>  
  17.         <property name="name"/>  
  18.         <property name="sex"/>  
  19.         <many-to-one name = "clazz" column = "class_id" cascade = "all" >  
  20.         </ many-to-one >  
  21. </class>  
<class  name="Clazz" table="tb_class">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="name"/>
		<bag name="students" inverse="true" cascade="all">
			<key column="class_id"/>
			<one-to-many class="com.clf.hibernate.bean.Student"/>
		</bag>
</class>


<class  name="Student" table="tb_student">
		<id name="id" column="id">
			<generator class="native">
		</id>
		<property name="name"/>
		<property name="sex"/>
		<many-to-one name = "clazz" column = "class_id" cascade = "all" >
		</ many-to-one >
</class>


单边一对一

有两种策略可以实现一对一的关联映射
主键关联：即让两个对象具有相同的主键值，以表明它们之间的一一对应的关系；数据库表不会有额外的字段来维护它们之间的关系，仅通过表的主键来关联。
唯一外键关联：外键关联，本来是用于多对一的配置，但是如果加上唯一的限制之后，也可以用来表示一对一关联关系。
唯一外键关联策略
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class IdCard {  
  3.   private int id;  
  4.   private String cardNo;  
  5.   
  6.   @Id  
  7.   @GeneratedValue  
  8.   public int getId() {return id;}  
  9.   
  10.     //setter、getter略  
  11. }  
  12.   
  13. @Entity  
  14. public class Person {  
  15.    
  16.   private IdCard idCard;//引用IdCard对象    
  17.   private String name;   
  18.     
  19.   @Id  
  20.   @GeneratedValue  
  21.   private int id;  
  22.   
  23.   @OneToOne  
  24.   @JoinColumn(name="idCard")      
  25.   private IdCard idCard;    //引用IdCard对象  
  26.   
  27.   private String name;   
  28.     
  29.     //setter、getter略  
  30. }  
@Entity
public class IdCard {
  private int id;
  private String cardNo;

  @Id
  @GeneratedValue
  public int getId() {return id;}

	//setter、getter略
}

@Entity
public class Person {
 
  private IdCard idCard;//引用IdCard对象  
  private String name; 
  
  @Id
  @GeneratedValue
  private int id;

  @OneToOne
  @JoinColumn(name="idCard")	
  private IdCard idCard;	//引用IdCard对象

  private String name; 
  
	//setter、getter略
}


[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.IdCard" table="t_idcard">  
  2.       <id name="id" column="id">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="cardNo"/>  
  6. </class>  
  7.   
  8. <class name="com.clf.hibernate.Person" table="t_person">  
  9.       <id name="id" column="id">  
  10.           <generator class="native"/>  
  11.       </id>  
  12.       <property name="name"/>   
  13. <!--在多的一端(当前Person一端)，加入一个外键(当前为idCard)指向一的一端(当前IdCard),但多对一关联映射字段是可以重复的，所以需要加入一个唯一条件unique="true",这样就可以此字段唯一了。-->  
  14.       <many-to-one name="idCard" unique="true"/>  
  15. </class>  
<class name="com.clf.hibernate.IdCard" table="t_idcard">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="cardNo"/>
</class>

<class name="com.clf.hibernate.Person" table="t_person">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="name"/> 
<!--在多的一端(当前Person一端)，加入一个外键(当前为idCard)指向一的一端(当前IdCard),但多对一关联映射字段是可以重复的，所以需要加入一个唯一条件unique="true",这样就可以此字段唯一了。-->
      <many-to-one name="idCard" unique="true"/>
</class>


主键关联策略
IdCart正常注解

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class Person {  
  3.    
  4.   private IdCard idCard;//引用IdCard对象    
  5.   private String name;   
  6.     
  7.   @Id  
  8.   @GeneratedValue  
  9.   private int id;  
  10.   
  11.   @OneToOne   
  12.   @PrimaryKeyJoinColumn //注解主键关联映射    
  13.   private IdCard idCard;    //引用IdCard对象    
  14.   
  15.   private String name;   
  16.     
  17.     //setter、getter略  
  18. }  
@Entity
public class Person {
 
  private IdCard idCard;//引用IdCard对象  
  private String name; 
  
  @Id
  @GeneratedValue
  private int id;

  @OneToOne 
  @PrimaryKeyJoinColumn	//注解主键关联映射  
  private IdCard idCard;	//引用IdCard对象  

  private String name; 
  
	//setter、getter略
}



[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.IdCard" table="t_idcard">  
  2.       <id name="id" column="id">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="cardNo"/>  
  6. </class>  
  7.   
  8. <class name="com.clf.hibernate.Person" table="t_person">  
  9.       <id name="id" column="id">  
  10.           <!--主键不是自己生成的，而是作为一个外键，所以使用foreign生成策略。foreign:使用另外一个相关联的对象的标识符，通常和<one-to-one>联合起来使用。再使用元素<param>的属性值指定相关联对象(这里Person相关联的对象为idCard,则标识符为idCard的id)为了能够在加载person数据同时加载IdCard数据，所以需要使用一个标签<one-to-one>来设置这个功能。  -->  
  11.             <generator class="foreign">  
  12.                 <!-- 元素<param>属性name的值是固定为property -->  
  13.                 <param name="property">idCard</param>  
  14.             </generator>  
  15.       </id>  
  16.       <property name="name"/>   
  17.   <!--表示如何加载它的引用对象(这里引用对象就指idCard这里的name值是idCard)，同时也说是一对一的关系。 默认方式是根据主键加载(把person中的主键取出再到IdCard中来取相关IdCard数据。) 我们也说过此主键也作为一个外键引用 了IdCard，所以需要加一个数据库限制(外键约束)constrained="true"     -->  
  18.        <one-to-one name="idCard" constrained="true"/>    
  19. </class>  
<class name="com.clf.hibernate.IdCard" table="t_idcard">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="cardNo"/>
</class>

<class name="com.clf.hibernate.Person" table="t_person">
      <id name="id" column="id">
          <!--主键不是自己生成的，而是作为一个外键，所以使用foreign生成策略。foreign:使用另外一个相关联的对象的标识符，通常和<one-to-one>联合起来使用。再使用元素<param>的属性值指定相关联对象(这里Person相关联的对象为idCard,则标识符为idCard的id)为了能够在加载person数据同时加载IdCard数据，所以需要使用一个标签<one-to-one>来设置这个功能。  -->
            <generator class="foreign">
                <!-- 元素<param>属性name的值是固定为property -->
                <param name="property">idCard</param>
            </generator>
      </id>
      <property name="name"/> 
  <!--表示如何加载它的引用对象(这里引用对象就指idCard这里的name值是idCard)，同时也说是一对一的关系。 默认方式是根据主键加载(把person中的主键取出再到IdCard中来取相关IdCard数据。) 我们也说过此主键也作为一个外键引用 了IdCard，所以需要加一个数据库限制(外键约束)constrained="true"     -->
       <one-to-one name="idCard" constrained="true"/>  
</class>


联合主键关联(Annotation方式)
实现上联合主键的原理同唯一外键关联-单向一样，只是使用的是@JoinColumns，而不是@JoinColumn，实体类注解如下：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @OneToOne  
  2. @JoinColumns(  
  3.     {  
  4.         @JoinColumn(name="personId", referencedColumnName="id"),  
  5.         @JoinColumn(name="personName", referencedColumnName="name")  
  6.     }  
  7. )  
  8. rivate Person person;  
    @OneToOne
    @JoinColumns(
        {
            @JoinColumn(name="personId", referencedColumnName="id"),
            @JoinColumn(name="personName", referencedColumnName="name")
        }
    )
   private Person person;


   注意：@JoinColumns注解联合主键一对一联系，然后再使用@JoinColumn来注解当前表中的外键字段名，并指定关联哪个字段，使用referencedColumnName指定哪个字段的名称


双边一对一

凡是双向关联，必设 mappedBy
唯一外键关联策略
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class IdCard {  
  3.    
  4.   private String cardNo;  
  5.   
  6.   @Id  
  7.   @GeneratedValue  
  8.   private int id;  
  9.   
  10.   @OneToOne(mappedBy="idCard")  
  11.   private Person person;  
  12.   
  13.     //setter、getter略  
  14. }  
  15.   
  16. @Entity  
  17. public class Person {  
  18.    
  19.   private IdCard idCard;//引用IdCard对象    
  20.   private String name;   
  21.     
  22.   @Id  
  23.   @GeneratedValue  
  24.   private int id;  
  25.   
  26.   @OneToOne  
  27.   @JoinColumn(name="idCard")    //为idCard对象指定外键  
  28.   private IdCard idCard;    //引用IdCard对象    
  29.   
  30.   private String name;   
  31.     
  32.     //setter、getter略  
  33. }  
@Entity
public class IdCard {
 
  private String cardNo;

  @Id
  @GeneratedValue
  private int id;

  @OneToOne(mappedBy="idCard")
  private Person person;

	//setter、getter略
}

@Entity
public class Person {
 
  private IdCard idCard;//引用IdCard对象  
  private String name; 
  
  @Id
  @GeneratedValue
  private int id;

  @OneToOne
  @JoinColumn(name="idCard")	//为idCard对象指定外键
  private IdCard idCard;	//引用IdCard对象  

  private String name; 
  
	//setter、getter略
}



[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.IdCard" table="t_idcard">  
  2.       <id name="id" column="id">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="cardNo"/>  
  6.        <one-to-one name="person" property-ref="idCard"/>  
  7. </class>  
  8. <!-- 一对一 唯一外键 关联映射 双向 需要在另一端(当前IdCard)，添加<one-to-one>标签，指示hibernate如何加载其关联对象(或引用对象)，默认根据主键加载(加载person),外键关联映射中，因为两个实体采用的是person的外键来维护的关系，所以不能指定主键加载person,而要根据person的外键加载，所以采用如下映射方式：  
  9.     <one-to-one>标签：告诉hibernate如何加载其关联对象  
  10. property-ref属性：是根据哪个字段进行比较加载数据  -->  
  11.   
  12. <class name="com.clf.hibernate.Person" table="t_person">  
  13.       <id name="id" column="id">  
  14.           <generator class="native"/>  
  15.       </id>  
  16.       <property name="name"/>   
  17. <!--在多的一端(当前Person一端)，加入一个外键(当前为idCard)指向一的一端(当前IdCard),但多对一关联映射字段是可以重复的，所以需要加入一个唯一条件unique="true",这样就可以此字段唯一了。-->  
  18.       <many-to-one name="idCard" unique="true"/>  
  19. </class>  
<class name="com.clf.hibernate.IdCard" table="t_idcard">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="cardNo"/>
	   <one-to-one name="person" property-ref="idCard"/>
</class>
<!-- 一对一 唯一外键 关联映射 双向 需要在另一端(当前IdCard)，添加<one-to-one>标签，指示hibernate如何加载其关联对象(或引用对象)，默认根据主键加载(加载person),外键关联映射中，因为两个实体采用的是person的外键来维护的关系，所以不能指定主键加载person,而要根据person的外键加载，所以采用如下映射方式：
	<one-to-one>标签：告诉hibernate如何加载其关联对象
property-ref属性：是根据哪个字段进行比较加载数据  -->

<class name="com.clf.hibernate.Person" table="t_person">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="name"/> 
<!--在多的一端(当前Person一端)，加入一个外键(当前为idCard)指向一的一端(当前IdCard),但多对一关联映射字段是可以重复的，所以需要加入一个唯一条件unique="true",这样就可以此字段唯一了。-->
      <many-to-one name="idCard" unique="true"/>
</class>


主键关联策略
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class IdCard {  
  3.    
  4.   private String cardNo;  
  5.   
  6.   @Id  
  7.   @GeneratedValue  
  8.   private int id;  
  9.   
  10.   @OneToOne(mappedBy="idCard")  
  11.   private Person person;  
  12.   
  13.     //setter、getter略  
  14. }  
  15.   
  16. @Entity  
  17. public class Person {  
  18.    
  19.   private IdCard idCard;//引用IdCard对象    
  20.   private String name;   
  21.     
  22.   @Id  
  23.   @GeneratedValue  
  24.   private int id;  
  25.   
  26.   @OneToOne   
  27.   @PrimaryKeyJoinColumn //注解主键关联映射    
  28.   private IdCard idCard;    //引用IdCard对象    
  29.   
  30.   private String name;   
  31.     
  32.     //setter、getter略  
  33. }  
@Entity
public class IdCard {
 
  private String cardNo;

  @Id
  @GeneratedValue
  private int id;

  @OneToOne(mappedBy="idCard")
  private Person person;

	//setter、getter略
}

@Entity
public class Person {
 
  private IdCard idCard;//引用IdCard对象  
  private String name; 
  
  @Id
  @GeneratedValue
  private int id;

  @OneToOne 
  @PrimaryKeyJoinColumn	//注解主键关联映射  
  private IdCard idCard;	//引用IdCard对象  

  private String name; 
  
	//setter、getter略
}

[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.IdCard" table="t_idcard">  
  2.       <id name="id" column="id">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="cardNo"/>  
  6.        <one-to-one name="person"/>  
  7. </class>  
  8.   
  9.   
  10.   
  11. <class name="com.clf.hibernate.Person" table="t_person">  
  12.       <id name="id" column="id">  
  13.             <generator class="foreign">  
  14.                 <param name="property">idCard</param>  
  15.             </generator>  
  16.       </id>  
  17.       <property name="name"/>   
  18.       <one-to-one name="idCard" constrained="true"/>    
  19. </class>  
<class name="com.clf.hibernate.IdCard" table="t_idcard">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="cardNo"/>
	   <one-to-one name="person"/>
</class>



<class name="com.clf.hibernate.Person" table="t_person">
      <id name="id" column="id">
            <generator class="foreign">
                <param name="property">idCard</param>
            </generator>
      </id>
      <property name="name"/> 
      <one-to-one name="idCard" constrained="true"/>  
</class>


单边多对多

[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class User {  
  3.   private int id;  
  4.   private String name;  
  5.   private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id  
  6.     
  7. @GeneratedValue  
  8.   public int getId() {return id;}  
  9.    
  10.   @ManyToMany  
  11.   @JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称  
  12.           joinColumns={@JoinColumn(name="userId")},  
  13. //使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象  
  14.           inverseJoinColumns={@JoinColumn(name="roleId")}  
  15. //使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表  
  16.   )  
  17.   public Set<User> getRoles() {return roles;  
  18. }  
@Entity
public class User {
  private int id;
  private String name;
  private Set<User> roles = new HashSet<User>();// Role对象的集合  @Id
  
@GeneratedValue
  public int getId() {return id;}
 
  @ManyToMany
  @JoinTable(name="u_r",//使用@JoinTable标签的name属性注解第三方表名称
          joinColumns={@JoinColumn(name="userId")},
//使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象
          inverseJoinColumns={@JoinColumn(name="roleId")}
//使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表
  )
  public Set<User> getRoles() {return roles;
}



Role实体正常注解

Role映射文件：
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.Role" table="t_role">  
  2.         <id name="id">  
  3.             <generator class="native"/>  
  4.         </id>  
  5.         <property name="name" column="name"/>  
  6. </class>  
  7.   
  8. User映射文件：  
  9.     <class name="com.clf.hibernate.User" table="t_user">  
  10.         <id name="id"column="id">  
  11.             <generator class="native"/>  
  12.         </id>  
  13.         <property name="name"/>  
  14. <!--使用<set>标签映射集合(set)，标签中的name值为对象属性名(集合roles)，而使用table属性是用于生成第三方表名称，例：table="t_user_role"，但是第三方面中的字段是自动加入的，作为外键分别指向其它表。  
  15. 所以表<key>标签设置，例：<key column="userid"/>，意思是：在第三方表(t_user_role)中加入一个外键并且指向当前的映射实体类所对应的表(t_user).使用<many-to-many>来指定此映射集合所对象的类(实例类)，并且使用column属性加入一个外键指向Role实体类所对应的表(t_role) -->  
  16.         <set name="roles" table="t_user_role">  
  17.             <key column="userid"/>  
  18.             <many-to-many class="com.clf.hibernate.Role" column="roleid"/>  
  19.         </set>  
  20. </class>  
<class name="com.clf.hibernate.Role" table="t_role">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
</class>

User映射文件：
    <class name="com.clf.hibernate.User" table="t_user">
        <id name="id"column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
<!--使用<set>标签映射集合(set)，标签中的name值为对象属性名(集合roles)，而使用table属性是用于生成第三方表名称，例：table="t_user_role"，但是第三方面中的字段是自动加入的，作为外键分别指向其它表。
所以表<key>标签设置，例：<key column="userid"/>，意思是：在第三方表(t_user_role)中加入一个外键并且指向当前的映射实体类所对应的表(t_user).使用<many-to-many>来指定此映射集合所对象的类(实例类)，并且使用column属性加入一个外键指向Role实体类所对应的表(t_role) -->
        <set name="roles" table="t_user_role">
            <key column="userid"/>
            <many-to-many class="com.clf.hibernate.Role" column="roleid"/>
        </set>
</class>


双边多对多

User实体类的注解与单边多对多一样

Role实体类注解也非常的简单:使用@ManyToMany注解，并使用mappedBy属性指定引用对象持有自己的的属性名
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class Role {  
  3.   private int id;  
  4.   private String name;  
  5.   private Set<User> users = new HashSet<User>();  
  6.   
  7.   @Id  
  8.   @GeneratedValue  
  9.   public int getId() {return id;  }  
  10.   
  11.   @ManyToMany(mappedBy="roles")  
  12.   public Set<User> getUsers() {return users;}  
  13.   
  14.   public voidsetUsers(Set<User> users) {this.users = users;    
  15. }  
@Entity
public class Role {
  private int id;
  private String name;
  private Set<User> users = new HashSet<User>();

  @Id
  @GeneratedValue
  public int getId() {return id;  }

  @ManyToMany(mappedBy="roles")
  public Set<User> getUsers() {return users;}

  public voidsetUsers(Set<User> users) {this.users = users;  
}


[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.User" table="t_user">  
  2.         <id name="id"column="id">  
  3.             <generator class="native"/>  
  4.         </id>  
  5.         <property name="name"/>  
  6.         <set name="roles" table="t_user_role">  
  7.             <key column="userid"/>  
  8.             <many-to-many class="com.clf.hibernate.Role" column="roleid"/>  
  9.         </set>  
  10.     </class>  
  11.   
  12. <class name="com.clf.hibernate.Role" table="t_role">  
  13.         <id name="id">  
  14.             <generator class="native"/>  
  15.         </id>  
  16.         <property name="name" column="name"/>  
  17.         <set name="users" table="t_user_role"order-by="userid">  
  18.             <key column="roleid"/>  
  19.             <many-to-many class="com.clf.hibernate.User" column="userid"/>  
  20.         </set>    
  21. </class>  
<class name="com.clf.hibernate.User" table="t_user">
        <id name="id"column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="roles" table="t_user_role">
            <key column="userid"/>
            <many-to-many class="com.clf.hibernate.Role" column="roleid"/>
        </set>
    </class>

<class name="com.clf.hibernate.Role" table="t_role">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <set name="users" table="t_user_role"order-by="userid">
            <key column="roleid"/>
            <many-to-many class="com.clf.hibernate.User" column="userid"/>
        </set>  
</class>


component（组件）关联映射

例如有以下两个实体类：用户与员工，两者存在很多相同的字段，但是两者有不可以是同一个类，这样在实体类中每次都要输入很多信息，现在把其中共有部分抽取出来成为一个类，然后在用户、员工对象中引用就可以
值对象没有标识，而实体对象具有标识，值对象属于某一个实体，使用它重复使用率提升，而且更清析。
以上关系的映射称为component（组件）关联映射
在hibernate中，component是某个实体的逻辑组成部分，它与实体的根本区别是没有oid，component可以成为是值对象（DDD）。
采用component映射的好处：它实现了对象模型的细粒度划分，层次会更加分明，复用率会更高。
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.User" table="t_user">  
  2.       <id name="id" column="id">  
  3.           <generator class="native"/>  
  4.       </id>  
  5.       <property name="name" column="name"/>  
  6.       <component name="contact">  
  7.           <property name="email"/>  
  8.           <property name="address"/>  
  9.           <property name="zipCode"/>  
  10.           <property name="contactTel"/>            
  11.       </component>  
  12.   </class>  
<class name="com.clf.hibernate.User" table="t_user">
      <id name="id" column="id">
          <generator class="native"/>
      </id>
      <property name="name" column="name"/>
      <component name="contact">
          <property name="email"/>
          <property name="address"/>
          <property name="zipCode"/>
          <property name="contactTel"/>          
      </component>
  </class>


[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. public class User {  
  3.     private int id;  
  4.     private String name;     
  5.     private Contact contact;//值对象的引用     
  6.   
  7.     @Id  
  8.     @GeneratedValue  
  9.     public int getId() {    return id;}  
  10.   
  11.     @Embedded//用于注解组件映射，表示嵌入对象的映射  
  12.     public Contact getContact() {return contact;}  
  13.     public void setContact(Contactcontact) {this.contact = contact;}   
@Entity
public class User {
    private int id;
    private String name;   
    private Contact contact;//值对象的引用   

    @Id
    @GeneratedValue
    public int getId() {    return id;}

    @Embedded//用于注解组件映射，表示嵌入对象的映射
    public Contact getContact() {return contact;}
    public void setContact(Contactcontact) {this.contact = contact;}


Contact类是值对象，不是实体对象，是属于实体类的某一部分，因此没有映射文件

Contact值对象：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class Contact {  
  2.   private String email;    
  3.   private String address;  
  4.   private String zipCode;  
  5.   private String contactTel;  
  6.   //setter、getter略  
  7. }  
public class Contact {
  private String email;  
  private String address;
  private String zipCode;
  private String contactTel;
  //setter、getter略
}


继承关联映射

继承映射：就是把类的继承关系映射到数据库里(首先正确的存储，再正确的加载数据)
继承关联映射的分类：
单表继承：每棵类继承树使用一个表(table per class hierarchy)
具体表继承：每个子类一个表(table per subclass)
类表继承：每个具体类一个表(table per concrete class)(有一些限制)

下面用一个实例来说明三种继承关系的用法和区别：

动物Animal有三个基本属性，然后有一个Pig继承了它并扩展了一个属性，还有一个Brid也继承了并且扩展了一个属性


 
Animal实体类：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class Animal {  
  2.   private int id;  
  3.   private String name;     
  4.   private boolean sex;  
  5.   public int getId() {return id;  }  
  6.   public void setId(int id) { this.id = id;}  
  7.   public String getName() {return name;}  
  8.   public void setName(Stringname) {this.name = name;}  
  9.   public boolean isSex() {return sex;}  
  10.   public void setSex(boolean sex) {this.sex = sex;}   
  11. }  
public class Animal {
  private int id;
  private String name;   
  private boolean sex;
  public int getId() {return id;  }
  public void setId(int id) { this.id = id;}
  public String getName() {return name;}
  public void setName(Stringname) {this.name = name;}
  public boolean isSex() {return sex;}
  public void setSex(boolean sex) {this.sex = sex;} 
}


Pig实体类：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class Pig extends Animal {  
  2.   private int weight;  
  3.   public int getWeight() {return weight;}  
  4.   public void setWeight(int weight) {this.weight = weight;}  
  5. }  
public class Pig extends Animal {
  private int weight;
  public int getWeight() {return weight;}
  public void setWeight(int weight) {this.weight = weight;}
}


Bird实体类：
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class Bird extends Animal {  
  2.   private int height;  
  3.   public int getHeight() {return height;}  
  4.   public void setHeight(int height) {this.height = height;}   
  5. }  
public class Bird extends Animal {
  private int height;
  public int getHeight() {return height;}
  public void setHeight(int height) {this.height = height;} 
}


单表继承
把所有的属性都要存储表中，目前至少需要5个字段，另外需要加入一个标识字段(表示哪个具体的子类)
 
其中：
           ①、id:表主键
           ②、name:动物的姓名，所有的动物都有
           ③、sex:动物的性别，所有的动物都有
           ④、weight:只有猪才有
           ⑤、height：只有鸟才有
           ⑥、type:表示动物的类型；P表示猪；B表示鸟
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="Animal" table="t_animal" lazy="false">  
  2.     <id name="id">  
  3.         <generator class="native"/>  
  4.     </id>  
  5.     <discriminator column="type" type="string"/>  
  6.     <property name="name"/>  
  7.     <property name="sex"/>  
  8.     <subclass name="Pig" discriminator-value="P">  
  9.         <property name="weight"/>  
  10.     </subclass>  
  11.     <subclass name="Bird" discriminator-value="B">  
  12.         <property name="height"/>  
  13.     </subclass>  
  14. </class>  
  <class name="Animal" table="t_animal" lazy="false">
      <id name="id">
          <generator class="native"/>
      </id>
      <discriminator column="type" type="string"/>
      <property name="name"/>
      <property name="sex"/>
      <subclass name="Pig" discriminator-value="P">
          <property name="weight"/>
      </subclass>
      <subclass name="Bird" discriminator-value="B">
          <property name="height"/>
      </subclass>
  </class>


父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型，如：<discriminator column="XXX" type="string"/>
子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）  的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标  签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值  是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

annotation注解
父类中注解如下：
使用@Inheritance注解为继承映射，再使用strategy属性来指定继承映射的方式
strategy有三个值：InheritanceType.SINGLE_TABLE           单表继承
                  InheritanceType.TABLE_PER_CLASS       类表继承
                  InheritanceType.JOINED                具体表继承
再使用@DiscriminatorColumn注意标识字段的字段名，及字段类型
在类中使用@DiscriminatorValue来注解标识字段的值
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Inheritance(strategy=InheritanceType.SINGLE_TABLE)  
  3. @DiscriminatorColumn(  
  4. name="discriminator",  
  5. discriminatorType=DiscriminatorType.STRING)  
  6. @DiscriminatorValue("type")  
  7. public class Animal {……}  
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name="discriminator",
discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("type")
public class Animal {……}


继承类中注解如下：

    只需要使用@DiscriminatorValue来注解标识字段的值


具体表继承
每个类映射成一个表(table per subclass)，所以Animal也映射成一张表(t_animal),表中字段为实体类属性
而pig子类也需要映射成一张表(t_pid)，但为了与父类联系需要加入一个外键(pidid)指向父类映射成的表(t_animal),字段为子类的扩展属性。Bird子类同样也映射成一张表(t_bird),也加入一个外键(birdid)指向父类映射成的表(t_animal),字段为子类的扩展属性。
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.Animal" table="t_animal">  
  2.         <id name="id"column="id"><!-- 映射主键 -->  
  3.             <generator class="native"/>  
  4.         </id>  
  5.         <property name="name"/><!-- 映射普通属性 -->  
  6.         <property name="sex"/>  
  7.         <!--joined-subclass标签：每个类映射成一个表 -->  
  8.         <joined-subclass name="com.clf.hibernate.Pig" table="t_pig">  
  9. <!-- <key>标签：会在相应的表（当前映射的表）里，加入一个外键 , 参照指向当前类的父类(当前Class标签对象的表(t_animal))-->  
  10.             <key column="pigid"/>  
  11.             <property name="weight"/>  
  12.         </joined-subclass>  
  13.         <joined-subclass name="com.clf.hibernate.Bird" table="t_bird">  
  14.             <key column="birdid"/>  
  15.             <property name="height"/>  
  16.         </joined-subclass>  
  17.     </class>  
<class name="com.clf.hibernate.Animal" table="t_animal">
        <id name="id"column="id"><!-- 映射主键 -->
            <generator class="native"/>
        </id>
        <property name="name"/><!-- 映射普通属性 -->
        <property name="sex"/>
        <!--joined-subclass标签：每个类映射成一个表 -->
        <joined-subclass name="com.clf.hibernate.Pig" table="t_pig">
<!-- <key>标签：会在相应的表（当前映射的表）里，加入一个外键 , 参照指向当前类的父类(当前Class标签对象的表(t_animal))-->
            <key column="pigid"/>
            <property name="weight"/>
        </joined-subclass>
        <joined-subclass name="com.clf.hibernate.Bird" table="t_bird">
            <key column="birdid"/>
            <property name="height"/>
        </joined-subclass>
    </class>


这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。如：<key column="PARENT_KEY_ID"/>，这里的column，实际上就是父类的主键对应的映射字段名称。Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

annotation注解
因为子类生成的表需要引用父类生成的表，所以只需要在父类设置具体表继承映射就可以了，其它子类只需要使用@Entity注解就可以了
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Inheritance(strategy=InheritanceType.JOINED)  
  3. public class Animal {……}  
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
public class Animal {……}

具体表继承效率没有单表继承高，但是单表继承会出现多余的庸于字段，具体表层次分明


类表继承
每个具体类(Pig、Brid)映射成一个表(table per concrete class)(有一些限制)
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. <class name="com.clf.hibernate.Animal" table="t_animal">  
  2.         <id name="id"column="id"><!-- 映射主键 -->  
  3.             <generator class="assigned"/><!-- 每个具体类映射一个表主键生成策略不可使用native -->         
  4.          </id>    
  5.         <property name="name"/><!-- 映射普通属性 -->  
  6.         <property name="sex"/>  
  7.         <!--使用<union-subclass>标签来映射"每个具体类映射成一张表"的映射关系，实现上上面的表t_animal虽然映射到数据库中，但它没有任何作用。      -->  
  8.         <union-subclass name="com.clf.hibernate.Pig" table="t_pig">  
  9.             <property name="weight"/>  
  10.         </union-subclass>  
  11.         <union-subclass name="com.clf.hibernate.Bird" table="t_bird">  
  12.             <property name="height"/>  
  13.         </union-subclass>  
  14. </class>  
<class name="com.clf.hibernate.Animal" table="t_animal">
        <id name="id"column="id"><!-- 映射主键 -->
            <generator class="assigned"/><!-- 每个具体类映射一个表主键生成策略不可使用native -->       
		 </id>  
        <property name="name"/><!-- 映射普通属性 -->
        <property name="sex"/>
        <!--使用<union-subclass>标签来映射"每个具体类映射成一张表"的映射关系，实现上上面的表t_animal虽然映射到数据库中，但它没有任何作用。      -->
        <union-subclass name="com.clf.hibernate.Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="com.clf.hibernate.Bird" table="t_bird">
            <property name="height"/>
        </union-subclass>
</class>


如果不想t_animal存在(因为它没有实际的作用)，可以设置<class>标签中的abstract="true"(抽象表)，这样在导出至数据库时，就不会生成t_animal表了
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
父类用普通<class>标签定义即可
子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
Union-subclass标签不再需要包含key标签（与joined-subclass不同）
Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。
注意：在保存对象的时候id是不能重复的（不能使用自增生成主键）

annotation注解
只需要对父类进行注解就可以了，因为子类表的ID是不可以重复，所以一般的主键生成策略已经不适应了，只有表主键生成策略。
首先使用@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)来注解继承映射，并且使用具体表继承方式，使用@TableGenerator来申明一个表主键生成策略再在主键上@GeneratedValue(generator="t_gen", strategy=GenerationType.TABLE)来注解生成策略为表生成策略，并且指定表生成策略的名称继承类只需要使用@Entity进行注解就可以了
[java] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Entity  
  2. @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)  
  3. @TableGenerator(  
  4.       name="t_gen",  
  5.       table="t_gen_table",  
  6.       pkColumnName="t_pk",  
  7.       valueColumnName="t_value",  
  8.       pkColumnValue="person_pk",  
  9.       initialValue=1,  
  10.       allocationSize=1  
  11.       )  
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@TableGenerator(
      name="t_gen",
      table="t_gen_table",
      pkColumnName="t_pk",
      valueColumnName="t_value",
      pkColumnValue="person_pk",
      initialValue=1,
      allocationSize=1
      )



三种继承关联映射的区别：
第一种：它把所有的数据都存入一个表中，优点：效率好（操作的就是一个表）；缺点：存在庸于字段，如果将庸于字段设置为非空，则就无法存入数据；
第二种：层次分明，缺点：效率不好（表间存在关联表）
第三种：主键字段不可以设置为自增主键生成策略。
LLYJ666666
关注
专栏目录
Hibernate对象关系映射
lvdingding的专栏
12-20 315
一个对象/关系型映射一般定义在 XML 文件中。映射文件指示 Hibernate 如何将已经定义的类或类组与数据库中的表对应起来。 尽管有些 Hibernate 用户选择手写 XML 文件，但是有很多工具可以用来给先进的 Hibernate 用户生成映射文件。这样的工具包括 XDoclet, Middlegen 和 AndroMDA。 让我们来考虑我们之前定义的 POJO 类，它的对象将延续到下一部分定义的表中。 public class Employee { private int id;
java 实体类注解_Hibernate实体映射配置1（java@注解方式）
weixin_32924159的博客
02-21 938
实体和数据库之间存在某种映射关系，hibernate根据这种映射关系完成数据的存取。在程序中这种映射关系由映射文件(*.hbm.xml)或者java注解(@)定义。本文以java注解的形式总结映射关系配置。实体类组件以及注解标签映射关系实体类-----------@Entity/@Table----------数据表Id--------------@Id----------主键普通属性------...
Hibernate之实体关系映射
weixin_30262255的博客
03-06 204
延迟加载与即时加载 例如Person类和Email类是一对多关系，如果设为即时加载，当加载Person时，会自动加载Email，如果设置为延迟加载，当第一次调用person.getEmails()时才会执行SQL语句加载Email 注解配置时，@OnetToMany(Fetch = FetchType.EAGER)为即时加载，Fetch = FetchType.LAZY为延迟加载 ...
怎么在Hibernate实体间建立映射关系
maoyeqiu的专栏
12-25 1504
在之前的文章中，我们已经了解了Hibernate实体的四种持久状态，我们注意到当标注了特定的注解之后Hibernate可以标识java 对象为持久状态。否则他们就是普通的java对象没有和数据库由直接的关系。当我们在java类上标注了JPA注解并使他们成为持久实体之后，我们面对的一个问题就是两个实体间可以有一种关系而且必须一个实体引用另一个实体，以一种直接或者间接的方式，在我们创建两个实体的引用之
8.Hibernate关联映射注解之多对多双向外键关联
qq_39039017的博客
07-17 217
关系映射级别注解： &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 1.一对一单向外键 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; 2.一对一双向外键关联 &amp;nbsp; &amp;nbsp; &amp;nbsp; &
hibernate映射的两种方式
fengfangyuan的博客
12-13 551
hibernate映射的两种方式将实体类映射到数据库中的表的方式有两种，包括通过xml文件映射以及通过注解映射。个人认为通过注解映射更加直观，出错率低一些吧。下面是简单的步骤介绍以及代码演示。 一、xml方式进行映射1.在hibernate.cfg.xml为映射进行配置（需要放在src目录下，否则需要重新设置映射的路径）<?xml version="1.0" encoding="UTF-8"?> <
Hibernate常见误区——正确区分值对象和实体对象
SpringsSpace
02-08 210
声明：该部分内容参考http://blog.csdn.net/gudong2945/article/details/7050196         值对象和实体对象是Hibernate的重要概念，当然在jpa中也有相应的概念,他们在语义上是相同的。常常听 到人们抱怨Hibernate中对象之间的映射关系配置很难，而且经常出现一些莫名奇妙的问题。其真正原因是没有 正确的区分值对象和实体对象而...
Hibernate组件映射代码详解
08-28
Session是指Hibernate框架中用于管理数据库连接的对象，事务是指Hibernate框架中用于管理数据库事务的机制。 7. 组件关联映射的实现方式 组件关联映射的实现方式包括： * 通过组件标签(component)在配置文件中...
hibernate对象关系映射案例demo
03-04
**hibernate对象关系映射案例demo** 在Java开发领域，对象关系映射（ORM）是一种将数据库中的数据与程序中的对象进行关联的技术，它极大地简化了数据操作。Hibernate作为一款流行的ORM框架，使得开发者无需关注底层...
hibernate中的对象关系映射
08-29
【hibernate中的对象关系映射】是Java开发中一种重要的技术，它允许开发者使用面向对象的方式来处理数据库操作，从而避免了直接与SQL打交道的复杂性。Hibernate是Java领域的一个ORM框架，它提供了数据持久化的解决...
Hibernate映射之实体映射<转载>
alexhill2009的博客
08-15 183
实体类与数据库之间存在某种映射关系，Hibernate依据这种映射关系完成数据的存取，因此映射关系的配置在Hibernate中是最关键的。Hibernate支持xml配置文件与@注解配置两种方式。xml配置文件是最基础的配置，而@注解是Java的官方JPA（JavaPersistenceAPI）提供的。本章分别使用@注解与xml讲解Hibernate的映射配置。 10.1实...
Hibernate关联映射（非常详细）
youandme520的专栏
02-12 1733
在前面的学习中，我们所涉及的都是基于单表的操作，但在实际的开发过程中，基本上都是同时对多张表的操作，且这些表都存在一定的关联关系。 Hibernate 是一款基于 ORM 设计思想的框架，它将关系型数据库中的表与我们 Java 实体类进行映射，表中的记录对应实体类的对象，而表中的字段对应着实体类中的属性。Hibernate 进行增删改查等操作时，不再直接操作数据库表，而是对与之对应的实体类对象进行处理。那么，Hibernate 是如何处理多表关联问题的呢？本节我们针对此问题进行介绍。 关联映射 在关系型
Hibernate实体映射
aa18229927211的博客
06-12 270
1.在HIbernate实体映射中,存在着3种关系:多对一、一对多、多对多,下面我为大家介绍Hibernate实体映射的相关步奏和技巧 2.Hibernate实体映射步奏:    2.1  写注释:  ?属性,本对象与 ? 的 ?关系    2.2  拷模板:   多对一:                           一对多 :                        
Hibernate 之实体类之间的关系
言叶水吉的博客
08-22 2090
1.一对一：如一个公民对应一张身份证。 package com.zking.entity; public class User { private int uid; private String uname; private Card card; public Card getCard() { return card; } public void setCard(Card
基于Java的Hibernate对象关系映射框架设计源码
最新发布
09-24
该项目是基于Java的Hibernate对象关系映射框架设计源码，包含11786个文件，其中Java源文件10296个，XML配置文件794个，SQL脚本235个，AsciiDoc文档71个，HTML文件60个，CSS样式表59个，JavaScript脚本59个，属性文件...
Hibernate 对象关系映射
10-18
本人在厦门邦初培训时候用的ppt 快速入门文档 内容： 建立一对多的关联关系域模型 建立一对多的参照关系的模型 映射一对多关联关系 通过hibernateAPI级联操作关联对象 其它关系的映射：一对一，多对多
Hibernate的关联关系
逗逗大魔王的博客
11-23 523
一.什么是hibernate的关联关系hibernate框架是与数据库打交道的，而数据库是存储数据的，有些数据之间有些内在联系，hibernate将对象之间通过某种方式联系起来，世界万物都有联系的，如用户和身份证，你创建了一个用户的一个数据库表，而每个用户要有身份证，所以你还要创建一个装身份证的一个数据库表，但你怎么把它们联系起来，或者说怎么分清楚哪个用户是哪个身份证，这就是我们要学的hiberna
Hibernate映射解析——七种映射关系
dengyll的专栏
07-19 504
首先我们了解一个名词ORM，全称是（Object Relational Mapping），即对象关系映射。ORM的实现思想就是将关系数据库中表的数据映射成对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作。Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。 Hibernate在实现ORM功能的时候...
Hibernate 的一对多自关联
zimuliusu的博客
10-27 486
关于查询权限菜单的加载一般有两种方法： 1，直接查询出全部的菜单加载到浏览器页面 2，类似于Hibernate中的懒加载，第一次加载一级节点与二级节点， 当点击二级节点再去后台查询三级节点用于浏览器的展示 实体类 package com.more.entity; import java.util.ArrayList; import java.util.List; public class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值