Hibernate注解方式多种映射

最新推荐文章于 2019-06-09 20:07:38 发布

Uno2

最新推荐文章于 2019-06-09 20:07:38 发布

阅读量842

点赞数

分类专栏： J2EE学习文章标签： hibernate

本文链接：https://blog.csdn.net/Raynaing/article/details/51145226

版权

J2EE学习专栏收录该内容

27 篇文章 0 订阅

订阅专栏

1、先介绍一对一的映射annotation（Man和Woman）

Man.java

<span style="font-size:14px;">package ray.one2one;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="_man") //制定数据库中Man实体对应的表名
public class Man {
	private int id;
	private String name;
	private Woman woman;
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO) //strategy制定主键生成策略为自动，=native
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Column(name="m_name") //制定数据库字段的名称
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne(mappedBy="man") //mappedBy同样指定由对方来用外键维护关联关系，即在数据库中woman表中有外键
	public Woman getWoman() {
		return woman;
	}
	public void setWoman(Woman woman) {
		this.woman = woman;
	}
}
</span>

Woman.java

<span style="font-size:14px;">package ray.one2one;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="_woman")
public class Woman {
	private int id;
	private String name;
	private Man man;
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@OneToOne(cascade=CascadeType.ALL)
	@JoinColumn(name="m_id") //指定外键的名字 为m_id
	public Man getMan() {
		return man;
	}
	public void setMan(Man man) {
		this.man = man;
	}
	
}
</span>

<span style="font-size:14px;">package ray.one2one;

import org.hibernate.Session;
import ray.util.SessionUtil;

public class Test {
	public static void main(String[] args) {
		Woman woman = new Woman();
		woman.setName("文苹");
		Man man = new Man();
		man.setName("雷盼");
		man.setWoman(woman);
		woman.setMan(man);
		Session session = SessionUtil.getSession();
		session.beginTransaction();
		
		session.save(woman);
		session.getTransaction().commit();
		session.close();
	}
}</span>

总结：数据库中外键在_woman表中

2、再看一对多的关系

Departs.java（一方）

<span style="font-size:14px;">package ray.many2one;

import java.util.HashSet;
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.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name = "_Departs")
public class Departs {
	private int d_id;
	private String d_name;
	// 维护一个set，方便业务查询，双向关联多方
	private Set<Employ> employs = new HashSet<Employ>();

	// 主键 ：@Id    主键生成方式：strategy = "increment"
	//映射表中id这个字段，不能为空，并且是唯一的
	@Id
	@GenericGenerator(name = "generator", strategy = "increment")
	@GeneratedValue(generator = "generator")
	@Column(name = "id", nullable = false, unique = true)
	public int getD_id() {
		return d_id;
	}

	public void setD_id(int d_id) {
		this.d_id = d_id;
	}
	//映射表中name这个字段 ，长度是500
	@Column(name = "name", length = 500)
	public String getD_name() {
		return d_name;
	}

	public void setD_name(String d_name) {
		this.d_name = d_name;
	}
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "departs")
	public Set<Employ> getEmploys() {
		return employs;
	}

	public void setEmploys(Set<Employ> employs) {
		this.employs = employs;
	}

}
</span>

Employ.java（多方）

<span style="font-size:14px;">package ray.many2one;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
@Table(name="_employ")
public class Employ {
	private int e_id;
	private String name;
	//维护一个一方，类似于数据库中的外键
	private Departs departs;
	@Id
	@GenericGenerator(name = "generator", strategy = "increment")
	@GeneratedValue(generator = "generator")
	@Column(name = "e_id", nullable = false, unique = true)
	public int getE_id() {
		return e_id;
	}
	public void setE_id(int e_id) {
		this.e_id = e_id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@ManyToOne(fetch = FetchType.LAZY)
	@JoinColumn(name="d_id")
	public Departs getDeparts() {
		return departs;
	}
	public void setDeparts(Departs departs) {
		this.departs = departs;
	}
	
}
</span>

测试代码：

<span style="font-size:14px;">package ray.many2one;

import org.hibernate.Session;

import ray.util.SessionUtil;

public class Test {
	public static void main(String[] args) {
		Departs departs = new Departs();
		departs.setD_name("北京昌平");
		Employ e1 = new Employ();
		e1.setName("雷子诺");
		e1.setDeparts(departs);
		
		Employ e2 = new Employ();
		e2.setName("雷盼");
		e2.setDeparts(departs);
		departs.getEmploys().add(e1);
		departs.getEmploys().add(e2);
/*		employs.add(e1);
		employs.add(e2);
		
		departs.setEmploys(employs);*/
		Session session = SessionUtil.getSession();
		session.beginTransaction();
		session.save(departs);
		session.save(e1);
		session.save(e2);
		session.getTransaction().commit();
		session.close();
	}
}</span>

总结：数据库中外键在_employ表中

3、最后看多对多的关系

多对多这里通常有两种处理方式，一种是通过建立一张中间表，然后由任一一个多的一方来维护关联关系，另一种就是将多对多拆分成两个一对多的关联关系

这里介绍一种通过中间表由任一一个多的一方来维护关联关系

Course.java

<span style="font-size:14px;">package ray.many2many;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
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.Table;

//多对多这里通常有两种处理方式，一种是通过建立一张中间表，然后由任一一个多的一方来维护关联关系，
//另一种就是将多对多拆分成两个一对多的关联关系
//1. 介绍用中间表来维护关系
@Entity
@Table(name = "_course")
public class Course {
	private int c_id;
	private String c_name;
	private Set<Student2> students = new HashSet<Student2>();

	public void addStudent(Student2 s) {
		this.getStudents().add(s);
	}

	/*
	 * 因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过 JoinTable
	 * 这个注解来声明，name就是指定了中间表的名字，JoinColumns是一个
	 * @JoinColumn类型的数组，表示的是我这方在对方中的外键名称，我方是Course，所以在对方外键的名称就是
	 * c_id，inverseJoinColumns也是一个
	 * @JoinColumn类型的数组，表示的是对方在我这放中的外键名称，对方是Student2，所以在我方外键的名称就是s)id
	 */
	@ManyToMany
	@JoinTable(name = "stu_course", joinColumns = { @JoinColumn(name = "c_id") }, inverseJoinColumns = { @JoinColumn(name = "stu_id") })
	public Set<Student2> getStudents() {
		return students;
	}

	public void setStudents(Set<Student2> students) {
		this.students = students;
	}

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	public int getC_id() {
		return c_id;
	}

	public void setC_id(int c_id) {
		this.c_id = c_id;
	}

	public String getC_name() {
		return c_name;
	}

	public void setC_name(String c_name) {
		this.c_name = c_name;
	}

}
</span>

Student2.java

<span style="font-size:14px;">package ray.many2many;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name="_student2")
public class Student2 {
	private int s_id;
	private String s_name;
	//增加set维护多对多关系
	private Set<Course> courses = new HashSet<Course>();
	
	@ManyToMany(mappedBy="students") //表示由Course方维护关系
	public Set<Course> getCourses() {
		return courses;
	}
	//增加一个方法，方便添加course
	public void addCourse(Course c){
		this.courses.add(c);
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	public int getS_id() {
		return s_id;
	}
	public void setS_id(int s_id) {
		this.s_id = s_id;
	}
	public String getS_name() {
		return s_name;
	}
	public void setS_name(String s_name) {
		this.s_name = s_name;
	}
}
</span>

测试代码：

<span style="font-size:14px;">package ray.many2many;

import org.hibernate.Session;

import ray.util.SessionUtil;

public class Test {
	public static void main(String[] args) {
		Student2 s1 = new Student2();
		s1.setS_name("s1");
		
		Student2 s2 = new Student2();
		s2.setS_name("s2");
		
		Course c1 = new Course();
		c1.setC_name("c1");
		
		Course c2 = new Course();
		c2.setC_name("c2");
		
//		s1.addCourse(c1);
//		s1.addCourse(c2);
//		
//		s2.addCourse(c1);
//		s2.addCourse(c2);
//		此处指明外键有student维护，所以只需要在course中添加student的引用即可
		c1.addStudent(s1);
		c1.addStudent(s2);
		
		c2.addStudent(s1);
		c2.addStudent(s2);
		
		Session session = SessionUtil.getSession();
		session.beginTransaction();
		session.save(s1);
		session.save(s2);
		session.save(c1);
		session.save(c2);
		session.getTransaction().commit();
		session.close();
	}
}
</span>

总结：通过hibernate来进行插入操作的时候，不管是一对多、一对一还是多对多，都只需要记住一点，在哪个实体类声明了外键，就由哪个类来维护关系，在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据

Uno2

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate注解方式多种映射

1、先介绍一对一的映射annotation（Man和Woman）Man.javapackage ray.one2one;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Ge
复制链接

扫一扫