首页 > 代码库 > Hibernate中的注解说明

Hibernate中的注解说明

Hibernate中注解注解比较多,常用的也就那么几个,在这里把Hibernate中的注解汇总总结一下。

@Entity:将一个类声明为一个实体bean,即一个持久化POJO;

@Id:声明bean的标识属性,即和表中的主键对应的属性;

@Table:声明bean映射数据库中指定的表;

@Column:声明bean的属性到表的列的映射,该注解还有以下属性:

  • name:可选,属性要映射的列明,如果属性名和列名相同则可以省略;
  • unique:可选,是否在该列上设置唯一约束,默认值为false;
  • nullable:可选,该列是否可以为空,默认值为false;
  • insertable:可选,该列是否作为生成的insert语句的列,默认值为true;
  • updatable:可选,该列是否作为生成的update语句的列,默认值为true;
  • columnDefinition:可选,为这个特定类覆盖sql ddl片段,可能导致无法在不同的数据库之间移植,慎用;
  • table:可选,定义对应的表,默认为主表;
  • length:可惜俺,列长度,默认值为255;
  • precision:可选,列值数字的有效位数;
  • scale:可选,列值数字小数点右边的位数,默认值为0;

@GenerateValue:声明主键的生成策略,该注解还有以下属性:

  • strategy:指定生成策略,类型为GenerationType,默认值为GenerationType.AUTO;
    • GenerationType.AUTO:主键由程序控制;
    • GenerationType.TABLE:使用一个特定的数据库表来存储主键;
    • GenerationType.IDENTITY:主键由数据库自动生成,主要是自动增长类型;
    • GenerationType.SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库要支持序列,要与generator一起使用;
  • generator:指定生成主键的生成器;

@SequenceGenerator:声明一个数据库序列,该注解还有以下属性:

  • name:主键生成策略的名称,它被引用在@GeneratorValue中设置的“generator”中;
  • sequenceName:生成策略用到的数据库序列名称;
  • initialValue:主键初始值,默认值为0;
  • allocationSize:每次主键增加的大小;

@GenericGenerator:声明一个hibernate的主键生成策略,有十三种生成策略。该注解还有以下属性:

  • name:指定生成器名称;
  • strategy:指定具体生成器的类名,指定生成策略;
  • parameters:得到strategy指定的具体生成器所用到的参数;
  • 十三种生成策略(strategy属性的值)如下:
    • native:oracle采用Sequence方式,MySql和Sql Server采用identify方式。native就是将主键的生成工作交给数据库来完成,hiberante不管,很常用。
    • uuid:采用128为的uuid算法生成主键,uudi被编码为一个32位16进制数字的字符串。占用空间较大。
    • hilo:要在数据库中建立一张额外的表,默认表明是hibernate_unique_key,默认字段是integer类型,名称是next_hi,比较少用。
    • assigned:在插入数据时主键有程序处理,这是generator没有指定时默认的生成策略。等同于JPA中的AUTO,很常用。
    • identity:使用Sql Server和MySql时的自增字段,oracle中不能使用。Sql Server和MySql中很常用。
    • select:使用触发器生成主键,主要用于早期的数据库主键生成机制,少用。
    • sequence:调用谨慎数据库的序列来生成主键,要设定序列名,不然hibernate无法找到。
    • seqhilo:用过hilo算法实现,但是主键历史保存在sequence中,适用于支持sequence的数据库,少用。
    • increment:插入数据时hibernate会给主键添加一个自增的主键,但是一个hibernate实例就维护一个计数器,所以在多个hibernate实例运行是不能使用这个方法。
    • foreign:使用另一个相关对象的主键。通常和one-to-one联合起来使用。
    • guid:使用数据库底层的guid算法机制,对应MySql的uuid()函数,SqlServer的newid()函数,oracle的rawtohex(sys_guid())函数等。
    • uudi_hex:参照uuid,建议用uuid替换。
    • sequence-identify:sequence策略的扩展,采用立即检索策略来获取sequence值,需要jdcb3.0和jdk4以上版本。

@OneToOne:设置一对一关联。

示例:

 1 @Entity
 2 public class Hansband {
 3     private int id;
 4     private String username;
 5     private Wife wife;
 6    
 7     @Id
 8     @GeneratedValue(strategy = GenerationType.IDENTITY)
 9     public int getId() {
10         return id;
11     }
12    
13     @Column
14     public String getUsername() {
15         return username;
16     }
17     /**
18       * @OneToOne:一对一关联
19       * cascade:级联,它可以有有五个值可选,分别是:
20       * CascadeType.PERSIST:级联新建
21       * CascadeType.REMOVE : 级联删除
22       * CascadeType.REFRESH:级联刷新
23       * CascadeType.MERGE  : 级联更新
24       * CascadeType.ALL    : 以上全部四项
25       * @JoinColumn:主表外键字段
26       * wifeId:Hansband所映射的表中的一个字段
27       */
28     @OneToOne
29     @JoinColumn(name="wifeId")
30     public Wife getWife() {
31         return wife;
32     }
33     public void setId(int id) {
34         this.id = id;
35     }
36     public void setUsername(String username) {
37         this.username = username;
38     }
39     public void setWife(Wife wife) {
40         this.wife = wife;
41     }
42 }
43 
44 
45 @Entity
46 public class Wife {
47     private int id ;
48     private String username;
49     private Hansband hansband;
50    
51     @Id
52     @GeneratedValue(strategy = GenerationType.AUTO)
53     public int getId() {
54         return id;
55     }
56     public String getUsername() {
57         return username;
58     }
59     public void setId(int id) {
60         this.id = id;
61     }
62     public void setUsername(String username) {
63         this.username = username;
64     }
65    /**
66      * @OneToOne:一对一关联
67      * mappedBy = "wife":意思是说这里的一对一配置参考了wife
68      * wife又是什么呢?wife是Husband类中的getWife(),注意不是Husband类中的
69      * wife属性,Husband类中的OneToOne配置就是在getWife()方法上面配的.
70      * 如果Husband类中的getWife()方法改成getNewHusband(),其他不变的话,
71      * 这里就要写成:mappedBy = "new Husband"
72      */
73     @OneToOne(mappedBy="wife")
74     public Hansband getHansband() {
75         return hansband;
76     }
77     public void setHansband(Hansband hansband) {
78         this.hansband = hansband;
79     }
80 }
View Code

@OneToMany和@ManyToOne:设置一对多和多对一关联。

示例:

@Entity
@Table(name = "t_employee")
public class Employee {

    private Integer employeeId;
    private String  employeeName;
    private Company company;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getEmployeeId() {
        return employeeId;
    }
     /**
      * @ManyToOne:多对一关联
      * cascade:级联,它可以有有五个值可选,分别是:
      * CascadeType.PERSIST:级联新建
      * CascadeType.REMOVE : 级联删除
      * CascadeType.REFRESH:级联刷新
      * CascadeType.MERGE  : 级联更新
      * CascadeType.ALL    : 以上全部四项
      * fetch = FetchType.LAZY,延迟加载策略,如果不想延迟加载可以用FetchType.EAGER
      * @JoinColumn:主表外键字段
      * cid:Employee所映射的表中的一个字段
      */
    @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH},fetch = FetchType.LAZY)
    @JoinColumn(name = "cid")
    public Company getCompany() {
        return company;
    }
    public String getEmployeeName() {
        return employeeName;
    }
    public void setEmployeeId(Integer employeeId) {
        this.employeeId = employeeId;
    }
    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }
    public void setCompany(Company company) {
        this.company = company;
    }
}


@Entity
@Table(name = "t_company")
public class Company {

    private Integer companyId;
    private String  companyName;
    private Set<Employee> employees;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer getCompanyId() {
        return companyId;
    }
    /**
     * @OneToMany:一对多关联
     * mappedBy = "company":意思是说这里的一对一配置参考了company
     * company又是什么呢?company是Employ类中的getCompany(),注意不是Employ类中的
     * company属性,Employ类中的OneToMany配置就是在getCompany()方法上面配的.
     * 如果Employ类中的getCompany()方法改成getNewCompany(),其他不变的话,
     * 这里就要写成:mappedBy = "newCompany"
     */
    @OneToMany(mappedBy = "company")
    public Set<Employee> getEmployees() {
        return employees;
    }
    public String getCompanyName() {
        return companyName;
    }
    public void setCompanyId(Integer companyId) {
        this.companyId = companyId;
    }
    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }
    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}
View Code

@ManyToMany:设置多对多关联。

@Entity
@Table(name="rong_user")
public class User{

    //省略其它内容

    private Set<Role> roles = new LinkedHashSet<Role>();//角色集合
    
    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    //name是数据库中间表名
    @JoinTable(name = "rong_user_role", joinColumns = { @JoinColumn(name ="user_id" )}, inverseJoinColumns = { @JoinColumn(name = "role_id") })
    @OrderBy("id")
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
}


@Entity
@Table(name="rong_role")
public class Role{
    
    //省略其它内容

    private Set<User> user = new LinkedHashSet<User>();//用户集合

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "roles", fetch = FetchType.LAZY)
    public Set<User> getUser() {
        return user;
    }
    public void setUser(Set<User> user) {
        this.user = user;
    }
}
View Code