3.一起来学hibernate之配置文件2
之前的映射文件配置都是简单的、基础的配置，只涉及到单个javabean，对于单个javabean的增删改查都能很好的、简单的去完成。
但是知道简单配置远远不够，并不能完成很多复杂的情况，比如对象与对象间的关联，对象中的集合属性等，所以还需更近一步的学习hibernate映射文件的配置。
本次映射文件配置涉及到集合、排序、多对一、一对多、多对多、以及一对一的内容等。
1.集合属性(Set、List、Map、数组)
1.1Set集合：
首先，创建一个User实体类，实体类是一个买家账号，包含id、name、addressSet(set集合，存放多个地址，地址不重复)
//该实体是买家实体
public class User {
private Integer id;// 买家id
private String name;// 买家名字
private Set<String> addressSet;// 买家地址，可以有多个，但是不能重复
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 Set<String> getAddressSet() {
return addressSet;
}
public void setAddressSet(Set<String> addressSet) {
this.addressSet = addressSet;
}
}
接着配置映射文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.Collection">
<class name="User" table="user">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="name" type="string" column="name" length="20"/>
<!-- addressSet属性，在javabean中是一个set集合 -->
<!-- name为javabean中的属性名，table为另一张表user_addr -->
<!-- user_addr表主键其实是user表的外键 -->
<set name="addressSet" table="user_addr">
<!-- user_addr外键 -->
<key column="addrId"/>
<!-- user_addr表address列 -->
<element type="string" column="address"/>
</set>
</class>
</hibernate-mapping>
表结构如下：
CREATE TABLE `user` (
`id` ) NOT NULL AUTO_INCREMENT,
`name` ) NULL DEFAULT NULL,
PRIMARY KEY (`id`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB
AUTO_INCREMENT;
CREATE TABLE `user_addr` (
`addrId` ) NOT NULL,
`address` ) NULL DEFAULT NULL,
INDEX `FK14340FE5D5E4BA1E` (`addrId`),
CONSTRAINT `FK14340FE5D5E4BA1E` FOREIGN KEY (`addrId`) REFERENCES `user` (`id`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
User u = new User();
u.setId(1);
u.setName("testName");
Set<String> s = new HashSet<String>();
s.add("BeiJing 12");
s.add("HongKong 35");
s.add("ShangHai 113");
u.setAddressSet(s);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(u);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
最终hibernate帮我们执行的sql代码：
Hibernate: insert into user (name) values (?) Hibernate: insert into user_addr (addrId, address) values (?, ?) Hibernate: insert into user_addr (addrId, address) values (?, ?) Hibernate: insert into user_addr (addrId, address) values (?, ?)
上述程序说明：
实体类User是一个买家账号类，该账号的id和name配置不多描述，主要说明addressSet集合，该集合存放多个地址，那么当我们存储数据到数据库中，user表的数据应该是这样子的：
id name
testName
testName2
由于一个User地址是多个，所以地址没办法在user表中的一个账号中体现出来，唯有创建一张地址表，用来被user表的用户指向，那么地址表的数据就是这样子的：
addrId address
123号
456号
789号
所以我们再次查看配置文件有关于集合的配置：
<set name="addressSet" table="user_addr">
<!-- user_addr外键 -->
<key column="addrId"/>
<!-- user_addr表address列 -->
<element type="string" column="address"/>
</set>
上述配置，set name代表的是javabean中的集合名称，而table代表的是地址表user_addr，同时必须指出地址表的外键，以及地址表其他字段。
举一反三，知道怎么存入数据，当然要知道怎么获取数据：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
User u = new User();
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
u = (User) session.get(User.class, 1);
System.out.println(u);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
hibernate帮我们查询的sql代码：
Hibernate:
select
user0_.id as id0_0_,
user0_.name as name0_0_
from
user user0_
where
user0_.id=?
Hibernate:
select
addressset0_.addrId as addrId0_0_,
addressset0_.address as address0_
from
user_addr addressset0_
where
addressset0_.addrId=?
得出结果：
User [id=1, name=testName, addressSet=[BeiJing 12, ShangHai 113, HongKong 35]]
1.2List集合，跟set集合很相似，唯一的不同是在映射文件的集合配置
把实体类属性更改一下：
//该实体是买家实体
public class User {
private Integer id;// 买家id
private String name;// 买家名字
private List<String> cargo;// 购物车商品，可多个，也可重复
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 List<String> getCargo() {
return cargo;
}
public void setCargo(List<String> cargo) {
this.cargo = cargo;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", cargo="
+ cargo + "]";
}
}
映射文件配置，相比set集合配置多了一个<list-index>标签：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.Collection">
<class name="User" table="user">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="name" type="string" column="name" length="20"/>
<list name="cargo" table="cargo_list">
<key column="cargoId"/>
<!-- list集合表，同一个用户购物车商品的顺序 -->
<list-index column="idx"/>
<element type="string" column="cargoName"/>
</list>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
User u = new User();
u.setId(1);
u.setName("testName");
List<String> cargoList = new ArrayList<String>();
cargoList.add("pancel");
cargoList.add("apple");
cargoList.add("water");
u.setCargo(cargoList);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(u);
System.out.println(u);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
查看hibernate帮我们生成的sql语句：
Hibernate:
insert
into
user
(name)
values
(?)
User [id=1, name=testName, cargo=[pancel, apple, water]]
Hibernate:
insert
into
cargo_list
(cargoId, idx, cargoName)
values
(?, ?, ?)
Hibernate:
insert
into
cargo_list
(cargoId, idx, cargoName)
values
(?, ?, ?)
Hibernate:
insert
into
cargo_list
(cargoId, idx, cargoName)
values
(?, ?, ?)
表结构和数据：
user表
cargo_list表
1.3数组(跟list集合配置一模一样，除了list集合标签使用<list></list>，而数组使用<array></array>)
依旧是更改一下user实体
//该实体是买家实体
public class User {
private Integer id;// 买家id
private String name;// 买家名字
private String[] cargo;// 购物车商品，可多个，也可重复
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[] getCargo() {
return cargo;
}
public void setCargo(String[] cargo) {
this.cargo = cargo;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", cargo="
+ cargo + "]";
}
}
映射文件配置：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.Collection">
<class name="User" table="user">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="name" type="string" column="name" length="20"/>
<array name="cargo" table="user_addressArray">
<key column="addrId"/>
<list-index column="idx"/>
<element type="string" column="address"/>
</array>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
User u = new User();
u.setId(1);
u.setName("testName");
String[] cargo = {"computer","iphone6s","ipad"};
u.setCargo(cargo);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(u);
System.out.println(u);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
查看hibernate为我们生成的sql语句：
Hibernate:
insert
into
user
(name)
values
(?)
User [id=1, name=testName, cargo=[Ljava.lang.String;@f737a7]
Hibernate:
insert
into
user_addressArray
(addrId, idx, address)
values
(?, ?, ?)
Hibernate:
insert
into
user_addressArray
(addrId, idx, address)
values
(?, ?, ?)
Hibernate:
insert
into
user_addressArray
(addrId, idx, address)
values
(?, ?, ?)
表结构和数据：
user表
user_addressArray表
1.4Map集合
仍然修改一下user实体
//该实体是买家实体
public class User {
private Integer id;// 买家id
private String name;// 买家名字
private Map<String,String> map = new HashMap<String,String>();// 地址+邮政编码
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 Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", map="
+ map + "]";
}
}
映射文件配置：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.Collection">
<class name="User" table="user">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="name" type="string" column="name" length="20"/>
<map name="map" table="user_map">
<!-- user_map外键 -->
<key column="mapId"/>
<!-- 由于javabean属性是map集合，所以必须配置key和value -->
<map-key type="string" column="mapKey"/>
<element type="string" column="mapValue"/>
</map>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
User u = new User();
u.setId(1);
u.setName("testName");
Map<String,String> map = new HashMap<String,String>();
map.put("xiaMen", "361100");
map.put("fuZhou", "351100");
u.setMap(map);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(u);
System.out.println(u);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
hibernate帮我们生成的sql语句：
Hibernate:
insert
into
user
(name)
values
(?)
User [id=2, name=testName, map={xiaMen=361100, fuZhou=351100}]
Hibernate:
insert
into
user_map
(mapId, mapKey, mapValue)
values
(?, ?, ?)
Hibernate:
insert
into
user_map
(mapId, mapKey, mapValue)
values
(?, ?, ?)
表结构和数据：
user表
user_map表
2.排序order-by
说明，这里的orderby指的是查询出来的集合表中数据的排序，只能在映射文件的集合中配置
<!--
orderby排序的是集合表的数据，
由于集合表现在有3个字段(从以下很容易看出mapId、mapKey、mapValue)，
所以通过哪个字段排序看你自己 ;
order-by内可以指定排序：ASC DESC，默认是ASC，不区分大小写
-->
<map name="map" table="user_map" order-by="mapKey DESC">
<!-- user_map外键 -->
<key column="mapId"/>
<!-- 由于javabean属性是map集合，所以必须配置key和value -->
<map-key type="string" column="mapKey"/>
<element type="string" column="mapValue"/>
</map>
3.多对一和一对多以及一对一和多对多
3.1一对多
所谓一对多，顾名思义，一个东西对应着多个东西，当然这是通俗的说法，实际上，用例子来描述就是：一个部门对应多个员工；一所学校对应多个老师；一个老师对应多个学生等等。。。
在说一对多之前，先来了解一下以下区别：
List<String> list = new ArrayList<String>();
List<Employee> list = new ArrayList<Employee>();
以上两个List的区别是，前者是存放字符串类型的集合，而后者是存放类(实体)的合集。然而，这会导致它们在hibernate映射文件中的配置不同。前者的配置，之前的总结就有，而后者的配置，却是跟前者有点区别，因为后者是两个实体之间建立关联关系。
创建两个实体，一个Department部门实体，一个Employee员工实体，一个部门对应多个员工，反之多个员工对应一个部门：
/**Department*/
public class Department {
private Integer deptId;//部门ID
private String deptName;//部门名称
//一个部门对应多个员工
private List<Employee> employees = new ArrayList<Employee>();
public Integer getDeptId() {
return deptId;
}
public void setDeptId(Integer deptId) {
this.deptId = deptId;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public List<Employee> getEmployees() {
return employees;
}
public void setEmployees(List<Employee> employees) {
this.employees = employees;
}
}
/**Employee*/
public class Employee {
private Integer empId;//员工ID
private String empName;//公共姓名
private Department dept;//多个员工对应一个部门
public Integer getEmpId() {
return empId;
}
public void setEmpId(Integer empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public Department getDept() {
return dept;
}
public void setDept(Department dept) {
this.dept = dept;
}
}
建立两个实体之间的关系，需要两个映射文件：
Department.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.one2many">
<class name="Department" table="department">
<id name="deptId" type="int" column="deptId">
<generator class="native"/>
</id>
<property name="deptName" type="string" column="deptName" length="20"/>
<!-- 配置一对多关系,由于employees是list集合，所以还是使用<list>标签来配置 -->
<list name="employees">
<!-- key指向Employee对应表的外键 departmentId-->
<key column="departmentId"/>
<list-index column="idx"/>
<!-- 指向Employee实体 class为全类名-->
<one-to-many class="com.hibernate.one2many.Employee"/>
</list>
</class>
</hibernate-mapping>
Employee.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.one2many">
<class name="Employee" table="employee">
<id name="empId" type="int" column="empId">
<generator class="native"/>
</id>
<property name="empName" type="string" column="empName" length="20"/>
<!-- 多对一配置 -->
<!-- name为Employee中属性名,class为与之关联的Department实体全限定名 -->
<!-- column为Department所对应表的deptId,即employee表的外键 -->
<many-to-one name="dept"
class="com.hibernate.one2many.Department"
column="departmentId"/>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建部门实体
Department dept = new Department();
dept.setDeptName("java dept");
//构建员工实体
Employee emp1 = new Employee();
emp1.setEmpName("zhangsan");
Employee emp2 = new Employee();
emp2.setEmpName("lisi");
//建立部门和员工的关系
dept.getEmployees().add(emp1);
dept.getEmployees().add(emp2);
emp1.setDept(dept);
emp2.setDept(dept);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(dept);
session.save(emp1);
session.save(emp2);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
表结构和数据：
department表
employee表
一对多分析：
上方测试程序是两个实体共同来维护表的关系！其实，hibernate允许两个关联的实体的其中一个实体来维护两者的关系，例如将测试程序改为：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建部门实体
Department dept = new Department();
dept.setDeptName("java dept");
//构建员工实体
Employee emp1 = new Employee();
emp1.setEmpName("zhangsan");
Employee emp2 = new Employee();
emp2.setEmpName("lisi");
//建立部门和员工的关系
dept.getEmployees().add(emp1);
dept.getEmployees().add(emp2);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(dept);
session.save(emp1);
session.save(emp2);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
查看hibernate帮我们生成的sql语句：
Hibernate: insert into department (deptName) values (?) Hibernate: insert into employee (empName, departmentId) values (?, ?) Hibernate: insert into employee (empName, departmentId) values (?, ?) Hibernate: update employee set departmentId=?, idx=? where empId=? Hibernate: update employee set departmentId=?, idx=? where empId=?
为什么有update语句?
根据sql，很容易看到先往部门表中插入部门数据;在将员工设置给部门之前，员工的数据必须先存在，所以将员工数据先插入到员工表，员工表的外键列(指向哪个部门)这时并没有值，由于是由一方的实体(一方表示一对多的一，多方表示一对多的多)来维护，所以再获得一方的主键值，设置到多方的外键列中(关联两表关系)。
再来看看，由多方实体来维护表的情况，仍然是修改测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建部门实体
Department dept = new Department();
dept.setDeptName("java dept");
//构建员工实体
Employee emp1 = new Employee();
emp1.setEmpName("zhangsan");
Employee emp2 = new Employee();
emp2.setEmpName("lisi");
//建立部门和员工的关系
emp1.setDept(dept);
emp2.setDept(dept);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(dept);
session.save(emp1);
session.save(emp2);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
看看hibernate帮我们生成的sql语句：
Hibernate: insert into department (deptName) values (?) Hibernate: insert into employee (empName, departmentId) values (?, ?) Hibernate: insert into employee (empName, departmentId) values (?, ?)
由上方sql，很清楚的看出，已经没有update语句，为什么？
根据sql，先往部门表中插入部门数据，这时候已经存在部门数据了，再根据实体来看，将部门实体设置给员工，员工实体在插入员工表时就已经拿到了部门数据，很容易就将部门数据插入到员工表的外键列，所以不需要额外的再去更新外键列的值。
总结：关联的实体双方都能维护表关系，但是最好的多方的实体来维护，多方的实体维护表关系，不必额外执行sql语句来更新外键列从而建立两张表的关系，效率比较高。
拓展：inverse属性
我们可以通过给一方(一对多的一，简称一方)的属性设置inverse属性，来表示是否由本方维护，例如：
<list name="employees" inverse="false">
<key column="departmentId"/>
<list-index column="idx"/>
<one-to-many class="com.hibernate.one2many.Employee"/>
</list>
inverse = "false"是默认设置，配置文件中的配置代表了department实体有责任来维护双方的关系
这时候通过部门来维护两个实体间的关系，就和上方由一方(一对多的一，简称一方)来维护两个实体间的关系是一样的！
但是如果inverse = "true"，那么department没有责任维护双方的关系了，一旦通过department来维护，那么两个实体间并不会建立关系，看以下sql：
Hibernate: insert into department (deptName) values (?) Hibernate: insert into employee (empName, departmentId) values (?, ?) Hibernate: insert into employee (empName, departmentId) values (?, ?)
上方的sql语句，仅仅是插入部门数据，插入员工数据，而员工表中的外键列却是空的，这是部门没责任维护双方关系的结果。
3.2多对多
以老师和学生为例，一个老师可以有多个学生，同时一个学生也可以有多个老师！
由于是多对多的关系，所以要让两者产生关联，还需要一张中间表。
实体：
public class Student {
private Integer stuId;
private String stuName;
private Set<Teacher> teachers = new HashSet<Teacher>();
public Integer getStuId() {
return stuId;
}
public void setStuId(Integer stuId) {
this.stuId = stuId;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Set<Teacher> getTeachers() {
return teachers;
}
public void setTeachers(Set<Teacher> teachers) {
this.teachers = teachers;
}
}
public class Teacher {
private Integer teaId;
private String teaName;
private Set<Student> students = new HashSet<Student>();
public Integer getTeaId() {
return teaId;
}
public void setTeaId(Integer teaId) {
this.teaId = teaId;
}
public String getTeaName() {
return teaName;
}
public void setTeaName(String teaName) {
this.teaName = teaName;
}
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
}
配置映射关系文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.many2many">
<class name="Student" table="student">
<id name="stuId" type="int" column="stuid">
<generator class="native"/>
</id>
<property name="stuName" type="string" column="stuname" length="20"/>
<!-- table中间表，关联teacher和student表之间的关联关系 -->
<set name="teachers" table="teacher_student">
<!-- student表在中间表中表示的id -->
<key column="studentId"/>
<!-- 与之关联的实体类，该实体类在中间表中的id -->
<many-to-many class="Teacher" column="teacherId"/>
</set>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.many2many">
<class name="Teacher" table="teacher">
<id name="teaId" type="int" column="teaid">
<generator class="native"/>
</id>
<property name="teaName" type="string" column="teaname" length="20"/>
<set name="students" table="teacher_student">
<key column="teacherId"/>
<many-to-many class="Student" column="studentId"/>
</set>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建对象
Teacher t1 = new Teacher();
t1.setTeaName("aaa");
Teacher t2 = new Teacher();
t1.setTeaName("bbb");
Student s1 = new Student();
s1.setStuName("sss");
Student s2 = new Student();
s2.setStuName("ssss");
//老师t1、t2分别有两个学生
t1.getStudents().add(s1);
t1.getStudents().add(s2);
t2.getStudents().add(s1);
t2.getStudents().add(s2);
//学生s1、s2分别有两个老师
s1.getTeachers().add(t1);
s1.getTeachers().add(t2);
s2.getTeachers().add(t1);
s2.getTeachers().add(t2);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(t1);
session.save(t2);
session.save(s1);
session.save(s2);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
执行sql：
Hibernate: insert into teacher (teaname) values (?) Hibernate: insert into teacher (teaname) values (?) Hibernate: insert into student (stuname) values (?) Hibernate: insert into student (stuname) values (?) Hibernate: insert into teacher_student (teacherId, studentId) values (?, ?) Hibernate: insert into teacher_student (teacherId, studentId) values (?, ?) Hibernate: insert into teacher_student (teacherId, studentId) values (?, ?) Hibernate: insert into teacher_student (teacherId, studentId) values (?, ?) Hibernate: insert into teacher_student (studentId, teacherId) values (?, ?) Hibernate: insert into teacher_student (studentId, teacherId) values (?, ?) Hibernate: insert into teacher_student (studentId, teacherId) values (?, ?) Hibernate: insert into teacher_student (studentId, teacherId) values (?, ?)
通过以上sql，可能看不出问题，实际上执行程序出错：
Caused by: java.sql.BatchUpdateException: Duplicate entry '2-2' for key 1
由于中间表teacher_student中字段teacherId为teacher表的外键，而studentId为student表的外键，两个字段构成复合主键，所以并不允许插入重复的数据，执行上述sql，会插入中间表的数据为：
teacherId , studentId (1 , 1) (1 , 2) (2 , 1) (2 , 2) --------------------------- (1 , 1) (2 , 1) (1 , 2) (2 , 2)
所以并无法插入数据，导致报错。
从上方错误，也许我们应该清楚了，多对多只能限定一个实体维护两个实体间关系(维护中间表)。
所以修改上方的配置，假设让student来维护，那么就需要在teacher.hbm.xml中设定inverse="true"，代表不由teacher来维护：
<class name="Teacher" table="teacher">
<id name="teaId" type="int" column="teaid">
<generator class="native"/>
</id>
<property name="teaName" type="string" column="teaname" length="20"/>
<set name="students" table="teacher_student" inverse="true">
<key column="teacherId"/>
<many-to-many class="Student" column="studentId"/>
</set>
</class>
修改测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建对象
Teacher t1 = new Teacher();
t1.setTeaName("aaa");
Teacher t2 = new Teacher();
t2.setTeaName("bbb");
Student s1 = new Student();
s1.setStuName("sss");
Student s2 = new Student();
s2.setStuName("ssss");
//老师t1、t2分别有两个学生
/*t1.getStudents().add(s1);
t1.getStudents().add(s2);
t2.getStudents().add(s1);
t2.getStudents().add(s2);*/
//学生s1、s2分别有两个老师
s1.getTeachers().add(t1);
s1.getTeachers().add(t2);
s2.getTeachers().add(t1);
s2.getTeachers().add(t2);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(t1);
session.save(t2);
session.save(s1);
session.save(s2);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
执行结果成功，查询表结构与数据：
student
teacher
teacher_student
3.3cascade级联属性
什么是级联？
举个很明了的例子就是：假设有两张表，一张是部门表，一张是雇员表，部门表和雇员表为一对多的关系，这时表结构就应该以下设计
tb_dept tb_employee
deptId deptName empId empName departmentId
| |
---------------------------------------------
主键 外键
现在假设tb_dept有如下数据：
部门id：1，部门名称：开发部
假设tb_employee有如下数据：
员工id：1，员工名称：小吖，部门id：1
员工id：2，员工名称：小撒，部门id：1
假设删除开发部，那么只需将tb_employee表中的部门id置为null，再删除部门即可，并不会删除员工；
而级联，在删除开发部后，那么开发部所相关的所有员工，也一并从tb_employee被清空。
了解了级联，有以下一个问题需要解决-->之前的一对多，多对多没提出，是因为在这说明更有利于理解级联和对象直接的关联：
--->一对多和多对多类似，以一对多来说明，上述已经说明，一般使用多的一方来维护两个实体间的关系：
拿一对多的例子来说,一个部门对应多个员工
public class Department{
private Integer id;
private String deptName;
private Set<Employee> employees = new HashSet<Employee>();
setter...getter...
}
public class Employee{
private Integer id;
private String empName;
private Department department;
setter...getter...
}
Department dept = new Department();
dept.setDeptName("java");
Employee emp1 = new Employee();
emp1.setEmpName("小李");
Employee emp2 = new Employee();
emp2.setEmpName("小陈");
以上是相关实体，Department是部门，deptName是部门名称；
employee是员工，empName是员工名称；
现在将小李和小陈都分配在java部门，那么代码就是
emp1.setDepartment(dept);
emp2.setDepartment(dept);
执行保存...
session.save(emp1);
session.save(emp2);
执行后报错了，原因在于department表并没有数据，employee表外键要引用department表主键id找不到；所以，执行保存时，相关的表都要先得有数据，才能执行关联；所以，执行保存代码为：
session.save(dept);
session.save(emp1);
session.save(emp2);
通过上述更深入的例子说明，也许都知道了级联存在的重要性了，有了级联，上方例子在执行第一次保存时就不会报错，并且hibernate都将帮我们在两张表生成数据。
了解了以上，开始级联的详细说明：
级联，使用属性cascade来设置，由于目的是使两个关联的对象的一个对象根据另一个对象的操作而做相同操作，所以在一对一和多对多中，级联属性是设置在集合上的，看以下示例(以以上的一对多为例)：
1.准备部门和员工数据
department
employee
2.在department.hbm.xml做如下配置(级联删除：cascade="delete")：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.one2many">
<class name="Department" table="department">
<id name="deptId" type="int" column="deptId">
<generator class="native"/>
</id>
<property name="deptName" type="string" column="deptName" length="20"/>
<!-- 配置一对多关系,由于employees是list集合，所以还是使用<list>标签来配置 -->
<list name="employees" cascade="delete">
<key column="departmentId"/>
<list-index column="idx"/>
<one-to-many class="com.hibernate.one2many.Employee"/>
</list>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建部门实体
/*Department dept = new Department();
dept.setDeptId(1);
dept.setDeptName("java");*/
//构建员工实体
/*Employee emp1 = new Employee();
emp1.setEmpName("小李");
Employee emp2 = new Employee();
emp2.setEmpName("小陈");*/
//建立部门和员工的关系
/*dept.getEmployees().add(emp1);
dept.getEmployees().add(emp2);*/
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
Department department = (Department) session.get(Department.class, 1);
session.delete(department);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
查看生成的sql：
Hibernate: select department0_.deptId as deptId0_0_, department0_.deptName as deptName0_0_ from department department0_ where department0_.deptId=? Hibernate: select employees0_.departmentId as departme3_0_1_, employees0_.empId as empId1_, employees0_.idx as idx1_, employees0_.empId as empId1_0_, employees0_.empName as empName1_0_, employees0_.departmentId as departme3_1_0_ from employee employees0_ where employees0_.departmentId=? Hibernate: update employee set departmentId=null, idx=null where departmentId=? Hibernate: delete from employee where empId=? Hibernate: delete from employee where empId=? Hibernate: delete from department where deptId=?
除了delete,级联还有save-update,all,none可选择！
当选择save-update,保存数据时，没有级联的情况是：
session.save(emp1);
session.save(emp2);
session.save(dept);
而有级联的情况为session.save(dept);相关联的employee表会自动插入emp1和emp2数据。
如果要让一个实体随着另一个关联实体的操作而做相同操作(不仅仅是删除，还有增加、更新等)，那么将级联属性值设置为all即可；
而级联属性值为none，代表不做任何相同操作。
3.4一对一映射
一对一，如何表示两个实体间的关系？
我们有两种方式来表达它们之间的关系：
1.使用两张表来表示两个实体，其中一张表使用一个外键引用另一张表的主键；
注意：有外键的表的这一列，数值是不能重复的(因为一对一)。
2.使用两张表来表示两个实体，其中一张表的主键引用另一张表的主键；
一对一，常见的例子有：一个公民拥有一个身份证，一个国家只能有一个元首，一个村庄只有一个村长等等，这里以公民和身份证为例。
实体类：
public class Person {
private Integer id;
private String name;
private IdCard idCard;
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 IdCard getIdCard() {
return idCard;
}
public void setIdCard(IdCard idCard) {
this.idCard = idCard;
}
}
public class IdCard {
private Integer id;
private String number;
private Person person;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
}
映射文件：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.one2one">
<class name="Person" table="person">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="name" type="string" column="name" length="20"/>
<!-- 配置一对多关系,由于employees是list集合，所以还是使用<list>标签来配置 -->
<!-- property-ref的值为被关联方idCard的外键所对应的属性 -->
<one-to-one name="idCard" class="IdCard" property-ref="person"></one-to-one>
</class>
</hibernate-mapping>
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.one2one">
<class name="IdCard" table="idcard">
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="number" type="string" column="'number'" length="20"/>
<!-- 不是一对一吗?怎么配置成多对一？ -->
<!-- 其实也是使用外键表示两者之间的关系，只是和一对多有所区别的是，外键列值是唯一的 -->
<many-to-one name="person" class="Person" column="personId" unique="true"/>
</class>
</hibernate-mapping>
测试程序：
public class App {
private static SessionFactory sessionFactory;
static {
Configuration cfg = new Configuration();
cfg.configure("hibernate.cfg.xml");
sessionFactory = cfg.buildSessionFactory();
}
public static void main(String[] args) {
//构建对象
Person person = new Person();
person.setName("lucy");
IdCard idCard = new IdCard();
idCard.setNumber("350212199912120001");
//关联对象
person.setIdCard(idCard);
idCard.setPerson(person);
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx= session.beginTransaction();
tx.begin();
session.save(person);
session.save(idCard);
tx.commit();
} catch (HibernateException e) {
tx.rollback();
e.printStackTrace();
} finally{
session.close();
sessionFactory.close();
}
}
}
生成的sql：
Hibernate: insert into person (name) values (?) Hibernate: insert into idcard (number, personId) values (?, ?)
表结构和数据：
person
person
注意：在一对多和多对多中，我们可以设置inverse来控制由谁来维护双方的关系，而一对一中，并没有inverse属性可以设置，hibernate要求必须由有外键方的实体来维护双方的关系，即上方必须使用IdCard这个实体来维护和Person实体的关系。
3.其它映射方式
后续...
3.一起来学hibernate之配置文件2的更多相关文章
- 2.一起来学hibernate之配置文件1与持久化对象
学框架,配置都是不可少的,有了配置,框架才知道我们想做什么,才知道如何去执行我们需要的操作! hibernate的配置文件,总体来说分为两个部分: 1.主配置文件hibernate.cfg.xml文件 ...
- 1.一起来学hibernate之hibernate简介
一.简介 Hibernate,是一个开源的ORM框架.所谓的ORM,即object relative mapping,就是对象关系映射. 那什么是对象关系映射? 对象,即java类,又称为实体类,对象 ...
- eclipse 新建 maven 项目 添加 spring hibernate 的配置文件 详情
主要配置文件 pom.xml 项目的maven 配置文件 管理项目所需 jar 依赖支持 web.xml 项目的总 配置文件 :添加 spring和hibernate 支持 applicationC ...
- Hibernate常用配置文件详解
本文转载自:http://blog.csdn.net/csh624366188/article/details/7578939 初学hibernate的童鞋,刚开应该都有这种感觉,hibernate的 ...
- Hibernate的配置文件解析
配置mybatis.xml或hibernate.cfg.xml报错: <property name="connection.url">jdbc:mysql://loca ...
- Hibernate之深入Hibernate的配置文件
1.创建Configuration类的对象 Configuration类的对象代表了应用程序到SQL数据库的映射配置.Configuration类的实例对象,提供一个buildSessionFacto ...
- Hibernate之配置文件
可持久化对象有以下三种状态: 临时状态(Transient):对象在保存进数据库之前为临时状态,这时数据库中没有该对象的信息,如果没有持久化,程序退出后临时状态的对象信息将会丢失.随时可能被垃圾回收器 ...
- spring(一)--spring/springmvc/spring+hibernate(mybatis)配置文件
这篇文章用来总结一下spring,springmvc,spring+mybatis,spring+hibernate的配置文件 1.web.xml 要使用spring,必须在web.xml中定义分发器 ...
- 使用 <!-- 指定使用hibernate核心配置文件 --> <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
在bean.xml文件中,这样使用出现问题 <!-- 指定使用hibernate核心配置文件 --> <property name="configLocations&quo ...
随机推荐
- 学习 OPenGL
今天在网上看到一篇硕士论文<基于OpenGL三维虚拟场景建模技术研究_王志杰>,学习到OpenGL可以进行三维重建,决定从现在开始学习OpenGL,特开此贴.
- maxiang.io css
/**设置你自己的CSS.例如:h1 { border-bottom: 1px solid #ccc; line-height:1.6;}body { background:#FDFFD0} **/p ...
- JQuery源码解析-- 对象的创建
使用 $("a") 返回的对象就不再是一个简单的DOM对象了,而是一个复杂的JQuery对象. 那么JQuery是怎么创建对象的. 为了便于分析,我将JQuery中复杂的代码简化了 ...
- flash中设置文本字体样式
txt.setTextFormat(tf); txt.defaultTextFormat = tf;
- [goa]golang微服务框架学习（二）-- 代码自动生成
之前用过go语言的反射来做一些代码生成,参考这篇. 但是这种方式,入侵太强,需要执行对应的申明调用, 所以对GOA框架的自动生成非常感兴趣,于是仔细研究了一下,发现用的比较巧妙, 这里先卖个关子,先看 ...
- linux操作系统-脚本入门
背景:在使用linux时,经常会写一些linux命令片段,比较麻烦,有经验的程序员会把 这些碎片式的命令写成shell脚本 1.重启tomcat脚本 #!/bin/sh #kill tomcat pi ...
- 特殊的ASCII码对应的字符
Special Characters " " " quotation mark u+0022 ISOnum p:before { content:"\0022& ...
- Spring.net 间接调用被AOP拦截的方法失效（无法进入aop的拦截方法）
.下面的tx要定义 <objects xmlns="http://www.springframework.net" xmlns:db="http://www.spr ...
- Sprint 3 回顾与总结 和团队贡献分 以及Sprint 1、2、3 总概
团队情况: 团队名称:Heaven Fire 团队博客地址:https://home.cnblogs.com/u/gjpg/ 团队Github地址:ht ...
- 20155306白皎 学习技能+C语言学习
你有什么技能比大多数人更好 谈起技能,我还有感觉有微微拿得出手的也只有主持这一项才艺了吧.从小学到高中一直参加朗诵比赛,以及从小学到大学一直在所在学校有担任过主持工作. 上大学以来,也参加了院级朗诵比 ...