hibernate学习笔记03---关联

1、多对一关联：
员工和部门(多个员工属于一个部门，多对一)
部门类：
public class Department{
private int id;
private String name;
.....
getter和setter 方法
.....
}
员工类：
public class Employee{
private int id;
private String name;
public Department dept;//可以得到部门的全部信息
//按下面的方式只能知道部门的id，要想知道全部信息还得进行查询
//private int departId;
.....
getter和setter 方法
.....

}
表结构：
department：id，name
employee：id,name,dept_id(外键)
前面学的都是一个实体类对应一个表，像现在的员工类就不能很好的映射了；
员工的映射文件：
...
<class name="Employee">
....
<many-to-one name="depart" column="dept_id"/>
....
</class>
...
hibernate 解析到<many-to-one>时 根据属性名(depart)和
类名(Employee)可以知道这个属性的类型，从而可以找到
Department类的映射文件，然后根据dept_id就可以得到一条
部门信息了；
ps:hibernate默认的认为这个外检对应另一张表中的主键，如果对应的不是主键则
需要指出：<many-to-one name="depart" column="dept_id" property-ref="name"/>
操作类：
(1)保存；
......
Department depart=new Department();
depart.setName("dept name");

Employee emp=new Employee();
emp.setDepart(depart);
emp.setName("emp name");
.....
session.save(depart);
session.save(emp);
tx.commit();
.....
session.close();
ps: 如果session.save(emp)在session.save(depart)前面，
执行session.save(emp)时会先给dept_id一个0的值；
当执行了session.save(depart)后dept_id有值了，
这是hibernate会在执行更新语句更新Employee表，
这就是hibernate的强大指出(因为此时对象都是
持久态，他们的变化都会反映到数据库中的)；
(2)查询：
employee emp=(Employee)session.get(Employee.class,id);
System.out.println(emp.getDepart().getName());
ps:session.get(Employee.class,id)这语句其实是执行了两次查询，
首先查询"员工表"得到员工信息，然后根据员工信息中的部门id
在查询"部门表"得到部门表。

2、一对多关联:
还是上面的例子：从部门角度考虑就是"一对多"
部门类：
public class Department{
private int id;
private String name;
private Set<Employee> emps;
.....
getter和setter 方法
.....
}
员工类：
public class Employee{
private int id;
private String name;
public Department dept;//可以得到部门的全部信息
//按下面的方式只能知道部门的id，要想知道全部信息还得进行查询
//private int departId;
.....
getter和setter 方法
.....

}
表结构：
department：id，name
employee：id,name,dept_id(外键)
ps: 关系模型没有变化，只是对象模型变了，就是
在"部门类"中多了个Set<Employee> emps
映射文件：
员工的映射文件没有变化：
<class name="Department">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!--集合中每个元素都是一个Employee对象-->
<!--根据id=depart_id去Employee对象的表中去找-->
<set name="emps">
<key column="depart_id"/>
<one-to-many class="Employee"/>
<set>
操作类：
(1)查询：
.....
Department depart=(Department)session.get(Department.class,id);
System.out.println(depart.getEmps().size());
.....
ps:session.get(Department.class,id)是进行两次数据库访问的
先查询"部门表"查出部门信息；
在查询"员工表"根据部门id查询员工信息。

3、一对一关联：
人和身份证---一个人对应一个身份证
Person类：
public class Person{
private int id;
private String name;
private IdCard idCard;
......
getter和setter方法
......
}
IdCard类：
public class IdCard{
//此处id非自增正，而是与Person的id对应的
private int id;
private String name;
private Person person;
......
getter和setter方法
......
}
映射文件：
Person类的映射文件：
<class name="Person">
...
<one-to-one name="idCard"/>
...
</class>
IdCard类的映射文件：
<class name="IdCard" table="id_card">
<!--id是从person中拿到的不是自增长的-->
<id name="id">
<generator class="foreign">
<param name="propery">person</param>
</generator>
</id>
<one-to-one name="person" constrained="true"/>
...
</class>
操作类：
(1)添加：
.....
IdCard idCard=new IdCard();
idCard.setName("身份证");

Person p=new Person();
p.setName("lid");
p.setIdCard(idCard);

idCard.setPerson(p);

session.save(p);
session.save(idCard);
.....
(2)查询：
....
Person p=(Person)s.get(Person.class,id);
System.out.println(p.getIdCard().getName());
....

当然如果IdCard的id是自增长，而是通过外键与person关联：
IdCard类的映射文件：
<class name="IdCard" table="id_card">
<id name="id">
<generator class="native"/>
</id>
<many-to-one name="person" column="person_id" unique="true"/>
...
</class>
Person类的映射文件：
<class name="Person">
...
<one-to-one name="idCard" property-ref="person"/>
...
</class>

4、多对多关联：如老师和学生(一个老师对应多个学生，一个学生对应多个老师)
多对多是我们回创建一个中间表，这样就变成两个一对多了；
Teacher类：
public class Teacher{
private int id;
private String name;
private Set<Student> students;
......
getter 和setter方法
......
}
Student类：
public class Student{
private int id;
private String name;
private Set<Teacher> teachers;
......
getter 和setter方法
......
}
表结构：
teacher: id,name
teacher_student:teacher_id,student_id;
student:id,name;
映射文件：
Teacher的映射文件：
<class name="Teacher">
......
<!--中间表是teacher_student-->
<set name="students" table="teacher_student">
<key column="teacher_id"/>
<many-to-many class="Student" column="student_id"/>
</set>
......
</class>
Student的映射文件：
<class name="Student">
......
<!--中间表是teacher_student-->
<set name="teachers" table="teacher_student">
<key column="student_id"/>
<many-to-many class="Teacher" column="teacher_id"/>
</set>
......
</class>

5、组件关联：
Name类：
public class Name{
private String firstName;
private String lastName;
......
getter和setter方法
......
}

User类：
public class User{
private int id;
private Name name;
private Date birthday;
.....
getter 、setter方法
}
User的映射文件：
<class name=User">
......
<component name="name">
<property name="firstName" column="first_name"/>
<property name="lastName" column="last_name"/>
</component>
......
</class>
ps:当然我们也可以按一对一或者多对一来处理上面的情况，不过那样，用户和
Name就分别对应一张表了；
而向上面这种处理只会生成一张表(firstName和lastName分别对应列first_name和last_name)