hibernate常用注解&映射关系

简介

在hibernate中用到的注解以及注解的参数整理(或许不全,欢迎指正)
整理了下几种关系映射的使用方法

hibernate注解

注解需要添加到属性上,或者getter方法上面,不能混用

序号	注解	作用	用法
1	@Entity	将一个类声明为一个实体bean(即一个持久化POJO类	一般实体类都要加上这个注释
2	@Table	用来标记该实体类映射到数据库中的表的表名	可添加参数来说明表名@Table(name=”table_name”)
3	@Id	说明该属性为主键	直接添加@Id
4	@GeneratedValue	注解声明了主键的生成策略性	1.strategy:指定生成的策略,默认是GenerationType. AUTO; (1)TABLE：使用一个特定的数据库表格来保存主键。 (2)SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 (3)IDENTITY：主键由数据库自动生成（主要是自动增长型） (4)AUTO：主键由程序控制 2.generator:指定生成主键使用的生成器
5	@Column	注解声明了属性到列的映射	@Column()注解内的属性 1.name:可选，列名（默认值是属性名） 2.insertable:可选，该列是否作为生成的insert语句中的一个列(是否忽略)（默认值true） 3.updatable:可选，该列是否作为生成的update语句中的一个列（默认值true） 4.unique:可选，是否在该列上设置唯一约束（默认值false） 5.nullable:可选，是否设置该列的值可以为空（默认值false） 6.columnDefinition:可选，为这个特定列覆盖sql ddl片段（这可能导致无法在不同数据库间移植） 7.table:可选，定义对应的表（默认为主表） 8.length:可选，列长度（默认值255） 9.precision:可选，列十进制精度（decimal precision)(默认值0） 10.scale:可选，如果列十进制数值范围（decimal scale）可用，在此设置（默认值0）
6	@OneToOne	建立持久化类之间的一对一关联关系	@OneToOne()注解内的属性 1. cascade为联级级别 2.mappedBy:该属性的值是所对应的另一方的变量 3.fetch:加载的策略 4.optional:定义该关联类是否必须存在 5.targetEntity:定义关系类的类型
7	@OneToMany	建立持久化类之间的一对多关联关系，通常用于Set变量	@OneToMany注解内的属性: 1. mappedBy:该属性的值是“多”方class里的“一”方的变量名 2. fetch:加载的策略,默认值是FetchType.LAZY,表示关系类在被访问时才加载 3. cascade:该属性定义类和类之间的级联关系 4. targetEntity:定义关系类的类型，默认是该成员属性对应的类类型
8	@ManyToOne	建立持久化类之间的多对一关联关系	@ManyToOne注释有四个属性：targetEntity、cascade、fetch 和optional: 1. 前三个属性含义和@OneToMany相同 2. optional属性是定义该关联类是否必须存在,optional属性的默认值是true。值为false 时，关联类双方都必须存在，如果关系被维护端不存在，查询的结果为null。值为true 时, 关系被维护端可以不存在，查询的结果仍然会返回关系维护端，在关系维护端中指向关系被维护端的属性为null
9	@ManyToMany	建立持久化类之间的多对多关联关系	@ManyToMany注释有四个属性：targetEntity、cascade、fetch 和mappeBy
10	@joinColumn	指明该变量映射到数据库中表的列名	作用于@ManyToOne标注后的变量
11	@Transient	指明被标注的变量不需要被映射到数据库表中	忽略这个属性
12	@MappedSuperclass	表明该类作为父类被其他实体类继承后，其它实体类可以继承该类的属性，并且结合各子类各自映射对应的表，然后改父类不映射到数据库表	这个和上面的@Entity可以说二者只能选其一: 如果选择@MappedSuperclass则不映射表 如果用@Entity则会映射到表
13	@Inheritance	定义继承的策略	@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)上面的InheritanceType.TABLE_PER_CLASS是指每个子类都成为一个新表
14	@JsonIgnoreProperties	忽略属性
15	@GenericGenerator	声明了一个hibernate的主键生成策略	支持十三种策略主键策略参考链接
16	@PrimaryKeyJoinColumn	主键相关联	这种方法要求主表与从表的主键值相对应
17	@JoinTable	与@Table注释类似，用于标注用于关联的表,通过表关联的方式来映射一对多或者多对多的关系时	@JoinTable()主要属性: 1.name属性为连接两个表的表名称 2.joinColumns属性表示，在保存关系中的表中，所保存关联关系的外键的字段。并配合@JoinColumn标记使用 3.inverseJoinColumns属性与joinColumns属性类似，它保存的是保存关系的另一个外键字段

映射关系

1. 一对一映射关联

一对一映射有两种方式:
主键关联:其中一个表的主键参照另外一张表的主键而建立起一对一关联关系
外键关联:本质上是一对多的蜕化形式。在<many-to-one>元素中设置unique=”true就变成了一对一

注解的方式:

@Entity
@Table(name = "t_person")
public class Person {
    @Id

    private int id;
    private String name;

    @OneToOne(cascade = CascadeType.ALL, fetch=FetchType.LAZY)
    //@PrimaryKeyJoinColumn //主键关联
    @JoinColumn(name = "idcard", nullable = false, updatable = false) //外键关联,外键在Person表中
    private IDCard idCard;
    ...
}

@Entity
@Table(name = "t_idcard")
public class IDCard {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String cardNo;
    // 如果一对一单向映射不需要这个注解,双向映射则需要添加
    // 双向映射要注意循环引用
    @OneToOne(mappedBy="idCard") //idCard:person中idcard对象的属性
    private Person person;
    ...
}

XML配置的方式

Person.hum.xml配置

    <hibernate-mapping>  
        <class name="Person" table="sc_person">  
            <id name="id" column="id" type="int">  
                <generator class="increment"></generator>  
            </id>  
            <property name="name" column="name" type="string"></property>  
            <!--使用<one-to-one>表示一对一关联-->  
            <one-to-one name="idCard" class="IDCard" cascade="all"></one-to-one>  
        </class>  
    </hibernate-mapping>  

IDCard.hbm.xml配置:

    <hibernate-mapping>  
        <class name="IDCard" table="sc_idcard" >  
            <id name="id" column="id" type="int">  
            <!-- 表示该表的主键值参照“user属性对应的表的主键”的值，注意：但id并不是外键！ -->  
                <generator class="foreign">  
                <param name="property">person</param>  
                </generator>  
            </id>  
            <property name="number" column="number" type="string"></property>  
            <!-- 一对一关联 -->  
            <one-to-one name="person" class="Person" ></one-to-one>  
        </class>  
    </hibernate-mapping>  

外键关联:

<!-- 修改Person.hbm.xml中的<one-to-one>为<many-to-one>: -->
<many-to-one name="idCard" class="IDCard" cascade="all" update="true"></many-to-one> 

<!-- 修改IDCard.hbm.xml中的<one-to-one>为<many-to-one>且自己生成主键：-->
<id name="id" column="id" type="int">  
    <generator class="increment"></generator>  
</id>  
<many-to-one name="person" class="Person" cascade="all" unique="true"></many-to-one>  

2. 一对多关系映射

注解的方式:

// one的一方
@Entity
@Table(name = "t_classess")
public class Classes {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "classes")
    private Set<Student> students; 
    ...
}

// many的一方
@Entity
@Table(name = "t_student")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "classesid")
    private Classes classes;
    ...
}

xml配置的方式

student.hbm.xml

<hibernate-mapping package="com.great.entity">
    <!-- 配置实体类与数据库表的映射关系 -->
    <class name="Student" table="t_studnet">
        <!-- 配置主键映射关系 -->
        <id name="id" column="id" type="int">
            <!-- 配置主键生成策略 -->
            <generator class="identity">
            </generator>
        </id>
        <!-- 配置属性和表字段映射关系 -->
        <property name="name" column="name" type="string"></property>
        <!-- 多对一关联关系配置 -->
        <!-- many-to-one标签声明多对一关联关系，name指定多方所维护的一方的实例名 -->
        <many-to-one name="classes" class="Classes"
            cascade="save-update">
            <!-- column标签指定关联外键，还是子表的外键列名 -->
            <column name="classesid"></column>
        </many-to-one>
    </class>

classes.hbm.xml

<hibernate-mapping package="com.great.entity">
    <class name="Classes" table="t_classess">
        <!-- 配置主键映射关系 -->
        <id name="id" column="id" type="int">
            <!-- 配置主键生成策略 -->
            <generator class="identity">
            </generator>
        </id>
        <!-- 配置属性和表字段映射关系 -->
        <property name="name" column="name" type="string"></property>
        <!-- 一对多关联关系配置 -->
        <!-- inverse属性设置为true代表一的一方不在拥有关联关系的控制权，而把控制权交给多的一方 -->
        <!-- fetch属性用来指定子表数据的抓取策略，默认值为"select"，代表对主表子表进行单独查询 ，对主表子表单独发select语句 -->
        <!-- fetch属性用来指定子表数据的抓取策略，设置为"join"时，代表对主表子表进行关联查询，对主表子表发出关联查询语句 -->
        <!-- lazy属性用来指定子表数据是否延迟加载，fetch="select"时起作用，fetch="join"时不起作用 -->
        <!-- fetch="select" lazy="true" -->
        <set name="students" cascade="all" inverse="true">
            <!-- key配置的是子表的外键列名 -->
            <key column="classes"></key>
            <!-- one-to-many标签声明关联关系是一对多，class指定多方的实体类类型 -->
            <one-to-many class="Student" />
        </set>
    </class>
</hibernate-mapping>

3. 多对多关系映射

注解的方式

数据库中表

// Teacher.java
@ManyToMany(cascade = CascadeType.ALL, targetEntity=Student.class)
@JoinTable(name = "t_tStudent", joinColumns = { @JoinColumn(name="tid")}, inverseJoinColumns = {
            @JoinColumn(name="sid") })
private Set<Student> students;


// Student.java
@ManyToMany(cascade = CascadeType.ALL, targetEntity=Teacher.class)
    @JoinTable(name = "t_tStudent", joinColumns = { @JoinColumn(name="sid")}, inverseJoinColumns = {
            @JoinColumn(name="tid") })
private Set<Teacher> teachers;

xml配置方式

Student.hbc.xml

<hibernate-mapping>
    <class name="Student" table="t_student">
        <id name="sid" type="int">
            <column name="id" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="name" length="32" />
        </property>
        <!-- 通过table属性告诉hibernate中间表，cascade指明级联操作的类型，inverse属性说明Student实体类是主控方，负责维护关系表 --> 
        <set name="teachers" table="t_tStudent" cascade="save-update,delete" inverse="false">
        <!-- 通过key属性告诉hibernate在中间表里面查询sid值相应的student记录 --> 
            <key>
                <column name="sid" not-null="true" />
            </key>
             <!-- 通过column项告诉hibernate对teacher表中查找tid值相应的teacher记录 --> 
            <many-to-many class="Teacher" column="tid"/>
        </set>
    </class>
</hibernate-mapping>

Teacher.hbm.xml

<hibernate-mapping>
    <class name="com.db.Teacher" table="t_teacher">
        <id name="id" type="int">
            <column name="tid" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="name" length="32" />
        </property>
        <!-- 通过table属性告诉hibernate中间表，cascade指明级联操作的类型，inverse属性说明Teacher实体类是被控方，不负责维护关系表 ，不能触发对象和数据库的同步更新的。-->
        <set name="students" table="t_tStudent" inverse="true"
            cascade="save-update,delete">
            <key>
                <column name="tid" not-null="true" />
            </key>
            <many-to-many class="Student" column="sid" />
        </set>
    </class>
</hibernate-mapping>