笔记47 Hibernate快速入门（四）

Hibernate注解，完成原来xml文件里的映射信息。

使用注解时，要修改hibernate.cfg.xml中的映射，不再是通过xml文件

<mapping class="hibernate.pojo.annotation.Product" />
<mapping class="hibernate.pojo.annotation.Category" />
<mapping class="hibernate.pojo.annotation.User" />

一、类与属性

package hibernate.pojo.annotation;

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.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "product")
public class Product {
    int id;
    String name;
    float price;
    Category category;
    Set<User> users;
    int version;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Column(name = "name")
    public String getName() {
        return name;
    }

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

    @Column(name = "price")
    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    @ManyToOne
    @JoinColumn(name = "cid")
    public Category getCategory() {
        return category;
    }

    public void setCategory(Category category) {
        this.category = category;
    }

    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinTable(name = "user_product", joinColumns = @JoinColumn(name = "pid"), inverseJoinColumns = @JoinColumn(name = "uid"))
    public Set<User> getUsers() {
        return users;
    }

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

    public int getVersion() {
        return version;
    }

    public void setVersion(int version) {
        this.version = version;
    }

}

1.类注解

在上面的代码中，Product类声明前面有两个注解：@Entity 和 @Table(name = "product")

@Entity 表示这是一个实体类，用于映射表
@Table(name = "product") 表示这是一个类，映射到的表名:product

2.属性注解

属性注解是配置在属性对应的getter方法上的

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    @Column(name = "id")   
    public int getId() {
        return id;
    }

@Id 表示这是主键
@GeneratedValue(strategy = GenerationType.IDENTITY) 表示自增长方式使用mysql自带的
@Column(name = "id") 表示映射到字段id

二、关系

1.多对一注解

在product表中多个产品可以对应一种类别。

把Product的getCategory进行多对一映射：

    @ManyToOne
    @JoinColumn(name="cid") 
    public Category getCategory() {
        return category;
    }

@ManyToOne 表示多对一关系
@JoinColumn(name="cid") 表示关系字段是cid

2.一对多注解

在category表中，一种类别可以对应多种产品。

在Category类中的getProducts方法加上一对多注解:

    @OneToMany(fetch=FetchType.EAGER)
    @JoinColumn(name="cid") 
    public Set<Product> getProducts() {
        return products;
    }

@OneToMany 表示一对多,fetch=FetchType.EAGER 表示不进行延迟加载(FetchType.LAZY表示要进行延迟加载)
@JoinColumn(name="cid") 表示映射字段

*cid字段存在多的一方

3.多对多注解

多对多涉及到user和product表，一个用户可以购买多个产品，一个产品可以被多个用户购买。

<1>为Product的getUsers加上注解

    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @JoinTable(
            name="user_product",
            joinColumns=@JoinColumn(name="pid"),
            inverseJoinColumns=@JoinColumn(name="uid")
    )    
    public Set<User> getUsers() {
        return users;
    }

<2>为User的getProducts加上注解

    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.EAGER)
    @JoinTable(
            name="user_product",
            joinColumns=@JoinColumn(name="uid"),
            inverseJoinColumns=@JoinColumn(name="pid")
    )    
    public Set<Product> getProducts() {
        return products;
    }

三、注解手册

1.属性相关注解

@Id —— 注解声明了该实体bean的标识属性（对应表中的主键）。 

@Column —— 注解声明了属性到列的映射。该注解有如下的属性 

name 可选，列名（默认值是属性名） 

unique 可选，是否在该列上设置唯一约束（默认值false） 

nullable 可选，是否设置该列的值可以为空（默认值false） 

insertable 可选，该列是否作为生成的insert语句中的一个列（默认值true） 

updatable 可选，该列是否作为生成的update语句中的一个列（默认值true） 

columnDefinition 可选，为这个特定列覆盖sql ddl片段（这可能导致无法在不同数据库间移植） 

table 可选，定义对应的表（默认为主表） 

length 可选，列长度（默认值255） 

precision 可选，列十进制精度（decimal precision)(默认值0） 

scale 可选，如果列十进制数值范围（decimal scale）可用，在此设置（默认值0） 

@GeneratedValue —— 注解声明了主键的生成策略。该注解有如下属性 

strategy 指定生成的策略（JPA定义的），这是一个GenerationType。默认是GenerationType. AUTO 

GenerationType.AUTO 主键由程序控制 

GenerationType.TABLE 使用一个特定的数据库表格来保存主键 

GenerationType.IDENTITY 主键由数据库自动生成（主要是自动增长类型） 

GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列。（这个值要与generator一起使用） 

generator 指定生成主键使用的生成器（可能是orcale中的序列）。 

@SequenceGenerator —— 注解声明了一个数据库序列。该注解有如下属性 

name 表示该表主键生成策略名称，它被引用在@GeneratedValue中设置的“gernerator”值中 

sequenceName 表示生成策略用到的数据库序列名称。 

initialValue 表示主键初始值，默认为0. 

allocationSize 每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50.

2.关系相关注解

@ManyToOne 设置多对一关联 

方法一 

@ManyToOne(cascade={CasCadeType.PERSIST,CascadeType.MERGE})

@JoinColumn(name="外键") 

public 主表类 get主表类(){return 主表对象} 

方法二 

@ManyToOne(cascade={CascadeType.PERSIST,CascadeType.MERGE}) 

@JoinTable(name="关联表名"， 

joinColumns = @JoinColumn(name="主表外键"), 

inverseJoinColumns = @JoinColumns(name="从表外键") 

) 

@OneToMany 设置一对多关联。

方法一 

“一端”配置 

@OneToMany(mappedBy="“多端”的属性") 

public List<“多端”类> get“多端”列表(){return “多端”列表} 

“多端”配置参考@ManyToOne. 

方法二 

“一端”配置 

@OneToMany(mappedBy="“多端”的属性") 

@MapKey(name="“多端”做为Key的属性") 

public Map<“多端”做为Key的属性的类,主表类> get“多端”列表（）{return “多端”列表} 

“多端”配置参考@ManyToOne. 

方法三 使用这种配置，在为“一端”添加“多端”时，可以修改“多端”的外键。 

“一端”配置 

@OneToMany 

@JoinColumn(name="“多端”外键") 

public List<“多端”类> get“多端”列表(){return “多端”列表} 

“多端”配置参考@ManyToOne.