Hibernate注解的使用

喜欢ヅ旅行 2022-05-29 23:06 311阅读 0赞

# 说明 #

学习一下hibernate注解的使用

# 正文 #

Hibernate注解主要分为三类，分别是类级别注解，属性级别注解，映射关系注解

## 类级别注解 ##

类级别注解主要有**@Entity** **@Table** **@Embeddable** …

### @Entity ###

映射实体类，使用时实体类必须指定主键属性  
@Entity(name = “tableName”)  
其中name属性可选，对应数据库中的一个表，若表名和实体类名相同，则可以省略

### @Table ###

表示实体对应的数据库表的信息，配合@Entity使用，只能标注在实体的class定义处  
@Table(name = “tableName”）  
name可选，表示映射表的名称，默认表名和类名相同，只有在不一致的情况下才需要制定

### @Embeddable ###

表示一个非Entity类可以嵌入到另一个Entity类中，作为属性而存在。通常，将多个实体类共有的属性抽取出来，生成一个属性类，使用该注解

## 类注解使用示例 ##

注意：使用注解后，必须在hibernate.cfg.xml配置文件中配置类— <mapping class=”*\**“/>

import javax.persistence.Embeddable;
    
    @Embeddable
    public class Address { 
        private String street; //街道
        private String houseNum; //门牌号
        private String postCode;//邮编
        public String getStreet() {
            return street;
        }
        public void setStreet(String street) {
            this.street = street;
        }
    
        public String getHouseNum() {
            return houseNum;
        }
        public void setHouseNum(String houseNum) {
            this.houseNum = houseNum;
        }
        public String getPostCode() {
            return postCode;
        }
        public void setPostCode(String postCode) {
            this.postCode = postCode;
        }
    
    
    }

import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name="t_student")
    public class Student { 
    
        @Id
        private int sid; //学号
        private String sname; // 姓名
        private String gender; // 性别
    // private String address; //家庭住址
    
        private Address address;
    
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    
    
    }

执行结果：  
![这里写图片描述][20180227172104654]

## 属性级别注解 ##

属性级别注解主要有：**@Id** **@GeneratedValue** **@GenericGenerator** **@SequenceGenerator** **@Column** **@Embedded** **@EmbeddedId** **@Lob** **@Version** **@Basic** **@Transient**  
**@Temporal**

注解可以放在属性上，也可以放在get()方法上，但通常放在get()方法上

## 与主键相关的注解 ##

### @Id ###

指定类的主键，当类使用@Entity时，必须使用该注解指定主键。当类有多个主键时，实体类必须实现serializable接口

### @GeneratedValue ###

此注解是可选的，用于指定主键生成策略  
@GeneratedValue(strategy=GenerationType.\*,generator=”“)  
strategy表示主键生成策略，共有四种方式,由JPA提供：  
**AUTO** : 根据底层数据库自动选择，为默认值  
**IDENTITY** : 对DB2，MySQL,MS SQL Server,Sybase和HypersonicSQL的内置标识字段提供支持，返回的标识符是long,short或者int类型的  
**SEQUENCE** : 使用Sequence来决定主键的取值，Oracle适用，没有自增长类型  
**TABLE** : 使用指定表来决定主键取值，结合@TableGenerator使用

**generator** 表示主键生成器的名称，这个属性通常和ORM框架有关

**复习一下Hibernate常用的主键生成策略：**  
**native** : 根据底层数据库的能力自动选择，对于Oracle采用sequence方式，对于MySQL和SQL Server采用indentity(自增主键生成机制）

**assigned** : 让应用程序在save()之前分配一个标识符，这是generator没有指定时的默认策略

**increment** : 用于为long,short或者int类型生成唯一标识,插入数据时由Hibernate给主键添加一个自增的主键，但是一个Hibernate实例只维护一个计数器，不能在集群下使用

**uuid** : 用一个128-bit的UUID算法生成字符串类型的标识符，在这一个网络中是唯一的（使用了IP地址），UUID被编码为一个32位16进制数字的字符串,生成策略： 使用了主机的网卡地址+随机数

**identity** : 对DB2，MySQL,MS SQL Server,Sybase和HypersonicSQL的内置标识字段提供支持，返回的标识符是long,short或者int类型的

### @GenericGenerator ###

和@GeneratedValue配和使用  
使用方式：  
@GeneratedValue(generator = “generatorName”)  
@GenericGenerator(name = “generatorName”, strategy = “”)

当主键为String类型时，应使用assgined策略  
使用方法

@Id  
@GeneratedValue(generator = “assigned”)  
@GenericGenerator(name = “assigned”, strategry = “assigned”)

### @SequenceGenerator ###

声明了一个数据库序列  
属性：  
name ：表示该主键生成策略的名称，被引用在@GeneratorValue的generator属性中  
sequenceName：表示生成策略用到的数据库序列名称  
initialValue：表示主键初始值，默认为0  
allocationSize：每次主键值增加的大小，默认为50

### @EmbeddedId ###

使用嵌入式主键类实现复合主键  
注意：嵌入式主键必须实现Serializable接口，必须由默认的public无参数的构造方法，必须覆盖equals和hashCode方法

## 非主键相关 ##

### @Column ###

可将属性映射到列，使用该注解来覆盖默认值，@Column描述了数据库表中该字段的详细定义，这对于根据JPA注解生成数据库表结构的工具非常有作用  
常用属性：  
**name**：可选，表示数据库表中该字段的名称，默认情况与属性一致  
**nullable**：可选，表示该字段是否允许为null，默认为true  
**unique**：表示该字段是否是唯一标识，默认为false  
**length**：可选，表示该字段的大小，仅对String类型的字段有效，默认值为255  
**insertable**：可选，表示在ORM框架执行插入操作时，该字段是否应出现在INSERT语句中，默认为true  
**updateable**：可选，表示在ORM框架执行更新操作时，该字段是否应该出现在UPDATA语句中，默认为true，对于一经创建就不可更改的字段，该属性十分有用，如birthday字段

### @Embedded ###

注解属性，表示该属性的类是嵌入类  
注意：同时嵌入类也必须标注@Embeddable注解

### @Version ###

使用该注解添加对乐观锁定的支持

### @Basic ###

该注解映射属性到数据库的一个列，该属性为一个单独的，非聚合的java类型，这是默认的注解

声明存取策略  
@Basic(fetch=FetchType.EAGER) 及时获取（默认存取策略）  
@Basic(fetch=FetchType.LAZY) 延时获取

### @Temporal ###

用于定义映射到数据库的时间精度  
@Temporal(TemporalType=DATE) 日期  
@Temporal(TemporalType=TIME) 时间  
@Temporal(TemporalType=TIMESTAMP) 两者兼具

### @Transient ###

表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性，如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则ORM框架默认其注解为@Basic

### @Lob ###

表示实体属性是一个大型对象类型

## 属性注解使用示例 ##

import javax.persistence.Column;
    import javax.persistence.Embeddable;
    
    @Embeddable
    public class Address { 
        private String street; //街道
        private String houseNum; //门牌号
        private String postCode;//邮编
    
        @Column(name="STREET",length=150)
        public String getStreet() {
            return street;
        }
        public void setStreet(String street) {
            this.street = street;
        }
    
        @Column(name="HOUSENUM",length=30)
        public String getHouseNum() {
            return houseNum;
        }
        public void setHouseNum(String houseNum) {
            this.houseNum = houseNum;
        }
    
        @Column(name="POSTCODE",length=6)
        public String getPostCode() {
            return postCode;
        }
        public void setPostCode(String postCode) {
            this.postCode = postCode;
        }
    
    
    }

import java.io.Serializable;
    import java.util.Date;
    
    import javax.persistence.Column;
    import javax.persistence.Embedded;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Lob;
    import javax.persistence.Table;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    
    @Entity
    @Table(name="t_student")
    public class Student implements Serializable{ 
    
    
        private int sid; //学号
        private String sname; // 姓名
        private String gender; // 性别
        private Address address; // 地址
        private Date birthday; // 出生年月日
        private String introduce; // 个人介绍
    
        @Id
        @Column(name="SID")
        @GeneratedValue(strategy=GenerationType.AUTO)
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
    
        @Column(name="SNAME",length=40)
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
    
        @Column(name="GENDER",length=10)
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        @Embedded
        public Address getAddress() {
            return address;
        }
        public void setAddress(Address address) {
            this.address = address;
        }
    
        @Temporal(TemporalType.DATE)
        @Column(name="BIRTHDAY",updatable=false)
        public Date getBirthday() {
            return birthday;
        }
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @Lob
        @Column(name="INTRODUCE")
        public String getIntroduce() {
            return introduce;
        }
        public void setIntroduce(String introduce) {
            this.introduce = introduce;
        }
    
    
    }

执行结果：  
![这里写图片描述][20180227212444889]

## 映射关系注解 ##

常用映射关系注解：**@OneToOne** **@OneToMany** **@ManyToOne** **@ManyToMany**

### 多种映射关系的定义及注解 ###

一对一单向外键 @OneToOne  
一对一双向外键关联 @OneToOne(mappedBy=”xx”)  
一对一单向外键联合主键 @Embeddable @EmbeddedId  
多对一单向外键关联 @ManyToOne @JoinColumn  
一对多单向外键关联 @OneToMany @JoinColumn  
一对多双向外键关联 @ManyToOne @OneToMany @JoinColumn  
多对多单向外键关联 @ManyToMany @JoinTable  
多对多双向外键关联 @ManyToMany(mappedBy=”xx”) @JoinTable

### 实体之间的映射关系 ###

一对一：一个公民对应一个身份证号码  
一对多（多对一）：一个公民有多个银行账号  
多对多：一个学生有多个老师，一个老师有多个学生

关系维护：  
单向：关系写哪边，就由谁管理  
双向：一般由多方管理

### 注解的共有属性 ###

**fetch 配置加载方式**  
Fetch.EAGER 及时加载 @ManyToOne默认是Fetch.EAGER  
Fetch.LAZY 延迟加载（懒加载）@OneToMany默认是Fetch.LAZY

**cascade 设置级联方式**  
CascadeType.PERSIST 保存  
CascadeType.REMOVE 删除  
CascadeType. MERGE 修改  
CascadeType.REFRESH 刷新  
CascadeType.ALL 全部

**mappedBy 反向配置**  
@OneToOne(mappedBy=”xx”)  
相当于inverse为true，放弃维护关系，由对方管理  
xx为主控方持有被控方的引用名

### @OneToOne ###

**单向外键关联**

在主控方进行配置注解  
@OneToOne(cascade=CascadeType.ALL)  
@JoinColumn(name=”xx”,unique=true) 参数name为被控类主键，unique标识该主键唯一 xx是被控类的主键，主控类的外键

**双向外键关联**  
在主控方注解如上

在被控方注解：  
@OneToOne(mappedBy=”xx”) xx 为主控方持有被控方的对象名

双向关联，必须设置mappedBy属性，因为双向关联只能交给一方去控制，不可能在双方都设置外键保存关联关系，否则双方都无法保存

### 使用示例 ###

import java.util.Date;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.OneToOne;
    import javax.persistence.Table;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    
    import org.hibernate.annotations.GenericGenerator;
    
    @Entity
    @Table(name="oto_idcard")
    public class IdCard { 
    
        private String cardNum; // 身份证号
        private String name; //姓名
        private String gender; //性别
        private String nation; //民族
        private Date birthday;//出生日期
        private Student student; // 与学生一对一关系 此时是双向外键关联
    
    
        @Id
        @Column(name="CARDNUM",length=18)
        @GeneratedValue(generator="assigned")
        @GenericGenerator(name="assigned",strategy="assigned")
        public String getCardNum() {
            return cardNum;
        }
        public void setCardNum(String cardNum) {
            this.cardNum = cardNum;
        }
    
        @Column(name="NAME",length=20)
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Column(name="GENDER",length=10)
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
        @Column(name="NATION",length=20)
        public String getNation() {
            return nation;
        }
        public void setNation(String nation) {
            this.nation = nation;
        }
        @Temporal(TemporalType.DATE)
        @Column(name="BIRTHDAY")
        public Date getBirthday() {
            return birthday;
        }
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @OneToOne(mappedBy="idcard") //由学生控制关系
        public Student getStudent() {
            return student;
        }
        public void setStudent(Student student) {
            this.student = student;
        }
    
    
    
    }

import java.io.Serializable;
    
    import javax.persistence.CascadeType;
    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.OneToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name="oto_student")
    public class Student implements Serializable{ 
    
    
        private int sid; //学号
        private String major; //专业
        private IdCard idcard; //身份证 一对一关系
    
    
        @Id
        @Column(name="SID")
        @GeneratedValue(strategy=GenerationType.AUTO)
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
    
        @Column(name="MAJOR",length=15)
        public String getMajor() {
            return major;
        }
        public void setMajor(String major) {
            this.major = major;
        }
    
        @OneToOne(cascade=CascadeType.ALL)
        @JoinColumn(name="CARDNUM",unique=true)
        public IdCard getIdcard() {
            return idcard;
        }
        public void setIdcard(IdCard idcard) {
            this.idcard = idcard;
        }
    
    
    }

执行结果：  
![这里写图片描述][20180228092059221]

### @OneToMany @ManyToOne ###

**多对一单向外键关联**  
多方持有一方的引用，比如多个学生对应一个班级

在多方进行配置注解：  
@ManyToOne(cascade=CascadeType.ALL, fetch=FetchType.EAGER)  
@JoinColumn(name=”xx”,referencedColumnName=”XX”)

其中在@JoinColumn中，参数name指的是多方数据库表中的外键列名，referencedColumnName指的是一方数据库表中的列名，即为主键列名，通常两者设置一致，当referencedColumnName不写时，默认为一方数据库表的主键列

**一对多单向外键关联**  
一方持有多方的集合，比如一个班级有多个学生（一对多）

在一方进行配置注解：  
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY)  
@JoinColumn(name=”xx”)

**一对多（多对一）双向外键**  
多方：多方持有一方的引用  
@ManyToOne(cascade=CascadeType.ALL, fetch=FetchType.EAGER)  
@JoinColumn(name=”xx”)

一方：一方持有多方的集合  
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY)  
@JoinColumn(name=”xx”)

注意：两方配置中@JoinColumn的name属性值必须相等，在此双方关系中不需要配置mappedBy

### 使用示例 ###

import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;
    
    import org.hibernate.annotations.GenericGenerator;
    
    @Entity
    @Table(name="mto_classRoom")
    public class ClassRoom { 
    
        private String cid; // 班级编号
        private String cname; // 班级名称
        private Set<Student> students; //持有学生集合
    
        @Id
        @Column(name="CID",length=15)
        @GeneratedValue(generator="assigned")
        @GenericGenerator(name="assigned",strategy="assigned")
        public String getCid() {
            return cid;
        }
        public void setCid(String cid) {
            this.cid = cid;
        }
    
        @Column(name="CNAME",length=30)
        public String getCname() {
            return cname;
        }
        public void setCname(String cname) {
            this.cname = cname;
        }
    
        @OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
        @JoinColumn(name="CID")
        public Set<Student> getStudents() {
            return students;
        }
        public void setStudents(Set<Student> students) {
            this.students = students;
        }
    
    
    }

import java.io.Serializable;
    import java.util.Date;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.Lob;
    import javax.persistence.ManyToOne;
    import javax.persistence.Table;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    
    @Entity
    @Table(name="mto_student")
    public class Student implements Serializable{ 
    
    
        private int sid; //学号
        private String sname; // 姓名
        private String gender; // 性别
        private Date birthday; // 出生年月日
        private String introduce; // 个人介绍
        private ClassRoom classRoom;// 班级 多对一的关系
    
        @Id
        @Column(name="SID")
        @GeneratedValue(strategy=GenerationType.AUTO)
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
    
        @Column(name="SNAME",length=40)
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
    
        @Column(name="GENDER",length=10)
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        @Temporal(TemporalType.DATE)
        @Column(name="BIRTHDAY",updatable=false)
        public Date getBirthday() {
            return birthday;
        }
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @Lob
        @Column(name="INTRODUCE")
        public String getIntroduce() {
            return introduce;
        }
        public void setIntroduce(String introduce) {
            this.introduce = introduce;
        }
    
        @ManyToOne(cascade=CascadeType.ALL, fetch=FetchType.EAGER)
        @JoinColumn(name="CID")
        public ClassRoom getClassRoom() {
            return classRoom;
        }
        public void setClassRoom(ClassRoom classRoom) {
            this.classRoom = classRoom;
        }
    
    
    }

执行结果：  
![这里写图片描述][20180228111705301]

### @ManyToMany ###

**多对多单向外键**  
学生和老师构成多对多的关联关系  
其中一个多方持有另一个多方的集合对象（学生持有老师的集合）  
创建中间表，保存关系

在学生类中进行配置注解：  
@ManyToMany  
@JoinTable(name = “teachers\_students”,JoinColumns = \{ @JoinColumn(name = “sid”)\}, inverseJoinColumns=\{@JoinColumn(name = “tid”)\})

**多对多双向外键**  
双方都持有对方的集合对象，其中一方必须放弃维护外键关系

在教师方配置注解，教师持有学生的集合  
@ManyToMany(mappedBy=”teachers”)  
mappedBy的值为学生持有教师集合的属性名

在学生方配置如上

### 使用示例 ###

import java.util.Set;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    
    import org.hibernate.annotations.GenericGenerator;
    
    @Entity
    @Table(name="mtm_teacher")
    public class Teacher { 
    
        private String tid; //教师编号
        private String tname;// 教师姓名
        private Integer tage; //教师年龄
        private String tgender; //教师性别
        private Set<Student> students; // 学生集合
    
        @Id
        @Column(name="TID",length=15)
        @GeneratedValue(generator="assigned")
        @GenericGenerator(name="assigned",strategy="assigned")
        public String getTid() {
            return tid;
        }
        public void setTid(String tid) {
            this.tid = tid;
        }
        @Column(name="TNAME",length=30)
        public String getTname() {
            return tname;
        }
        public void setTname(String tname) {
            this.tname = tname;
        }
        @Column(name="TAGE")
        public Integer getTage() {
            return tage;
        }
        public void setTage(Integer tage) {
            this.tage = tage;
        }
    
        @Column(name="TGENDER",length=15)
        public String getTgender() {
            return tgender;
        }
        public void setTgender(String tgender) {
            this.tgender = tgender;
        }
    
        @ManyToMany(mappedBy="teachers")
        public Set<Student> getStudents() {
            return students;
        }
        public void setStudents(Set<Student> students) {
            this.students = students;
        }
    
    }

import java.io.Serializable;
    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.JoinColumn;
    import javax.persistence.JoinTable;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    
    @Entity
    @Table(name="mtm_student")
    public class Student implements Serializable{ 
    
    
        private int sid; //学号
        private String sname; // 姓名
        private String gender; // 性别
        private Set<Teacher> teachers; //教师 多对多关系
    
        @Id
        @Column(name="SID")
        @GeneratedValue(strategy=GenerationType.AUTO)
        public int getSid() {
            return sid;
        }
        public void setSid(int sid) {
            this.sid = sid;
        }
    
        @Column(name="SNAME",length=40)
        public String getSname() {
            return sname;
        }
        public void setSname(String sname) {
            this.sname = sname;
        }
    
        @Column(name="GENDER",length=10)
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        @ManyToMany
        @JoinTable(name="teachers_students",
                             joinColumns={
       @JoinColumn(name="SID")},
                             inverseJoinColumns={
       @JoinColumn(name="TID")})
        public Set<Teacher> getTeachers() {
            return teachers;
        }
        public void setTeachers(Set<Teacher> teachers) {
            this.teachers = teachers;
        }
    
    
    
    }

执行结果：  
![这里写图片描述][20180228121703795]

参考资料：  
[Hibernate注解使用方法总结][Hibernate]  
[@GeneratedValue][GeneratedValue]  
[Hibernate官方文档][Hibernate 1]

源码地址：  
[https://github.com/Edenwds/hibernateanno][https_github.com_Edenwds_hibernateanno]

[20180227172104654]: /images/20220530/0d865c93e2e94ac39febfdff9f6844d2.png
[20180227212444889]: /images/20220530/9085f87b1ff54eb088a0c7616ca98e00.png
[20180228092059221]: /images/20220530/4ea208996cd4456e9b532add21b14a63.png
[20180228111705301]: /images/20220530/629d5144c587451bbe232cd2d6e13e08.png
[20180228121703795]: /images/20220530/7db89d48938243e9bec91d242c4b92e8.png
[Hibernate]: http://blog.csdn.net/arybd/article/details/52065030
[GeneratedValue]: http://blog.csdn.net/fancylovejava/article/details/7438660
[Hibernate 1]: http://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/Hibernate_User_Guide.html#annotations
[https_github.com_Edenwds_hibernateanno]: https://github.com/Edenwds/hibernateanno