Hibernate annotation 多对多 双向关联 问题

zhoubaoyi 2010-02-01 06:28:43


如题,用HBM的时候可以按照我们的需求完成双向关联的CRUD,但是现在项目需求用Annotation,结果总是无法实现

跟使用hbm时候的效果--具体表现为用annotation的时候,如果不写mappedby,则生成2张维护关系用的表,而每次在一端

插入数据的时候,只写其中一张,那么需要在另外一端重新维护的时候,调用的却是另外一张关系表,这样就无法达到目的



总之,重点是要用annotation实现多对多的双向关联

举例代码如下:

使用hbm时候的.xml文件:

1.Student端:


<class name="com.bjsxt.hibernate.Student" table="student" schema="a">
<id name="id" type="integer">
<generator class="native"></generator>
</id>
<property name="name" type="string"></property>

<set name="teachers" table="teacher_student" cascade="all">
<key column="students_id"></key>
<many-to-many class="com.bjsxt.hibernate.Teacher" column="teachers_id"></many-to-many>
</set>
</class>


2.Teacher端

<hibernate-mapping>
<class name="com.bjsxt.hibernate.Teacher" table="teacher" schema="a">
<id name="id" type="integer">
<generator class="native"></generator>
</id>
<property name="name" type="string"></property>

<set name="students" table="teacher_student" cascade="all">
<key column="teachers_id"></key>
<many-to-many class="com.bjsxt.hibernate.Student"
column="students_id" />
</set>
</class>
</hibernate-mapping>




然后是annotation部分的关键部分:

1.student端

@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "students", targetEntity = Teacher.class)

public Set<Teacher> getTeachers() {
return this.teachers;
}



2.teacher端

@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "teacher_student", catalog = "a", joinColumns = { @JoinColumn(name = "teachers_id", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "students_id", nullable = false, updatable = false) })
public Set<Student> getStudents() {
return this.students;
}

...全文
1043 17 打赏 收藏 转发到动态 举报
写回复
用AI写文章
17 条回复
切换为时间正序
请发表友善的回复…
发表回复
nevernam 2010-02-02
  • 打赏
  • 举报
回复
14楼的同学终于说到点子上了
owen_008 2010-02-02
  • 打赏
  • 举报
回复
ecc_report
BearKin 2010-02-02
  • 打赏
  • 举报
回复

//关系集合
@ManyToMany(targetEntity=Subject.class)
@JoinTable(name="STUDENT_SUBJECT",
joinColumns=@JoinColumn(name="STUDENT_ID",referencedColumnName="ID"),
inverseJoinColumns=@JoinColumn(name="SUBJECT_ID",referencedColumnName="ID"))
private Set subjects;
BearKin 2010-02-02
  • 打赏
  • 举报
回复
[Quote=引用 6 楼 zhoubaoyi 的回复:]
回楼上

现在问题是换成Annotation无法实现和hbm的效果

多对多关系以前用hbm完全是不存在问题的。。
[/Quote]

是么..

如果有中间表的话 告诉LZ怎么弄


//关系集合
@ManyToMany(targetEntity=Student.class)
@JoinTable(name="STUDENT_SUBJECT",
joinColumns=@JoinColumn(name="SUBJECT_ID",referencedColumnName="ID"),
inverseJoinColumns=@JoinColumn(name="STUDENT_ID",referencedColumnName="ID"))
private Set students;


//关系集合
@ManyToMany(targetEntity=Student.class)
@JoinTable(name="STUDENT_SUBJECT",
joinColumns=@JoinColumn(name="SUBJECT_ID",referencedColumnName="ID"),
inverseJoinColumns=@JoinColumn(name="STUDENT_ID",referencedColumnName="ID"))
private Set students;
islandrabbit 2010-02-02
  • 打赏
  • 举报
回复
看了楼主的配置有几点想法。

首先楼主xml映射的配置至少有两点问题:

1. 缺少inverse="true"。因为楼主配的是个双向多对多,必须在配置中决定关系的哪一边来更新中间表。

2. 楼主使用了cascade="all", 这个对于多对多来说也是不行的。cascade="save-update"是可以的。
cascade="all"就包含了cascade="delete"。试想一下你删除A就会删除A下面所有的B,但因为是多对多这个A下面的B还可能对应着其他的A。

楼主说如果不写mappedby,则生成2张维护关系用的表。那个mappedby不写是不行的,它相当于xml里的inverse="true"。

lp19890601 2010-02-01
  • 打赏
  • 举报
回复
其他的表不管,只要关联中间表,不管其他表的事
xujun614 2010-02-01
  • 打赏
  • 举报
回复
public class Student {
private int id;
private String name;
private Set<Teacher> teachers = new HashSet<Teacher>();
@ManyToMany(mappedBy="students")
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
@Id
@GeneratedValue
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;
}
}
@Entity
public class Teacher {
private int id;
private String name;
private Set<Student> students = new HashSet<Student>();
@Id
@GeneratedValue
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;
}
@ManyToMany
@JoinTable(name="t_s",
joinColumns={@JoinColumn(name="teacher_id")},
inverseJoinColumns={@JoinColumn(name="student_id")}
)
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
}
可以搞定的
crazylaa 2010-02-01
  • 打赏
  • 举报
回复
路过
zhoubaoyi 2010-02-01
  • 打赏
  • 举报
回复
回楼主

试了啊,还是 插入数据的时候,只写其中一张
zhj92lxs 2010-02-01
  • 打赏
  • 举报
回复
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.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;

@Entity
public class Student {
private Integer id;
private String name;

private Set<Teacher> teachers = new HashSet<Teacher>();

public Student(){}

public Student(String name) {
this.name = name;
}
@Id @GeneratedValue
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}

@Column(length=10,nullable=false)
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

@ManyToMany(cascade=CascadeType.REFRESH,fetch=FetchType.LAZY)
@JoinTable(name="student_teacher",
inverseJoinColumns=@JoinColumn(name="teacher_id"),
joinColumns=@JoinColumn(name="student_id"))

public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}

public void addTeacher(Teacher teacher){
this.teachers.add(teacher);
}

public void remoceTeacher(Teacher teacher){
if(this.teachers.contains(teacher))
this.teachers.remove(teacher);
}
}


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.ManyToMany;

@Entity
public class Teacher {
private Integer id;
private String name;

private Set<Student> students = new HashSet<Student>();

public Teacher(){}

public Teacher(String name) {
this.name = name;
}

@Id
@GeneratedValue
public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

@Column(length = 10, nullable = false)
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}


@ManyToMany(cascade = CascadeType.REFRESH, fetch = FetchType.LAZY, mappedBy = "teachers")
public Set<Student> getStudents() {
return students;
}

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

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Teacher other = (Teacher) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}


}



给你个例子,这是jpa实现的,hibernate照着改下吧
fjhooo 2010-02-01
  • 打赏
  • 举报
回复
我也遇到这样的问题,jpa 的 annotation 没办法 实现跟 hbm配置文件 多对多的效果 给我造成了很大的困扰
希望大家进行有意义的 讨论 不是粘贴一大段东西来
zhoubaoyi 2010-02-01
  • 打赏
  • 举报
回复
回楼上

现在问题是换成Annotation无法实现和hbm的效果

多对多关系以前用hbm完全是不存在问题的。。
lp19890601 2010-02-01
  • 打赏
  • 举报
回复
多对多需要一个中间表来确定其关系的维护权

中间表只需要连个字段,即两张表的关系,也可以是主外键,

映射时无须映射中间表:

只需映射需要的两张表即可两张表

关键是里面的配置
//部门表
package pojo;

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

/**
* Department generated by MyEclipse Persistence Tools
*/

public class Department implements java.io.Serializable {

// Fields

private Integer oid;

private Integer parentoid;

private String deptName;

private String phone;

private String email;

private String fax;

private Integer manager;

private String address;

private String zipcode;

private String description;

private Integer[] jobids;

private Set<Job> jobs = new HashSet<Job>(0);//职位集合

private Set<Employee> emps = new HashSet<Employee>(0);//员工集合

// Constructors

public Integer[] getJobids() {
return jobids;
}

public void setJobids(Integer[] jobids) {
this.jobids = jobids;
}

public Set<Job> getJobs() {
return jobs;
}

public void setJobs(Set<Job> jobs) {
this.jobs = jobs;
}



// Property accessors

public Integer getOid() {
return this.oid;
}

public void setOid(Integer oid) {
this.oid = oid;
}

public Integer getParentoid() {
return this.parentoid;
}

public void setParentoid(Integer parentoid) {
this.parentoid = parentoid;
}

public String getDeptName() {
return this.deptName;
}

public void setDeptName(String deptName) {
this.deptName = deptName;
}

public String getPhone() {
return this.phone;
}

public void setPhone(String phone) {
this.phone = phone;
}

public String getEmail() {
return this.email;
}

public void setEmail(String email) {
this.email = email;
}

public String getFax() {
return this.fax;
}

public void setFax(String fax) {
this.fax = fax;
}

public Integer getManager() {
return this.manager;
}

public void setManager(Integer manager) {
this.manager = manager;
}

public String getAddress() {
return this.address;
}

public void setAddress(String address) {
this.address = address;
}

public String getZipcode() {
return this.zipcode;
}

public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}

public String getDescription() {
return this.description;
}

public void setDescription(String description) {
this.description = description;
}

public Set<Employee> getEmps() {
return emps;
}

public void setEmps(Set<Employee> emps) {
this.emps = emps;
}

}


//职位表

package pojo;

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

/**
* Job generated by MyEclipse Persistence Tools
*/

public class Job implements java.io.Serializable {

// Fields

private Integer oid;

private String jobname;

private Set<Department> depts = new HashSet<Department>(0);

// Constructors

/** default constructor */
public Job() {
}

/** full constructor */
public Job(String jobname) {
this.jobname = jobname;
}

// Property accessors

public Integer getOid() {
return this.oid;
}

public void setOid(Integer oid) {
this.oid = oid;
}

public String getJobname() {
return this.jobname;
}

public void setJobname(String jobname) {
this.jobname = jobname;
}

public Set<Department> getDepts() {
return depts;
}

public void setDepts(Set<Department> depts) {
this.depts = depts;
}

}


//部门表映射文件及配置


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="pojo.Department" table="Department" schema="dbo"
catalog="study">
<id name="oid" type="java.lang.Integer">
<column name="oid" />
<generator class="native" />
</id>
<property name="parentoid" type="java.lang.Integer">
<column name="parentoid" />
</property>
<property name="deptName" type="java.lang.String">
<column name="deptName" length="20" />
</property>
<property name="phone" type="java.lang.String">
<column name="phone" length="20" />
</property>
<property name="email" type="java.lang.String">
<column name="email" length="100" />
</property>
<property name="fax" type="java.lang.String">
<column name="fax" length="20" />
</property>
<property name="manager" type="java.lang.Integer">
<column name="manager" />
</property>
<property name="address" type="java.lang.String">
<column name="address" length="100" />
</property>
<property name="zipcode" type="java.lang.String">
<column name="zipcode" length="10" />
</property>
<property name="description" type="java.lang.String">
<column name="description" length="100" />
</property>
<!-- 中间表 -->
<set name="jobs" table="department_job"><!-- 职位集合配置 -->
<!-- 中间表对应的部门字段 -->
<key column="deptid"></key>
<!-- 中间表对应的职位字段 -->
<many-to-many class="pojo.Job" column="jobid">
</many-to-many>
</set>
<set name="emps" cascade="all" inverse="false"><!-- 员工集合配置 -->

<key column="deptid"></key>
<one-to-many class="pojo.Employee" />
</set>
</class>
</hibernate-mapping>


//职位表映射及配置

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="pojo.Job" table="job" schema="dbo" catalog="study">
<id name="oid" type="java.lang.Integer">
<column name="oid" />
<generator class="native" />
</id>
<property name="jobname" type="java.lang.String">
<column name="jobname" length="50" />
</property>
<!-- 中间表 -->
<set name="depts" table="department_job">
<!-- 中间表对应的职位字段 -->
<key column="jobid"></key>
<!-- 中间表对应的部门字段 -->
<many-to-many class="pojo.Department" column="deptid"></many-to-many>
</set>
</class>
</hibernate-mapping>


中间表只有 部门表的主键和职位表的主键,他们就是靠中间表来围护对方的

希望可以对你有所帮助!
蛋黄车 2010-02-01
  • 打赏
  • 举报
回复
强烈不建议使用多对多关联关系!!
coveking 2010-02-01
  • 打赏
  • 举报
回复
帮顶下。
islandrabbit 2010-02-01
  • 打赏
  • 举报
回复
下班回家看看!
nevernam 2010-02-01
  • 打赏
  • 举报
回复
强烈关注,我也遇到了这个问题
Hibernate Annotation几种关联映射 一对一(One-To-One) 使用@OneToOne注解建立实体Bean之间的一对一关联。一对一关联有三种情况:(1).关联的实体都共享同样的主键,(2).其中一个实体通过外键关联到另一个实体的主键(注意要模拟一对一关联必须在外键列上添加唯一约束),(3).通过关联表来保存两个实体之间的连接关系(要模拟一对一关联必须在每一个外键上添加唯一约束)。 1.共享主键的一对一关联映射: @Entity @Table(name="Test_Body") public class Body { private Integer id; private Heart heart; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } @OneToOne @PrimaryKeyJoinColumn public Heart getHeart() { return heart; } public void setHeart(Heart heart) { this.heart = heart; } } @Entity @Table(name="Test_Heart") public class Heart { private Integer id; @Id public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } } 通过@PrimaryKeyJoinColumn批注定义了一对一关联 2.使用外键进行实体一对一关联: @Entity @Table(name="Test_Trousers") public class Trousers { @Id public Integer id; @OneToOne @JoinColumn(name = "zip_id") public TrousersZip zip; } @Entity @Table(name="Test_TrousersZip") public class TrousersZip { @Id public Integer id; @OneToOne(mappedBy = "zip") public Trousers trousers; } 上面的例子是指Trousers通过Trousers的外键列zip_id和TrousersZip关联,@JoinColumn批注定义了联接列,该批注和@Column批注有点类似,但是多了一个名为referencedColumnName的参数。该参数定义了所关联目标实体中的联接列,注意,当referencedColumnName关联到非主键列的时候,关联的目标类必须实现Serializable,还要注意的是所映像的属性对应单个列(否则映射无效) 一对一关联可能是双向的,在双向关联中,有且仅有一端作为主体(owner)端存在:主体端负责维护联接列(即更新),对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中,mappedBy的值为zip。最后,不必也不能再在被关联端(ownedside)定义联接列了,因为已经在主体端声明了。 如果在主体没有声明@JoinColumn,系统自动进行处理:在主表(owner table)中将创建联接列,列名为:主体的关联属性名+下划线+被关联端的主键列名。上面的例子中是zip_id,因为Trousers中的关联属性名为zip,TrousersZip的主键是id。 3.通过关联表定义一对一关联 @Entity @Table(name="Test_People") public class People { @Id public Integer id; @OneToOne @JoinTable(name ="TestPeoplePassports", joinColumns =@JoinColumn(name="people_fk"), inverseJoinColumns =@JoinColumn(name="passport_fk") ) public Passport passport; } @Entity @Table(name="Test_Passport") public class Passport { @Id public Integer id; @OneToOne(mappedBy = "passport") public People people; } People通过名为TestPeoplePassports的关联表和Passport关联。该关联表拥有名为passport_fk的外键列,该外键指向Passport表,该信息定义为inverseJoinColoumns的属性值,而people_fk外键列指向People表,该信息定义为joinColumns的属性值。 这种关联可能是双向的,在双向关联中,有且仅有一端作为主体(owner)端存在:主体端负责维护联接列(即更新),对于不需要维护这种关系的从表则通过mappedNy属性进行声明。mappedBy的值指向主体的关联属性。例子中,mappedBy的值为passport。最后,不必也不能再在被关联端(ownedside)定义联接列了,因为已经在主体端声明了。 以上是一对一关联的三种形式,下面介绍多对一关联。 多对一(Many-to-One) 使用@ManyToOne批注来实现多对一关联。 @ManyToOne批注有一个名为targetEntity的参数,该参数定义了目标实体名,通常不需要定义该参数,因为在大部分情况下默认值(表示关联关系的属性类型)就可以很好的满足需求了。不过下面这种情况下这个参数就显得有意义了:使用接口作为返回值而不是常见的实体。 @ManyToOne(targetEntity=CompanyImpl.class) @JoinColoumn(name=”COPM_ID”) Public Company getCompany(){ return company; } 多对一的配置方式有两种:(1)通过@JoinColoumn映像(2)通过关联表的方式来映像 (1) 通过@JoinColoumn映射 SRD Framework中Company,Category例子: Company: @ManyToOne @JoinColumn(name = "CATEGORY_OPTION_ID") private Category category = null; Category: @DiscriminatorValue("Category") public class Category extends Option { } (2) 通过关联表映射 通过@JoinTable批注定义关联表,该关联表包含了指回实体表的外键(通过@JoinTable.joinColoumns)以及指向目标实体表的外键(通过@JoinTable.inverseJoinColoumns) @Entity @Table(name="Test_TreeType") public class TreeType { private Integer id; private String name; private ForestType forestType; @ManyToOne(fetch = FetchType.LAZY) @JoinTable(name="Test_Tree_Forest", joinColumns = @JoinColumn(name="tree_id"), inverseJoinColumns = @JoinColumn(name="forest_id") ) public ForestType getForestType() {// forestType的getter,setter方法必须在这里,否则会出错 return forestType; } public void setForestType(ForestType forestType) { this.forestType = forestType; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } @Entity @Table(name="Test_ForestType") public class ForestType { private Integer id; private String name; private Set trees; @OneToMany(mappedBy="forestType") public Set getTrees() {// trees的getter,setter方法必须在这里,否则会出错 return trees; } public void setTrees(Set trees) { this.trees = trees; } @Id @GeneratedValue public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 一对多(One-to-Many) 使用@OneToMany批注可定义一对多关联,一对多关联可以是双向关联。 在EJB3规范中多对一这端几乎总是双向关联中的主体(owner)端,而一对多这端关联批注为@OneToMany(mappedBy...) @Entity Public class Troop{ @OneToMany(mappedBy=”troop”) Public Set getSoldiers(){ ...... } @Entity Public class Soldier{ @ManyToOne @JoinColumn(name=”troop_fk”) Public Troop getTroop(){ ...... } Troop通过troop属性和Soldier建立一对多的双向关联,在mappedBy端不必也不能再定义任何物理映射。 对于一对多的双向映射,如果要一对多这一端维护关联关系,你需要删除mappedBy元素并将多对一这端的@JoinColoumn的insertable和updatabel设置为false。这种方案不会得到什么明显的优化,而且还会增加一些附加的UPDATE语句。 单向: 通过在被拥有的实体端(owned entity)增加一个外键列来实现一对多单向关联是很少见的,也是不推荐的,建议通过一个联接表来实现这种关联(下面会讲到)。 @JoinColoumn批注来描述这种单向关联关系 @Entity Public class Customer{ @OneToMany @JoinColoumn(name=”CUST_ID”) Public Set getTickets() { ...... } @Entity Public class Ticket{ ... } Customer通过CUST_ID列和Ticket建立了单向关联关系 通过关联表处理单向关联: 通过联接表处理单向一对多关联是首选方式,这种关联通过@JoinTable批注进行描述 @Entity Public class Trainer{ @OneToMany @JoinTable( name = "TrainedMonkeys", jonColumns = {@JoinColumn(name = "trainer_id")}, inverseJoinColumns = @JoinColumn(name = "monkey_id") ) public Set getTrainedMonkeys() { return trainedMonkeys; } ...... } @Entity public class Monkey { ...//no bidir } 上面这个例子中,Trainer通过TrainedMonkeys表和Monkey建立了单向关联,其中外键trainer_id关联到Trainer(joinColoumn),而外键monkey_id关联到Monkey(inversejionColoumns) 默认处理机制: 通过联接表来建立单向一对多关联不需要描述任何物理映像,表名由以下三个部分组成:主表(ownertable)表名+从表(the other side table)表名,指向主表的外键名:主表表名+下划线+主表主键列名,指向从表的外键名:主表所对应实体的属性名+下划线+从表主键列名,指向从表的外键定义为唯一约束,用来表示一对多的关联关系。 @Entity public class Trainer{ @OneToMany Public Set getTrainedTigers(){ ... ... } @Entity public class Tiger{ .. ..//no bidir } 上面这个例子中,Trainer和Tiger通过联接表Trainer_Tiger建立单向关联关系,其中外键trainer_id关联到Trainer,而外键trainedTigers_id关联到Tiger 多对多(Many-to-Many) 使用@ManyToMany批注可定义多对多关联,同时,你也许要通过批注@JoinTable描述关联表和关联条件。如果是双向关联,其中一段必须定义为Owner,另一端必须定义为inverse(在对关联表进行更新操作时这一端将被忽略) @Entity() public class Employer implements Serializable { private Integer id; private Collection employees; @ManyToMany( targetEntity = org.hibernate.test.annotations.manytomany.Employee.class, cascade = {CascadeType.PERSIST, CascadeType.MERGE} ) @JoinTable( name = "EMPLOYER_EMPLOYEE", joinColumns = {@JoinColumn(name = "EMPER_ID")}, inverseJoinColumns = {@JoinColumn(name = "EMPEE_ID")} ) public Collection getEmployees() { return employees; } ... } @Entity() public class Employee implements Serializable { @ManyToMany( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, mappedBy = "employees" targetEntity = Employer.class ) public Collection getEmployers() { return employers; } .. .. } @JoinTable批注定义了联接表的表名,联接列数组,以及invers联接列数组,后者是关联表中关联到Employee主键的列(the “other side”)。 被关联端不必也不能描述物理映射:只需要一个简单的mappedBy参数,该参数包含了主体端的属性名,这样就绑定了双方的关系。 默认值: 和其它许多批注一样,在多对多关联中很多值是自动生成,党双向多对多关联中没有定义任何物理映射时,Hibernate根据以下规则生成相应的值,关联表名:主表表名+下划线+从表表名,关联到主表的外键名:主表名+下划线+主表中的主键列名,关联到从表的外键名:主表中用于关联的属性名+下划线+从表的主键列名,以上规则对于双向一对多关联同样一样。 以上是整理的一点简单的几种映射,可参考EJB3.pdf中P111——P131,hibernate_annotation.pdf 第二章 在这里没有具体的例子,有很多内容还需要仔细查看文档。

67,512

社区成员

发帖
与我相关
我的任务
社区描述
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
社区管理员
  • Java EE
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧