jpa多对多

维护端注解

@ManyToMany(cascade=CascadeType.REFRESH)

@JoinTable(//关联表

name="student_teacher", //关联表名

inverseJoinColumns=@JoinColumn(name="teacher_id"),//被维护端外键

joinColumns=@JoinColumn(name="student_id"))//维护端外键

被维护端注解

@ManyToMany(

cascade = CascadeType.REFRESH,

mappedBy = "teachers",//通过维护端的属性关联

fetch = FetchType.LAZY)

关系维护端删除时，如果中间表存在些纪录的关联信息，则会删除该关联信息;

关系被维护端删除时，如果中间表存在些纪录的关联信息，则会删除失败.

以学生和老师的对应关系为例。一个学生可以拥有多个老师，一个老师也可以拥有多个学生。

学生实体类

packagecom.taoistwar.jpa.entity.manytomany;

importjava.util.HashSet;
importjava.util.Set;

importjavax.persistence.CascadeType;
importjavax.persistence.Column;
importjavax.persistence.Entity;
importjavax.persistence.GeneratedValue;
importjavax.persistence.GenerationType;
importjavax.persistence.Id;
importjavax.persistence.JoinColumn;
importjavax.persistence.JoinTable;
importjavax.persistence.ManyToMany;

@Entity
publicclassStudent{
privateIntegerid;
privateStringname;
privateSet<Teacher>teachers=newHashSet<Teacher>();

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
publicIntegergetId(){
returnid;
}

publicvoidsetId(Integerid){
this.id=id;
}

@Column(nullable=false,length=16)
publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

@ManyToMany(cascade=CascadeType.REFRESH)
@JoinTable(name="student_teacher",inverseJoinColumns=@JoinColumn(name="teacher_id"),joinColumns=@JoinColumn(name="student_id"))
publicSet<Teacher>getTeachers(){
returnteachers;
}

publicvoidsetTeachers(Set<Teacher>teachers){
this.teachers=teachers;
}

publicvoidaddTeacher(Teacherteacher){
this.teachers.add(teacher);
}

publicvoidremoveTeachers(Teacherteacher){
this.teachers.remove(teacher);
}

}

重点在于：

@ManyToMany(cascade=CascadeType.REFRESH)
@JoinTable(name="student_teacher",inverseJoinColumns=@JoinColumn(name="teacher_id"),joinColumns=@JoinColumn(name="student_id"))
publicSet<Teacher>getTeachers(){
returnteachers;
}

老师实体类

packagecom.taoistwar.jpa.entity.manytomany;

importjava.util.HashSet;
importjava.util.Set;

importjavax.persistence.CascadeType;
importjavax.persistence.Column;
importjavax.persistence.Entity;
importjavax.persistence.FetchType;
importjavax.persistence.GeneratedValue;
importjavax.persistence.GenerationType;
importjavax.persistence.Id;
importjavax.persistence.ManyToMany;

@Entity
publicclassTeacher{
privateIntegerid;
privateStringname;
privateSet<Student>students=newHashSet<Student>();

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
publicIntegergetId(){
returnid;
}

publicvoidsetId(Integerid){
this.id=id;
}

@Column(nullable=false,length=16)
publicStringgetName(){
returnname;
}

publicvoidsetName(Stringname){
this.name=name;
}

@ManyToMany(cascade=CascadeType.REFRESH,mappedBy="teachers",fetch=FetchType.LAZY)
publicSet<Student>getStudents(){
returnstudents;
}

publicvoidsetStudents(Set<Student>students){
this.students=students;
}

@Override
publicinthashCode(){
finalintprime=31;
intresult=1;
result=prime*result+((id==null)?0:id.hashCode());
returnresult;
}

@Override
publicbooleanequals(Objectobj){
if(this==obj)
returntrue;
if(obj==null)
returnfalse;
if(getClass()!=obj.getClass())
returnfalse;
Teacherother=(Teacher)obj;
if(id==null){
if(other.id!=null)
returnfalse;
}elseif(!id.equals(other.id))
returnfalse;
returntrue;
}
}

重点在于：

@ManyToMany(cascade=CascadeType.REFRESH,mappedBy="teachers",fetch=FetchType.LAZY)
publicSet<Student>getStudents(){
returnstudents;
}

拥有mappedBy注解的实体类为关系被维护端，另外的实体类为关系维护端的。顾名思意，关系的维护端对关系（在多对多为中间关联表）的CRUD做操作。关系的被维护端没有该操作，不能维护关系。

测试类

packagecom.taoistwar.jpa.entity.manytomany;

importjavax.persistence.EntityManager;
importjavax.persistence.EntityManagerFactory;
importjavax.persistence.Persistence;

importorg.junit.Test;

publicclassManyToMany{
@Test
publicvoidsave(){
EntityManagerFactoryemf=Persistence
.createEntityManagerFactory("JPAPU");
EntityManagerem=emf.createEntityManager();
em.getTransaction().begin();
Studentstudent=newStudent();
student.setName("小李");
Teacherteacher=newTeacher();
teacher.setName("大李");
em.persist(student);
em.persist(teacher);
em.getTransaction().commit();
emf.close();
}

@Test
publicvoidbind(){
EntityManagerFactoryemf=Persistence
.createEntityManagerFactory("JPAPU");
EntityManagerem=emf.createEntityManager();
em.getTransaction().begin();
Studentstudent=em.find(Student.class,1);
Teacherteacher=em.find(Teacher.class,1);
student.addTeacher(teacher);
em.persist(student);
em.getTransaction().commit();
emf.close();
}

@Test
publicvoidunbind(){
EntityManagerFactoryemf=Persistence
.createEntityManagerFactory("JPAPU");
EntityManagerem=emf.createEntityManager();
em.getTransaction().begin();
Studentstudent=em.find(Student.class,1);
Teacherteacher=em.find(Teacher.class,1);
student.removeTeachers(teacher);
em.persist(student);
em.getTransaction().commit();
emf.close();
}

@Test
publicvoidremoveTeacher(){
EntityManagerFactoryemf=Persistence
.createEntityManagerFactory("JPAPU");
EntityManagerem=emf.createEntityManager();
em.getTransaction().begin();
//关系被维护端删除时，如果中间表存在些纪录的关联信息，则会删除失败
em.remove(em.getReference(Teacher.class,1));
em.getTransaction().commit();
emf.close();
}

@Test
publicvoidremoveStudent(){
EntityManagerFactoryemf=Persistence
.createEntityManagerFactory("JPAPU");
EntityManagerem=emf.createEntityManager();
em.getTransaction().begin();
//关系维护端删除时，如果中间表存在些纪录的关联信息，则会删除该关联信息
em.remove(em.getReference(Student.class,1));
em.getTransaction().commit();
emf.close();
}

}