Resume表 Rq表
Id--简历编号 Id-----编号
Uid--用户编号 rid---简历编号
Dir---简历存放地址 rdir---简历存放地址
qid----岗位编号Quarter表
Id----岗位编号
cid----公司编号
name---岗位名称
require----能力要求
position----工作地点
sex----性别要求
experience----工作经验要求
education----学历
number----人数Resume.hbm.xml 中多对多关系的配置代码部分
<set name="quater" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="rid" not-null="true">
<comment>????</comment>
</column>
</key>
<many-to-many class="pojo.Quater" column="id">
</many-to-many>
</set>
Quater.hbm.xml 中多对多关系的配置代码部分
<set name="resume" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="qid" not-null="true">
<comment>????</comment>
</column>
</key>
<many-to-many class="pojo.Resume" column="id">
</many-to-many>
</set>
我在ResumeDao.java 对两个表进行关联的方法
public boolean resumeMail(Long rid,Long qid){
Transaction tx = session.beginTransaction();// 开始一个事务
try
{
Resume resume = (Resume)session.createQuery("from Resume r where r.id="+rid).uniqueResult();
Quater quater = (Quater)session.createQuery("from Quater q where q.id="+qid).uniqueResult();
resume.getQuater().add(quater);
quater.getResume().add(resume);
tx.commit();
return true;
}catch(Exception e){
e.printStackTrace();
tx.rollback();
return false;
}
}
结果运行没问题，可是rq表里面却一直没记录····不知道为什么····
Id--简历编号 Id-----编号
Uid--用户编号 rid---简历编号
Dir---简历存放地址 rdir---简历存放地址
qid----岗位编号Quarter表
Id----岗位编号
cid----公司编号
name---岗位名称
require----能力要求
position----工作地点
sex----性别要求
experience----工作经验要求
education----学历
number----人数Resume.hbm.xml 中多对多关系的配置代码部分
<set name="quater" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="rid" not-null="true">
<comment>????</comment>
</column>
</key>
<many-to-many class="pojo.Quater" column="id">
</many-to-many>
</set>
Quater.hbm.xml 中多对多关系的配置代码部分
<set name="resume" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="qid" not-null="true">
<comment>????</comment>
</column>
</key>
<many-to-many class="pojo.Resume" column="id">
</many-to-many>
</set>
我在ResumeDao.java 对两个表进行关联的方法
public boolean resumeMail(Long rid,Long qid){
Transaction tx = session.beginTransaction();// 开始一个事务
try
{
Resume resume = (Resume)session.createQuery("from Resume r where r.id="+rid).uniqueResult();
Quater quater = (Quater)session.createQuery("from Quater q where q.id="+qid).uniqueResult();
resume.getQuater().add(quater);
quater.getResume().add(resume);
tx.commit();
return true;
}catch(Exception e){
e.printStackTrace();
tx.rollback();
return false;
}
}
结果运行没问题，可是rq表里面却一直没记录····不知道为什么····
Resume表
Id--简历编号 ---------- 这里应该用Quarter对象, 而具体的映射由配置文件决定,比如uid --> Quarter.id
Uid--用户编号
Dir---简历存放地址Resume.hbm.xml 中多对多关系的配置代码部分
<set name="quater" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="rid" not-null="true">
<comment>???? </comment>
</column>
</key>
<many-to-many class="pojo.Quater" column="id">
(在关系表中体现 rid 对 Quarter.id 的外键引用)
</many-to-many>
</set>
还有,多对多关系是需要中间表来维护的,如果是双向多对多关系的话, Hibernate 需要手工指定双方是由同一个中间表维护,不然会出现两个毫无干系的多对一关系
Quater quater = (Quater)session.createQuery("from Quater q where q.id="+qid).uniqueResult();
resume.getQuater().add(quater);
quater.getResume().add(resume);
还有你这样操作后？resume，quater均变为临时对象，并没有持久化的过程，怎么能保存到数据库呢？
你的resume，和quarter是怎么联系的，表结构上没有体现嘛，映射文件也没写对。
<set name="quater" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="rid" not-null="true">
<comment>???? </comment>
</column>
</key>
<many-to-many class="pojo.Rq" column="id">
</many-to-many>
</set> Quater.hbm.xml应为
<set name="resume" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="qid" not-null="true">
<comment>???? </comment>
</column>
</key>
<many-to-many class="pojo.Rq" column="id">
</many-to-many>
</set>
即，rq表均关联到Quater和Resume表中，多对多
配置文件中的<column name="qid" not-null="true"> 是哪个表的哪个字段，很模糊
还请各位大虾讲一下····
rq中间表中的rid代表resume 表中的id qid代表quater表中的id
配置文件要怎么弄啊，另外进行关联的话，程序要怎么写啊
resume 表和quater表没有直接关系，两者通过中间表rq关联。
[/Quo}
我知道啊，那要怎么关联啊···
这个我支持, 我深刻理解... 当我刚发现使用 Hibernate 但不添加关联关系的时候(100多章表),我特别费解,然后..
就理解了- -||
参考这个 多对多实例
你介绍的这个是student中的sid和course中的cid关联，中间表也是sid,和cid
我的要进行对多对关联的两个字段都叫id啊 中间表是rid和qid
我现在对下面这个配置有点迷糊
<set name="resume" table="rq" cascade="all" inverse="true" lazy="true">
<key>
<column name="qid" not-null="true">
<comment>???? </comment>
</column>
</key>
<many-to-many class="pojo.Rq" column="id">
</many-to-many>
</set>
中<key>中的column 指定是哪个表的字段啊，是中间表的么？能不能在我的那几个表上做个示范用例啊··谢谢了，对这个学的有点模糊
1
级联。
2
关系维护。你这里主要是关系维护的问题。关系维护的对象是什么呢。
在一对多种，关系维护维护的对象是外键字段。如 学生--班级 对应，这个多对一的关系是通过在 学生 表里面一个班级的ID 来实现的。在多对1中关系的维护一般交给多的一方，这里就是由 学生表 来维护。当往学生记录里面添加一个班级的时候，
只需 student.setClass（class）. 这个操作的实质就是往学生记录里面的班级ID 添加了值。
而如果你想通过班级来操作，比如你做如下操作：class.getStruts.add(student).这个时候由于class并不是关系的维护方，所以并不会往student的记录里面添加classId.也就是说这个添加过程还是只能由学生方来完成。
在多对多的时候，就是你例子里面的中间表rp表了。关系维护的对象就是这个表里面的记录。也就是在执行
resume.getQuater().add(quater);
quater.getResume().add(resume);
的时候，如果resume是主控方（quater配置inverse="true"。）,那么
只有
resume.getQuater().add(quater); 会向rp表插入数据。
反之亦然。如果你两个多对多都配置了 inverse="true"。 那么双方不会往中间表写数据。
不知道说清楚没有。
*@author QQde00
*@date 2009-12-02
*/多对多关系在hibernate中配置的例子：有两个类：
1. Admin：管理员
2. Role：管理员的角色，，可能为财务管理员、产品管理员、订单管理员等。
Admin与Role之间的关系为多对多关系，即一个管理员可能同时为财务管理员、产品管理员，而一个角色有可能被多个管理员扮演，如产品管理员可能有a管理员、b管理员等。对应的为这两个类设计两个表：
1. t_admin（管理员表）: id, name, password, realName, enrollDate
2. t_role（角色表）: id, name, code
3. t_admin_rold（管理员与角色关系表）: admin_id, role_id两个类的源代码如下，类中体现为双向的多对多关系：
//Admin.java
import java.io.Serializable;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;public class Admin implements Serializable {
private Integer id ;
private String loginName ;
private String realName ;
private String password ;
private Date enrollDate ;
private Set<Role> roles = new HashSet<Role>();
//给Admin添加一个Role，并注册双边关系
public void addRole( Role r ){
roles.add( r ) ;
r.getAdmins().add( this ) ;
}
//从Admin中删除一个Role，并删除双边关系
public void removeRole( Role r ){
roles.remove( r ) ;
r.getAdmins().remove( this ) ;
}
//删除一个Admin中所有Role，并删除双边关系
public void clearRole( ){
for( Role r : roles ){
r.getAdmins().remove( this ) ;
}
roles.clear();
}
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Date getEnrollDate() {
return enrollDate;
}
public void setEnrollDate(Date enrollDate) {
this.enrollDate = enrollDate;
}
}//Role.java
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;public class Role implements Serializable {
private Integer id ;
private String name ;
private String code ;
private Set<Admin> admins = new HashSet<Admin>();
public Set<Admin> getAdmins() {
return admins;
}
public void setAdmins(Set<Admin> admins) {
this.admins = admins;
}
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;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}*.hbm.xml中的配置：
<class name="Admin" table="t_admin">
<id name="id">
<generator class="increment"/>
</id>
<property name="loginName" column="login_name" type="string"/>
<property name="realName" column="real_name" type="string"/>
<property name="password" column="passwd" type="string"/>
<property name="enrollDate" column="enroll_date" type="date"/>
<set name="roles" inverse="true" table="t_admin_role" cascade="save-update">
<!— table="t_admin_role"是指我们是多对多的关系，由t_admin_role这个表确定我们之间的关系。 -->
<key column="admin_id"/><!-- 在关系表中admin_id这个外键是根据本类对应表中的主键生成的 -->
<many-to-many class="Role" column="role_id"/><!—与本类有多对多的类型Role，而且它在关系表中的外键是role_id -->
</set>
</class>
<class name="Role" table="t_role">
<id name="id">
<generator class="increment"/>
</id>
<property name="name" type="string"/>
<property name="code" type="string"/>
<set name="admins" table="t_admin_role" cascade="save-update"><!-- table="t_admin_role"是指我们是多对多的关系，由t_admin_role这个表确定本类与关系属性之间的关系。 -->
<key column="role_id"/><!-- 在关系表中role_id这个外键是根据本类的主键生成的 -->
<many-to-many class="Admin" column="admin_id"/><!-- 跟本类多对多的类型Admin，而且它在关系表中的外键是admin_id -->
</set>
</class>
xinlan1022
两位说到问题所在了，longtenggdf说的算是有点明白了，还请xinlan1022再细将一下，谢谢
<many-to-many class="pojo.Quater" column="id">
改为
<many-to-many class="pojo.Quater" column="qid">
这里的column指定了Quater中包含的Quater集合的每个元素的id对应中间表的哪个字段.同理
<many-to-many class="pojo.Resume" column="id"> 也要改为
<many-to-many class="pojo.Resume" column="rid">你如果写id的话 hibernate就认为 id关联到Resume类吧.我想你应该是用Quater 做的主控是么?
所以才会写qid id.