笔记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.