Hibernate--多对一
//部门表
create table TDept(
d_Id varchar2(50) primary key,
d_Name varchar2(50) not null
);
//员工表
create table TEmp(
e_Id varchar2(50) primary key,
e_Name varchar2(50) not null,
e_Sex varchar2(50) not null,
e_Dept varchar2(50) not null//(外键列)
);
//部门实体类
public class TDept implements Serializable{
private String dId;
private String dName;
private Set<TEmp> emps;
...省略get(),set()
}
//员工实体类
public class TEmp implements Serializable{
private String eId;
private String eName;
private String eSex;
private TDept dept;
...省略get(),set()
}
//部门表映射文件--TDept.hbm.xml
<hibernate-mapping package="com.rt.xbliuc.pojos">
<class name="TDept" table="TDept">
<id name="dId" column="d_Id">
<generator class="assigned"/>
</id>
<property name="dName" column="d_Name"/>
<set name="emps" inverse="true" lazy="false">
<key column="e_Dept"/>
<one-to-many class="com.rt.xbliuc.pojos.TEmp"/>
</set>
//<set name="emps" inverse="true"> inverse属性表示,主外键关键由一的一方来维护
</class>
</hibernate-mapping>
//员工表映射文件--TEmp.hbm.xml
<hibernate-mapping package="com.rt.xbliuc.pojos">
<class name="TEmp" table="TEmp">
<id name="eId" column="e_Id">
<generator class="assigned"/>
</id>
<property name="eName" column="e_Name"/>
<property name="eSex" column="e_Sex"/>
<many-to-one name="dept" column="e_Dept" lazy="false"/>
</class>
</hibernate-mapping>
说明:fetch="select" :fetch参数指定了关联对象抓取的方式是select查询还是join查询,select方式时先查询返回要查询的主体对象(列表),再根据关联外键id,每一个对象发一个select查询,获取关联的对象,形成n+1次查询; 而join方式,主体对象和关联对象用一句外键关联的sql同时查询出来,不会形成多次查询。
如果你的关联对象是延迟加载的,它当然不会去查询关联对象。
查询抓取(默认的)在N+1查询的情况下是极其脆弱的,因此我们可能会要求在映射文档中定义使用连接(join)抓取.
lazy="false":false的时候表示不延迟加载,就是只要用一个东西,其他的和这个东西有关的都查出来,为true的时候就是等到用的时候再查.
----------------------------
//Test.java -- 测试类
Transaction transaction = session.beginTransaction();
TDept dept = new TDept("2", "22");
TEmp emp = new TEmp("22", "222", "222", dept);
session.save(dept);
session.save(emp);
transaction.commit();
//部门表
create table TDept(
d_Id varchar2(50) primary key,
d_Name varchar2(50) not null
);
//员工表
create table TEmp(
e_Id varchar2(50) primary key,
e_Name varchar2(50) not null,
e_Sex varchar2(50) not null,
e_Dept varchar2(50) not null//(外键列)
);
//部门实体类
public class TDept implements Serializable{
private String dId;
private String dName;
private Set<TEmp> emps;
...省略get(),set()
}
//员工实体类
public class TEmp implements Serializable{
private String eId;
private String eName;
private String eSex;
private TDept dept;
...省略get(),set()
}
//部门表映射文件--TDept.hbm.xml
<hibernate-mapping package="com.rt.xbliuc.pojos">
<class name="TDept" table="TDept">
<id name="dId" column="d_Id">
<generator class="assigned"/>
</id>
<property name="dName" column="d_Name"/>
<set name="emps" inverse="true" lazy="false">
<key column="e_Dept"/>
<one-to-many class="com.rt.xbliuc.pojos.TEmp"/>
</set>
//<set name="emps" inverse="true"> inverse属性表示,主外键关键由一的一方来维护
</class>
</hibernate-mapping>
//员工表映射文件--TEmp.hbm.xml
<hibernate-mapping package="com.rt.xbliuc.pojos">
<class name="TEmp" table="TEmp">
<id name="eId" column="e_Id">
<generator class="assigned"/>
</id>
<property name="eName" column="e_Name"/>
<property name="eSex" column="e_Sex"/>
<many-to-one name="dept" column="e_Dept" lazy="false"/>
</class>
</hibernate-mapping>
说明:fetch="select" :fetch参数指定了关联对象抓取的方式是select查询还是join查询,select方式时先查询返回要查询的主体对象(列表),再根据关联外键id,每一个对象发一个select查询,获取关联的对象,形成n+1次查询; 而join方式,主体对象和关联对象用一句外键关联的sql同时查询出来,不会形成多次查询。
如果你的关联对象是延迟加载的,它当然不会去查询关联对象。
查询抓取(默认的)在N+1查询的情况下是极其脆弱的,因此我们可能会要求在映射文档中定义使用连接(join)抓取.
lazy="false":false的时候表示不延迟加载,就是只要用一个东西,其他的和这个东西有关的都查出来,为true的时候就是等到用的时候再查.
----------------------------
//Test.java -- 测试类
Transaction transaction = session.beginTransaction();
TDept dept = new TDept("2", "22");
TEmp emp = new TEmp("22", "222", "222", dept);
session.save(dept);
session.save(emp);
transaction.commit();