dorado hibernate 一对多关系情况和使用【主从表】

一和多情况

1.正常一和多情况

sl_message 表有个外键，关联到 sl_employee 表
所以 sl_employee 是一，sl_message 是多
@OneToMany时getSet
@ManyToOne时get

@Entity//一端
@Table(name = "sl_employee")
public class SlEmployee implements Serializable {
	public void setSlMessageSet(Set<SlMessage> slMessageSet) {
		this.slMessageSet = slMessageSet;
	}
	//一端：有@mappedBy，表示当前表和SlMessage的关系是定义在SlMessage里面的成员变量slEmployee上，且自己【主表】不维护一和多的关系，由SlEmployee【从表】通过成员变量slEmployee维护一对多的关系
	/*
	a) 只有 OneToOne,OneToMany,ManyToMany 上才有 mappedBy 属性，ManyToOne 不存在该属性； 
	b) mappedBy 定义在主表【一对一的一，一对多的一，多对多的多】
	d) mappedBy 跟 JoinColumn/JoinTable 总是处于互斥的一方，mappedBy 这方定义的 JoinColumn/JoinTable 总是失效的，不会建立对应的字段或者表
*/
 	//FetchType.LAZY：懒加载，加载时，定义懒加载的属性不会马上从数据库中加载。即加载SlEmployee【主表】时不会把相关联的SlMessage【从表】都加载
 	//FetchType=EAGER：急加载，加载时，定义急加载的属性会马上从数据库中加载。即加载SlEmployee【主表】时会把相关联的SlMessage【从表】都加载。优点不用进行二次查询。缺点是严重影响数据查询的访问时间
	@OneToMany(fetch = FetchType.LAZY, mappedBy = "slEmployee")
	public Set<SlMessage> getSlMessageSet() {
		return slMessageSet;
	}
}

@Entity//多端
@Table(name = "sl_message")
public class SlMessage implements Serializable {
	public void setSlEmployee(SlEmployee slEmployee) {
		this.slEmployee = slEmployee;
	}
	//多端：有@JoinColumn，表自己【从表】通过外键"sender"来和主表SlEmployee进行关联
	//FetchType.LAZY：懒加载，加载时，定义懒加载的属性不会马上从数据库中加载。即加载SlMessage【从表】时不会把相关联的SlEmployee【主表】都加载
	//FetchType=EAGER：急加载，加载时，定义急加载的属性会马上从数据库中加载。即加载SlEmployee【主表】时会把相关联的SlMessage【从表】都加载。优点不用进行二次查询。缺点是严重影响数据查询的访问时间
	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "sender")
	public SlEmployee getSlEmployee() {
		return slEmployee;
	}
}

2.特殊一对多情况 【递归：一和多是同一类型】

1. eg：部门下面有部门
2. 由于一和多是同一类型，SlDept类，有slDept【一端应该有】和slDeptSet【多端应该有set】

CREATE TABLE `sl_dept` (
  `dept_id` int(11) NOT NULL AUTO_INCREMENT,
  `parent_id` int(11) DEFAULT NULL,
  `dept_name` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`dept_id`),
  KEY `fk_parent_id` (`parent_id`),
  CONSTRAINT `fk_parent_id` FOREIGN KEY (`parent_id`) REFERENCES `sl_dept` (`dept_id`) ON DELETE CASCADE ON UPDATE NO ACTION,
) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;
 

@Entity
@Table(name = "sl_dept")
public class SlDept implements Serializable {
	//sl_dept
	private SlDept slDept;
	//sl_dept
	private Set<SlDept> slDeptSet = new HashSet<SlDept>(0);
	public void setSlDept(SlDept slDept) {
		this.slDept = slDept;
	}

	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name = "parent_id")
	public SlDept getSlDept() {
		return slDept;
	}
	public void setSlDeptSet(Set<SlDept> slDeptSet) {
		this.slDeptSet = slDeptSet;
	}

	@OneToMany(fetch = FetchType.LAZY, mappedBy = "slDept")
	public Set<SlDept> getSlDeptSet() {
		return slDeptSet;
	}
}

保存一对多

1.1 保存正常一对多的一【同时要保存多，且有上面可知，关系由多进行维护】

	@DataResolver
    @Transactional
    public void saveAll(Collection<SlEmployee> slEmployees){
        //维护主表信息
        slEmployeeDao.persistEntities(slEmployees);
        for(SlEmployee employee:slEmployees){
            Collection<SlMessage> messages = employee.getSlMessageSet();
            if(messages!=null){
                for(SlMessage message:messages){
                    //维护关联关系
                    message.setSlEmployee(employee);
                }
                slMessageDao.persistEntities(messages);
            }
        }
    }

1.2 保存正常一对多的多

	@DataResolver
    @Transactional
    public void saveMessages(Collection<SlEmployee> slEmployees){
        for(SlEmployee employee:slEmployees){
            Collection<SlMessage> messages = employee.getSlMessageSet();
            for(SlMessage message:messages){
                //维护关联关系 学生.setClass("一班");
                message.setSlEmployee(employee);
            }
            slMessageDao.persistEntities(messages);
        }
    }

2保存特殊一对多的一【同时保存一和多】

	@DataResolver
    @Transactional
    public void saveAll(Collection<SlDept> depts){
        for(SlDept dept:depts){
            slDeptDao.persistEntity(dept);
            Collection<SlDept> childs = dept.getSlDeptSet();
            if(!(childs ==  null)){
                for(SlDept child:childs){
                    //根据主表类中的@mappedBy字段，表明由多端【从表】维护关系
                    child.setSlDept(dept);
                }
                slDeptDao.persistEntities(childs);
                saveAll(childs);
            }
        }
    }