才高行厚的hibernate(2)---hibernate的映射

最新推荐文章于 2019-07-28 15:49:53 发布
最新推荐文章于 2019-07-28 15:49:53 发布
阅读量1.7k 收藏
点赞数
分类专栏： 才高行厚 才高行厚的hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Senssic/article/details/13283905
版权

集合映射

1.使用xml

集合类：
一下类全部省略getter和setter方法 
package hibernate.senssic.mapping;


import java.util.List;
import java.util.Map;
import java.util.Set;


public class CollectionMapping {
	private String cid;
	private String desc;
	private Set<Student> studs;
	private List<Teacher> lteach;
	private Map<String, String> mtuds;
	private Set<Student> bagstuds;
	private List<Teacher> idbagltuds;
	private String[] strs;

}
辅助类student： 
package hibernate.senssic.mapping;


import java.util.Date;


public class Student {
	private String id;
	private Date name;

}

辅助类teacher类： 
package hibernate.senssic.mapping;


public class Teacher {
	private String id;
	private String name;
	private int inx;

}
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 package="hibernate.senssic.mapping">
    <!-- 上面已经配置package，下面的class只需要写类名即可 -->
      <class name="CollectionMapping">
         <id name="cid">
           <!--有这么几种设置：
increment用于为long, short或者int类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。
identity
对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。 返回的标识符是long, short 或者int类型的。
sequence
在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)， 而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。
hilo
使用一个高/低位算法高效的生成long, short 或者 int类型的标识符。给定一个表和字段（默认分别是 hibernate_unique_key 和next_hi）作为高位值的来源。 高/低位算法生成的标识符只在一个特定的数据库中是唯一的。
seqhilo
使用一个高/低位算法来高效的生成long, short 或者 int类型的标识符，给定一个数据库序列（sequence)的名字。
uuid
用一个128-bit的UUID算法生成字符串类型的标识符， 这在一个网络中是唯一的（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。
guid
在MS SQL Server 和 MySQL 中使用数据库生成的GUID字符串。
native
根据底层数据库的能力选择identity, sequence 或者hilo中的一个。
assigned
让应用程序在save()之前为对象分配一个标示符。这是 <generator>元素没有指定时的默认生成策略。
select
通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。
foreign
使用另外一个相关联的对象的标识符。通常和<one-to-one>联合起来使用。 -->
           <generator class="uuid"></generator>
         </id>
         <property name="desc" column="des" length="200" ></property>
         <!-- 数组的映射 -->
         <array name="strs" table="aray" >
         <key column="aryid"></key>
            <index column="strinx"></index>
            <element column="str" type="string"></element>
         </array>
         <!-- set映射不可重复，不记录顺序 -->
         <set name="studs" table="sstudent"  >
           <key column="cid" not-null="true"></key>
           <element column="name" type="java.util.Date"></element>
         </set>
         <!-- List映射可重复，但需记录顺序,需要有记录索引 -->
         <list name="lteach" table="teacher">
           <key column="cid"  not-null="true"></key>
           <index column="inx" type="int"></index>
           <element column="name" type="string"></element>
         </list>
         <!-- map映射需要对应的key和value映射 -->
         <map name="mtuds" table="mstudent" >
           <key column="cid" not-null="true"></key>
          <map-key type="string" column="mkey"></map-key>
          <element type="string" column="value"></element>
         </map>
         <!-- bag映射可重复，且不记录顺序。 -->
         <bag name="bagstuds">
           <key column="cid"  not-null="true"></key>
            <element column="name" type="java.util.Date"></element>
         </bag>
         <!-- idbag映射集合映射的一种扩展。可以在定义Bag映射时，为每一个添加的对象指定“id”，让Hibernate可以直接确定要更新的数据。 -->
         <idbag name="idbagltuds">
          <collection-id type="int" column="inx">
             <generator class="uuid"></generator>
           </collection-id>
            <key column="cid" ></key>
            <element column="name" type="java.util.Date"></element>
         </idbag>
         
      </class>
    </hibernate-mapping>

2.使用注解

在hibernate配置文件中加入： 
<mapping class="hibernate.senssic.mapping.CollectionMapping"/> 
       <mapping class="hibernate.senssic.mapping.Student"/> 
       <mapping  class="hibernate.senssic.mapping.Teacher"/>
主类Collectionmapping类： 
package hibernate.senssic.mapping;

import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MapKey;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.IndexColumn;

@Entity
@Table(name = "collectionmap")
public class CollectionMapping {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;

	@Column(length = 200)
	private String des;
	@OneToMany(mappedBy = "cid")
	private Set<Student> studs;
	@OneToMany(mappedBy = "cid")
	@IndexColumn(name = "id")
	private List<Teacher> teacher;
	@OneToMany(mappedBy = "cid")
	@MapKey
	private Map<Integer, Student> mapts;
	@OneToMany(mappedBy = "cid")
	@IndexColumn(name = "id")
	private Student[] stuts;

	
}
辅类student类： 
package hibernate.senssic.mapping;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Student {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@Column(name = "sdate")
	private Date name;
	@ManyToOne
	@JoinColumn(name = "cid", nullable = false, referencedColumnName = "id")
	private CollectionMapping cid;

	
}

辅类Teacher类： 
package hibernate.senssic.mapping;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Teacher {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@Column
	private String name;
	@Column
	private int inx;
	@ManyToOne
	@JoinColumn(name = "conid", referencedColumnName = "id", nullable = false)
	private CollectionMapping cid;

}

组件映射

特点：一个表映射多个类

1.使用xml配置

主类User类： 
package hibernate.senssic.component;

public class User {
	private int id;
	private String name;
	private String pasd;
	private Pro pro;

}
辅类Pro类： 
package hibernate.senssic.component;

public class Pro {
	private String address;
	private int phon;

	
}
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 package="hibernate.senssic.component">
    <class name="User">
       <id name="id">
         <generator class="uuid"></generator>
       </id>
       <property name="name" ></property>
       <property name="pasd"></property>
       <component name="pro" class="Pro">
           <property name="address"></property>
           <property name="phon"></property>
       </component>
    </class>
    </hibernate-mapping>
若想实现双向关联，即从profile对象也可找到user对象，只需
在以上的基础上，改动两个地方：A.在profile类中增加user对象属性。B.在映射文件的<component></component>中增加一行
 <parent name="user"/>

2.使用注解

user类： 
package hibernate.senssic.component;

import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	@Column
	private String name;
	@Column
	private String pasd;
	@Embedded
	private Pro pro;

	
}

Pro类： 
package hibernate.senssic.component;

import javax.persistence.Column;
import javax.persistence.Embeddable;

import org.hibernate.annotations.Parent;

@Embeddable
public class Pro {
	@Parent
	private User user;
	@Column
	private String address;
	@Column
	private int phon;

	
}
组件集合映射
其实和集合映射类似，只是在将集合作为属性时，集合里的元素不是表中的一个字段（基本类型），而是由组件（复合类型：类）映射表示。
配置时，在<set></set>中添加： 

 <set name="user" table="sstudent"  >
           <composite-element class="Pro">
             <property name="adderss"></property>
             <property name="phon"></property>
           </composite-element>
         </set>
如果也想实现双向关联除了在Pro中加入user还需要配置 

<composite-element class="Pro">
              <parent name="user"/>
             <property name="adderss"></property>
             <property name="phon"></property>
           </composite-element>

关联映射

单向关联

一对一外键单向关联

类：
Person类 
package hibernate.senssic.relevance;

public class Person {
	private int id;
	private String name;
	private Pro pro;

	
}
Pro类 
package hibernate.senssic.relevance;

public class Pro {
	private int aid;
	private String address;
	private String phon;

	
}

配置文件：
person.cfg.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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid"></generator>
        </id>
        <property name="name"></property>
       <many-to-one name="pro" foreign-key="address"></many-to-one><!--一对一外键单向关联-->
      </class>
    </hibernate-mapping>
pro.cfg.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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="uuid"></generator>
      </id>
      <property name="address"></property>
      <property name="phon"></property>
    </class>
    </hibernate-mapping>

一对一主键单向关联

需要改动的地方只有： 
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
            <!--一对一主键关联-->
          <generator class="foreign">
            <param name="property">pro</param>
          </generator>
        </id>
        <property name="name"></property>
       <one-to-one name="pro" constrained="true"></one-to-one>
      </class>
    </hibernate-mapping>

一对一非主键关联

两个类： 
public class Person {
	private int id;
	private String name;
	private Pro pro;
}
public class Pro {
	private int aid;
	private String address;
	private String phon;
}

其中pro要关联的是Pro中的phon！，即两个非主属性关联
配置文件：
Person.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="hibernate.bean.Person">
       <id name="id">
         <generator class="increment"></generator>
       </id>
       <property name="name" ></property>
       <!-- 一对一非主键关联Pro中的phon -->
       <one-to-one name="pro" property-ref="phon" ></one-to-one>
    </class>
  </hibernate-mapping>

Pro.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="hibernate.bean.Pro">
    <id name="aid">
      <generator class="increment"></generator>
    </id>
    <property name="address"  ></property>
    <property name="phon" not-null="true"></property>
    </class>
    </hibernate-mapping>

一对多非主键关联

两个实体类: 
public class Person {
	private int id;
	private String name;
	private Set<Pro> pro;
}

public class Pro {
	private int aid;
	private String address;
	private String phon;
}

一对多关联Person中的name非主字段
映射文件
Person.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="hibernate.bean.Person">
       <id name="id">
         <generator class="increment"></generator>
       </id>
       <property name="name" ></property>
       <!-- 一对多非主键关联Person中的name -->
  <set name="pro" table="pro">
     <key column="proid" property-ref="name"></key>
     <one-to-many  class="hibernate.bean.Pro"/>
  </set>
    </class>
  </hibernate-mapping>
Pro.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="hibernate.bean.Pro">
    <id name="aid">
      <generator class="increment"></generator>
    </id>
    <property name="address"  ></property>
    <property name="phon" not-null="true"></property>
    </class>
    </hibernate-mapping>

一对多外键单向关联

两个类： 
package hibernate.senssic.relevance;

import java.util.Set;

public class Person {
	private int id;
	private String name;
	private Set<Pro> spro;

	
}


package hibernate.senssic.relevance;

public class Pro {
	private int aid;
	private String address;
	private String phon;

}

两个配置文件： 
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid">
           
          </generator>
        </id>
        <property name="name"></property>
        <set name="pro" table="pro">
          <key column="proid"></key>
          <one-to-many class="hibernate.senssic.relevance.Pro"/>
        </set>
      </class>
    </hibernate-mapping>

<?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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="uuid"></generator>
      </id>
      <property name="address"></property>
      <property name="phon"></property>
    </class>
    </hibernate-mapping>

多对一外键单向关联

两个类省略setter和getter方法： 
package hibernate.senssic.relevance;

import java.util.Set;

public class Person {
	private int id;
	private String name;
	private Pro pro;
}


package hibernate.senssic.relevance;

public class Pro {
	private int aid;
	private String address;
	private String phon;
}
只需要更改的配置文件： 
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid">
           
          </generator>
        </id>
        <property name="name"></property>
        <!-- 用来映射关联address在Pro表中的外键列名-->
    <many-to-one name="pro" column="address"></many-to-one>
      </class>
    </hibernate-mapping>

双向关联

一对一外键双向关联

两个类无getter和setter： 
package hibernate.senssic.relevance;

public class Pro {
	private int aid;
	private Person person;
	private String address;
}
package hibernate.senssic.relevance;


public class Person {
	private int id;
	private String name;
	private Pro pro;
}
两个配置文件： 
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid">
           
          </generator>
        </id>
        <property name="name"></property>
       <one-to-one name="pro" property-ref="person"></one-to-one>
    
      </class>
    </hibernate-mapping>

<?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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="uuid"></generator>
      </id>
      <property name="address"></property>
       <many-to-one name="person" column="personid"></many-to-one>
    </class>
    </hibernate-mapping>

一对一主键双向关联

值需要改： 
<?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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="foreign">
         <param name="property">person</param>
       </generator>
      </id>
      <property name="address"></property>
     <one-to-one name="person" constrained="true"></one-to-one>
    </class>
    </hibernate-mapping>

一对多外键双向关联

类： 
package hibernate.senssic.relevance;

import java.util.Set;

public class Person {
	private int id;
	private String name;
	private Set<Pro> pro;
}
package hibernate.senssic.relevance;

public class Pro {
	private int aid;
	private Person person;
	private String address;
}

配置文件： 
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid">
           
          </generator>
        </id>
        <property name="name"></property>
       <set name="pro" inverse="true">
         <key column="addid"></key>
          <one-to-many class="hibernate.senssic.relevance.Pro"/>
       </set>
    
      </class>
    </hibernate-mapping>

<?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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="foreign">
         <param name="property">person</param>
       </generator>
      </id>
      <property name="address"></property>
     <many-to-one  name="person"></many-to-one>
    </class>
    </hibernate-mapping>

多对多双向关联

两个类： 
package hibernate.senssic.relevance;

import java.util.Set;

public class Pro {
	private int aid;
	private Set<Person> person;
	private String address;
}

package hibernate.senssic.relevance;

import java.util.Set;

public class Person {
	private int id;
	private String name;
	private Set<Pro> pro;
}

配置文件： 
<?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="hibernate.senssic.relevance.Pro">
      <id name="aid">
       <generator class="foreign">
         <param name="property">person</param>
       </generator>
      </id>
      <property name="address"></property>
       <set name="pro">
         <key column="proid"></key>
         <many-to-many column="person" class="hibernate.senssic.relevance.Person"></many-to-many>
       </set>
    </class>
    </hibernate-mapping>
<?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="hibernate.senssic.relevance.Person">
        <id name="id">
          <generator class="uuid">
           
          </generator>
        </id>
        <property name="name"></property>
       <set name="pro" inverse="true">
         <key column="personid"></key>
        <many-to-many column="addreid" class="hibernate.senssic.relevance.Pro"></many-to-many>
       </set>
    
      </class>
    </hibernate-mapping>

使用注解实现关系映射：

实例的实体是user和role，主键分别是userid和roleid
 1）一对一外键关联映射（单向）
 @OneToOne(cascade=CascadeType.ALL)  //一对一外键关联，使用@OneToOne，并设置了级联操作
 @JoinColumn(name="userid",unique=true)   //@JoinColum设置了外键的名称为userid（数据库字段名），如果不设置，则默认为另一类的属性名+ _id。外键的值是唯一的(unique)，不可重复，与另一类的主键一直
 
 2）一对一外键关联映射（双向）
 @OneToOne(mappedBy=" role",cascade=CascadeType.ALL)  //一对一双向关联关系，使用@OneToOne。注意：需要加上mappedBy="role"，如果不加上的话， role 也会生成一个外键（user_id），mappedby="role"需要指向与他关联对象的一个属性，说明双向关联关系中，有且仅有一端是作为主体(owner)端存在的，主体端负责维护联接列，对于不需要维护这种关系的从表则通过mappedBy属性进行声明，mappedBy的值指向主体的关联属性
 //规律：只有是双向关联关系，都加上mappedby，cascade=CascadeType.ALL级联


  3)一对一主键关联映射（不重要）
 在实际中很少用，使用注解@PrimaryKeyJoinColumn，意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML映射可以生成。Annotation注解一对一主键关联映，有些bug。不过没空去研究它。因为在实际开发中一对一很少用，主键关联就更少了


 4）多对一关联映射
 多端配置
 @ManyToOne(targetEntity=role.class)  //多对一注解@ManyToOne；targetEntity指定了关联对象
 @JoinColumn(name="userid")  //@JoinColumn(name="userid")指定生产的外键的字段名，默认是org_id


 5)一对多关联映射（单向）
 @OneToMany   //一对多注解@OneToMany（单向）,如果只写@OneToMany的话，hibernate会建一张中间表来维护他们之间的关系
 @JoinColumn(name="roleid")    //加上@JoinColumn(name="roleid")，则不会建中间表，他会在多的一端加上外键roleid，来维护他们之间的关系


 6)一对多关联映射（双向）
 一端配置
 @OneToMany(mappedBy="role")  //一对多双向，在一的一端中设置mappedBy,说明多的一端为主导
 @JoinColumn(name="roleid")  //如果指定了外键字段名称，则多的一端也需要指定相同的字段名称
 多端配置
 @ManyToOne  //一对多双向
 @JoinColumn(name=" roleid ") //需要指定外键与一的一端给的外键名称一致，@JoinColumn(name=" roleid "),也可以不指定，如果在多的一端不指定，则一的一端也不能指定,否则为生成两个外键


 7)多对多关联映射（单向）
 @ManyToMany  //多对多映射：注解@ManyToMany（单向），默认情况下，hibernate会自动的创建一张中间表来维护多对多关系
  默认中间表的名称 ：user_role中间表，字段的名称user_id role_id,如果想更换表名和字段名称，注解如下：
 @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})
 
 8)多对多关联映射（双向）
 user端
 @ManyToMany  //多对多映射：注解@ManyToMany（单向）;默认情况下，hibernate会自动的创建一张中间表，来维护多对多关系;默认中间表的名称 ：user_role中间表，字段的名称user_id role_id
 如果想更换表名和字段名称，注解如下：
 @JoinTable(name="t_u_r",joinColumns={@JoinColumn(name="u_id")},inverseJoinColumns={@JoinColumn(name="r_id")})  //@JoinTable(name="t_u_r"),指定中间表的表名；joinColumns={@JoinColumn(name="u_id")},指定当前对象的外键；inverseJoinColumns={@JoinColumn(name="r_id")},指定关联对象的外键
 role端
 @ManyToMany(mappedBy="role")   //多对多,双向关联映射

继承映射

关系数据库的世界中，表与表之间没有任何关键字可以明确指明这两张表的父子关系，表与表是没有继承关系这样的说法的。为了将程序领域中的继承关系反映到数据中，

Hibernate为我们提供了3中方案：

假设有这么三个类：

public class People
{
    /*父类所拥有的属性*/
    private String id;
    private String name;
    private String sex;
    private String age;
    private Timestamp birthday;
    
    /*get和set方法*/
}



public class Student extends People
{
    /*学生独有的属性*/
    private String cardId;//学号

    public String getCardId()
    {
        return cardId;
    }

    public void setCardId(String cardId)
    {
        this.cardId = cardId;
    }
}

public class Teacher extends People
{
    /*Teacher所独有的属性*/
    private int salary;//工资

    public int getSalary()
    {
        return salary;
    }

    public void setSalary(int salary)
    {
        this.salary = salary;
    }
}

第一种方案：一个子类对应一张表。

<?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="hibernate.senssic.People" abstract="true">
        <id name="id" type="string">
            <column name="id"></column>
            <generator class="uuid"></generator>
        </id>

        <property name="name" column="name" type="string"></property>
        <property name="sex" column="sex" type="string"></property>
        <property name="age" column="age" type="string"></property>
        <property name="birthday" column="birthday" type="timestamp"></property>

        <!-- 
        <union-subclass name="hibernate.senssic.Student" table="student"> 
            <property name="cardId" column="cardId" type="string"></property> 
        </union-subclass> 
        <union-subclass name="hibernate.senssic.Teacher" table="teacher"> 
            <property name="salary" column="salary" type="integer"></property> 
        </union-subclass> 
        -->
    </class>
    <union-subclass name="hibernate.senssic.Student"
        table="student" extends="hibernate.senssic.People">
        <property name="cardId" column="cardId" type="string"></property>
    </union-subclass>

    <union-subclass name="hibernate.senssic.Teacher"
        table="teacher" extends="hibernate.senssic.People">
        <property name="salary" column="salary" type="integer"></property>
    </union-subclass>
</hibernate-mapping>


第二种方案：使用一张表表示所有继承体系下的类的属性的并集。 

<?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="hibernate.senssic.People" table="people">
        <id name="id" type="string">
            <column name="id"></column>
            <generator class="uuid"></generator>
        </id>

        <discriminator column="peopleType" type="string"></discriminator>

        <property name="name" column="name" type="string"></property>
        <property name="sex" column="sex" type="string"></property>
        <property name="age" column="age" type="string"></property>
        <property name="birthday" column="birthday" type="timestamp"></property>

        <subclass name="hibernate.senssic.Student" discriminator-value="student">
            <property name="cardId" column="cardId" type="string"></property>
        </subclass>
        
        <subclass name="hibernate.senssic.Teacher" discriminator-value="teacher">
            <property name="salary" column="salary" type="string"></property>
        </subclass>
    </class>
</hibernate-mapping>


第三种方案：每个子类使用一张表只存储它特有的属性，然后与父类所对应的表以一对一主键关联的方式关联起来。 

<?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="hibernate.senssic.People" table="people">
        <id name="id" type="string">
            <column name="id"></column>
            <generator class="uuid"></generator>
        </id>

        <property name="name" column="name" type="string"></property>
        <property name="sex" column="sex" type="string"></property>
        <property name="age" column="age" type="string"></property>
        <property name="birthday" column="birthday" type="timestamp"></property>
        
        <joined-subclass name="hibernate.senssic.Student" table="student">
            <key column="id"></key>
            <property name="cardId" column="cardId" type="string"></property>
        </joined-subclass>
        
        <joined-subclass name="hibernate.senssic.Teacher" table="teacher">
            <key column="id"></key>
            <property name="salary" column="salary" type="integer"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

使用注解来实现继承映射：

http://blog.csdn.net/senssic/article/details/13421201

hibernate的联合主键

如果使用联合主键，而不是实体对应的id自动生成，则需要抽象出联合主键为一个类，并需要实现序列化接口，和覆盖equals方法，最好覆盖hashCode方法(用于比较对象)。
1.使用xml
抽象主键类： 
package hibernate.senssic.compositeid;

import java.io.Serializable;

public class ComposiTidPK implements Serializable {
	// 联合主键，使用name和email作为主键，需要实现序列化接口，和覆写hashCode和equals方法
	private String name;
	private String email;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((email == null) ? 0 : email.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ComposiTidPK other = (ComposiTidPK) obj;
		if (email == null) {
			if (other.email != null)
				return false;
		} else if (!email.equals(other.email))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

实体类： 
package hibernate.senssic.compositeid;

import java.util.Date;

public class ComposiTid {
	private String adder;
	private Date date;
	private ComposiTidPK cPk;

	public String getAdder() {
		return adder;
	}

	public void setAdder(String adder) {
		this.adder = adder;
	}

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

	public ComposiTidPK getcPk() {
		return cPk;
	}

	public void setcPk(ComposiTidPK cPk) {
		this.cPk = cPk;
	}
}

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 package="hibernate.senssic.compositeid">
     <class name="ComposiTid">
         <composite-id name="cPk">
              <key-property name="name"></key-property>
              <key-property name="email"></key-property>
          </composite-id>
          <property name="adder"></property>
          <property name="date"></property>
      </class>
   </hibernate-mapping>
2.使用注解
抽象联合主键类注解： 
package hibernate.senssic.compositeid;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Embeddable;

@Embeddable
public class ComposiTidPK implements Serializable {
	// 联合主键，使用name和email作为主键，需要实现序列化接口，和覆写hashCode和equals方法
	@Column
	private String name;
	@Column
	private String email;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((email == null) ? 0 : email.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ComposiTidPK other = (ComposiTidPK) obj;
		if (email == null) {
			if (other.email != null)
				return false;
		} else if (!email.equals(other.email))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

}

实体类： 
package hibernate.senssic.compositeid;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class ComposiTid {
	@Column
	private String adder;
	@Column
	private Date date;
	@Id
	private ComposiTidPK cPk;

	public String getAdder() {
		return adder;
	}

	public void setAdder(String adder) {
		this.adder = adder;
	}

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

	public ComposiTidPK getcPk() {
		return cPk;
	}

	public void setcPk(ComposiTidPK cPk) {
		this.cPk = cPk;
	}
}


Senssic
关注
专栏目录
Hibernate：one-to-many（一对多）关联映射详解
SirouW的博客
09-04 3046
对one-to-many关联映射进行论述
Hibernate实现many-to-many的映射关系
08-26
在Java的持久化框架Hibernate中，映射关系是对象关系映射（ORM）的重要组成部分，它使得数据库中的表格数据能够与Java对象模型进行对应。在本文中，我们将深入探讨如何使用Hibernate来实现多对多（many-to-many）的...
使用注解的Hibernate one-to-many映射
maoyeqiu的专栏
12-24 9545
One to many映射关系指的是两个实体间一个实体可以和多个实体有关联关系，但是多的这一端只能和一的这一端的一个实例有关系。它是一个1 到 n的关系。例如在任何的公司员工可以注册多个银行账户，一个银行账户只能和一个员工相关联，在这篇文章中我们将会学习怎么在Hibernate3中建立这种映射关系。 问题陈述 我们要写两个实体一个是Employee实体另一个是Account实体，这样多个银行账
hibernate -- 注解映射实体和表
zhangjunli的博客
09-14 2134
表名的映射 //代表此类参与ORM映射，此注解必须要有 @Entity //代表user这个类映射了一个表user50，如果表名和类名一样，此注解可以省略 @Table(name="user50") public class User { 回到顶部 主键的映射 //主键，此注解必须要有 @Id //数据库表中主键列名为id,如果实体类属性名和列名相...
Hibernate-3.映射(Mapping)
热门推荐
了无牵挂者忘生，心有所爱者忘死
01-04 3万+
3.1多表关系 表和表之间存在的关系就是主外键关系，而对象和对象之间通常存在以下三种关系： 一对一，一对多，多对多 我们首先一起来看看表之间是怎么建立这三种关系的。 一对一：（一个人对应一个身份证号） 一对多：（一个客户对应多个订单） 多对多：（老师可以带多个班级，一个班可以被多个老师带） 3.2 一对多关联关系映射 重点掌握一对多的单向和双向关联映射，开发中最常用 1.创建具备一对多关
使用注解的Hibernate many-to-many映射
maoyeqiu的专栏
12-25 6083
many to many映射是在两个实体间，一个实体可以和其他的多个实体建立关系。例如一个捐赠服务的实体Subscription实体和读取实体都是两个实体，一个捐赠可以有多个读者，一个读者可以有多个捐赠，在这篇文中我们将会学习在Hibernate3中怎么建立这种关系。 提出解决方案 为了演示多对多的关系，我们连接两个实体Reader实体和Subscription实体。他们的实体关系如下：
hibernate映射文件-id属性列表
技术何
01-30 1296
hibernate映射文件-id属性列表
Hibernate旅程（六）Hibernate映射--继承映射
Xinghf
03-10 3443
上篇主要讲述了hibernate的对象关系映射。本篇讲述对象继承关系是如何映射具体的表。  对于继承类映射到表有三种方式: 1、一棵继承树映射一张表。 2、每个子类各自映射表。 3、继承树的每个类各自映射表。   一棵继承树一张表。 直接上图，如下图所示。     映射文件代码如下所示。
jpa.hibernate.ddl-auto属性说明
当当当的博客
07-28 8467
jpa: hibernate: ddl-auto的几个常用属性值： none：默认值，什么都不做，每次启动项目，不会对数据库进行任何验证和操作 create：每次运行项目，没有表会新建表，如果表内有数据会被清空 create-drop：每次程序结束的时候会清空表 update：每次运行程序，没有表会新建表，但是表内有数据不会被清空，只会更新表结构。 validate：运行程序会校...
Hibernate稳定版（hibernate-release-5.3.23.Final.zip）
01-07
Hibernate稳定版（hibernate-release-5.3.23.Final.zip），Hibernate ORM 是一个为应用程序、库和框架提供对象/关系映射 (ORM) 支持的库。它还提供了 JPA 规范的实现，这是 ORM 的标准 Java 规范。
HibernateTools-3.2.4
04-27
4. **JPA注解工具**：允许将传统的Hibernate映射文件转换为Java Persistence API（JPA）的注解形式，方便使用JPA标准进行开发。 5. **Eclipse插件**：Hibernate Tools可以作为Eclipse的插件安装，提供图形化的界面...
Hibernate稳定版（hibernate-release-5.2.18.Final.zip）
01-07
Hibernate稳定版（hibernate-release-5.2.18.Final.zip），Hibernate ORM 是一个为应用程序、库和框架提供对象/关系映射 (ORM) 支持的库。它还提供了 JPA 规范的实现，这是 ORM 的标准 Java 规范。
hibernate-configuration-3.0.dtd、hibernate-mapping-3.0.dtd
10-11
这个文件定义了Hibernate映射文件的语法规则，使得Java对象能够与数据库表进行映射。在Hibernate中，每个Java实体类通常对应一个`.hbm.xml`映射文件，其中包含了对象-关系的映射信息。例如，`<class>`元素表示一个...
Hibernate - 对象关系映射文件(*.hbm.xml)详解
小小默：进无止境
10-07 3730
对象关系映射文件，即POJO 类和数据库的映射文件*.hbm.xml(映射文件的扩展名为 .hbm.xml)。 POJO 类和关系数据库之间的映射可以用一个XML文档来定义。 通过 POJO 类的数据库映射文件，Hibernate可以理解持久化类和数据表之间的对应关系，也可以理解持久化类属性与数据库表列之间的对应关系。 在运行时 Hibernate 将根据这个映射文件来生成各种 SQL 语句。 常...
才高行厚的hibernate(4)---hibernate的HQL语言
Senssic
10-31 2806
hql基本： 检索所有对象：from   类 检索类某几个属性：select 类.属性1，类.属性2 form 类 指定别名：select  类.属性1，类.属性2 from 类 as c where c.主属性=1-->即c为此类的别名 过滤重复值：select distinct 类.属性 from 类 删除对象：delete 类 where 类.属性>10 更新对象值：update
才高行厚的hibernate(7)---hibernate的优化
Senssic
11-03 1946
抓取策略 对集合默认使用延迟select抓取 定义了如下几种抓取策略： 连接抓取（Join fetching） - Hibernate通过 在SELECT语句使用OUTER JOIN（外连接）来 获得对象的关联实例或者关联集合。lazy失效，因为关联对象一并被抓取了 单端： xml配置 注解配置： @ManyToOne @Fetch(FetchMode.JOIN
Hibernate对象-关系映射详解
2. **属性映射**：类中的每个属性都对应着数据库表中的一列。这可以通过配置文件或注解来实现，指定属性的类型、长度、是否可为空等信息。例如，`String`类型的`email`属性可能被映射为一个`varchar`类型的列。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值