hibernate常用注解(2) ManyToOne OneToMany

ManyToOne 写在Many端 @(cascade（级联） = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH},fetch（提取方式：不写也会自动默认，To后面如果是one端：EAGER立即提取。To后面如果是Many端：LAZY延时提取） = FetchType.LAZY)

 

One端一定是被控端 Many端默认是主控端，也可以设置为被控端

 

例：

 

建表语句：

DROP TABLE IF EXISTS `t_company`;
CREATE TABLE `t_company` (
  `companyId` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `companyName` varchar(30) NOT NULL,
  PRIMARY KEY (`companyId`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=gb2312;

INSERT INTO `t_company` VALUES ('1', 'Sun');
INSERT INTO `t_company` VALUES ('2', 'Apache');

 

DROP TABLE IF EXISTS `t_employee`;
CREATE TABLE `t_employee` (
  `employeeId` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `employeeName` varchar(15) NOT NULL,
  `cid` int(10) unsigned NOT NULL,
  PRIMARY KEY (`employeeId`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=gb2312;

INSERT INTO `t_employee` VALUES ('1', 'Tom', '1');
INSERT INTO `t_employee` VALUES ('2', 'Summ', '1');
INSERT INTO `t_employee` VALUES ('3', 'Cat', '2');
INSERT INTO `t_employee` VALUES ('4', 'Vinylon', '1');
INSERT INTO `t_employee` VALUES ('5', 'Dog', '2');

 

Employee.java

 

package com.fancy.po;

import javax.persistence.CascadeType;
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.ManyToOne;
import javax.persistence.Table;
/**
 * -----------------------------------------
 * @描述: 实体类
 * -----------------------------------------
 */
/**
 * 下面只说@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;
    }
    public void setEmployeeId(Integer employeeId) {
        this.employeeId = employeeId;
    }
    public String getEmployeeName() {
        return employeeName;
    }
   
    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }

/** * @ManyToOne：多对一,cascade：级联,请参考上一篇 * fetch = FetchType.LAZY,延迟加载策略,如果不想延迟加载可以用FetchType.EAGER */ @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH},fetch = FetchType.LAZY) @JoinColumn(name = "cid") public Company getCompany() { return company; } public void setCompany(Company company) { this.company = company; }}

 

 

Company.java

package com.fancy.po;

import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
 * -----------------------------------------
 * @描述: 实体类
 * -----------------------------------------
 */
/**
 * 下面只说@OneToMany,如需了解其他注解,
 * 
 */
@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;
    }
    public void setCompanyId(Integer companyId) {
        this.companyId = companyId;
    }
    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

/** * @OneToMany 与 OneToOne相似的也用mappedBy,参考了Employee

     *控制这个One的是Employee声明的那个company对象  （private Company company；）
     * 可以参考上一篇
     */
    @OneToMany(mappedBy = "company")
    public Set<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<Employee> employees) {
        this.employees = employees;
    }
}

其他例子

@ManyToOne(fetch=FetchType,cascade=CascadeType ) 可选 

@ManyToOne 表示一个多对一的映射 , 该注解标注的属性通常是数据库表的外键 

optional: 是否允许该字段为 null, 该属性应该根据数据库表的外键约束来确定 , 默认为 true 

fetch: 表示抓取策略 , 默认为 FetchType.EAGER 

cascade: 表示默认的级联操作策略 , 可以指定为 ALL,PERSIST,MERGE,REFRESH 和 REMOVE 中的若干组合 , 默认为无级联操作 

targetEntity: 表示该属性关联的实体类型 . 该属性通常不必指定 ,ORM 框架根据属性类型自动判断 targetEntity. 

 

@ManyToOne

示例 : 

    // 订单 Order 和用户 User 是一个 ManyToOne 的关系 

    // 在 Order 类中定义 

    @ManyToOne() 

    @JoinColumn(name="USER") 

    public User getUser() { 

       return user; 

    }

 

 

@JoinColumn 

可选 

@JoinColumn 和 @Column 类似 , 介量描述的不是一个简单字段 , 而一一个关联字段 , 例如 . 描述一个 @ManyToOne 的字段 . 

name: 该字段的名称 . 由于 @JoinColumn 描述的是一个关联字段 , 如 ManyToOne, 则默认的名称由其关联的实体决定 . 

例如 , 实体 Order 有一个 user 属性来关联实体 User, 则 Order 的 user 属性为一个外键 , 

其默认的名称为实体 User 的名称 + 下划线 + 实体 User 的主键名称 

示例 : 

    见 @ManyToOne 

 

@OneToMany(fetch=FetchType,cascade=CascadeType) 

可选 

@OneToMany 描述一个一对多的关联 , 该属性应该为集体类型 , 在数据库中并没有实际字段 . 

fetch: 表示抓取策略 , 默认为 FetchType.LAZY, 因为关联的多个对象通常不必从数据库预先读取到内存 

cascade: 表示级联操作策略 , 对于 OneToMany 类型的关联非常重要 , 通常该实体更新或删除时 , 其关联的实体也应当被更新或删除 

例如 : 实体 User 和 Order 是 OneToMany 的关系 , 则实体 User 被删除时 , 其关联的实体 Order 也应该被全部删除 

示例 : 

    @OneToMany(cascade=CascadeType.ALL)

    public List getOrders() { 

       return orders; 

    } 

 

@ManyToMany 

可选 

@ManyToMany 描述一个多对多的关联 . 多对多关联上是两个一对多关联 , 但是在 ManyToMany 描述中 , 中间表是由 ORM 框架自动处理 

targetEntity: 表示多对多关联的另一个实体类的全名 , 例如 :package.Book.class 

mappedBy: 表示多对多关联的另一个实体类的对应集合属性名称 

示例 : 

    User 实体表示用户 ,Book 实体表示书籍 , 为了描述用户收藏的书籍 , 可以在 User 和 Book 之间建立 ManyToMany 关联