Hibernate第三节(复合主键+映射问题(集合映射、一对一、一对多、多对多映射))
1>:复合主键
什么是复合主键?
就是当一个表里面的一个字段不能唯一的标识一行数据的话那么这个时候就需要这个表的多个字段来共同作为主键、这样的主键就叫做复合主键
Hibernate中的复合主键的使用(下面以用户为例、假设用户表中没有主键id、要使用uName和uAddress来共同作为主键)
1>:将要作为复合主键的这些属性抽取城一个复合主键的类
public class CompositeKey implements Serializable{
private String uName;
private String uAddress;
setter...
getter...
}2>:在用户实体中引用这个类
public class User implements Serializable{
private Date uBirth;
private Gender gender;
private String uPwd;
//在这个类里面保存复合主键的引用
private CompositeKey key; //我们的主键
setter...
getter...
}3>:在配置文件中做如下配置(User.hbm.xml)
4>:测试我们的复合主键
@Test
public void testAdd() throws Exception {
Session session=getSession();
CompositeKey key=new CompositeKey();
key.setuAddress("四川成都");
key.setuName("小波波");
//准备我们的保存数据对象
User user=new User(new Date(1234566),Gender.man,"123", key);
session.save(user);
close();
}2>:集合映射
需求:当我们在购买商品的时候、有可能用户处于不同的地点、所以需要填写不同的地址，所以假设一个用户可以对应多个地址(那么这种情况下 用户---->地址之间的关系是一对多)
使用Set集合映射实现如下:
1>:定义用户实体
public class User implements Serializable{
private int uId;
private String uName;
private String uNickName;
private String uTelNum;
//一个用户对应了多个地址 用户和地址之间是 一对多
private Set address=new HashSet();
setter...
getter...
} 2>:配置的映射文件如下
这里需要使用上面这个class的id来作为外键
下面这个key表示的是要对应上面的class中的主键
column:表示的是上面的主键对应t_address这个表的外键的名字(随便写都是对的 只不过还是要见名之意
}3>:测试代码如下
@Test
public void testSet() throws Exception {
Session session=getSession();
Set address=new HashSet();
address.add("中国云南");
address.add("中国海南");
address.add("中国甘肃");
address.add("中国河南");
User user=new User(1,"铁蛋","秋红叶落","120",address);
//执行业务逻辑
session.save(user);
close();
} 使用List实现如下
1>:编写用户实体
public class User implements Serializable{
private int uId;
private String uName;
private String uNickName;
private String uTelNum;
//一个用户对应了多个地址 用户和地址之间是 一对多
private List address=new ArrayList();
setter...
getter... 2>:映射文件如下
3>:测试类
@Test
public void testList() throws Exception {
Session session=getSession();
List address=new ArrayList();
address.add("中国云南");
address.add("中国海南");
address.add("中国甘肃");
address.add("中国河南");
User user=new User(1,"铁蛋","秋红叶落","120",address);
session.save(user);
close();
} Map集合的实现如下
1>:编写用户的实体类
public class User implements Serializable{
private int uId;
private String uName;
private String uNickName;
private String uTelNum;
private Map address=new HashMap();
} 2>:映射文件如下
3>:测试文件的使用
@Test
public void testMap() throws Exception {
Session session=getSession();
Map address=new HashMap();
address.put("第一个地址","海南三亚");
address.put("第二个地址","海南海口");
address.put("第三个地址","海南文昌");
address.put("第四个地址","四川成都");
User user=new User(1,"铁蛋","秋红叶落","120",address);
session.save(user);
close();
} 3>:一对一映射
基于外键来进行映射(在身份证中维护用户的id作为外键)
需求:用户和身份证的关系使用Hibernate映射文件来描述出来
一个用户只有一个身份证 一个身份证只是对应了一个用户
用户和身份证之间的关系:一对一
1>:设计用户的实体类
public class User {
private int uId;
private String uName;
private String uAddress;
private IdCard idCard;
setter...
getter...
}2>:设置身份证这个实体类
public class IdCard {
private String cardNum; //身份证号码
private Date cardTime; //身份证的有效时间
private User user; //一个身份证对应了一个用户
setter...
getter...
}3>:用户的配置文件
4>:有外键的一方IdCard的配置
5>:测试类
@Test
public void testOne2One() throws Exception {
//如果是基于外键映射的话那么只能通过有外键的一方来维护没有外键的这一方
//获取我们的Session对象
Session session=getSession();
User user=new User();
user.setuAddress("四川成都...");
user.setuName("小波波");
IdCard idCard=new IdCard();
idCard.setCardNum("510.....7890");
idCard.setCardTime(new Date(1234));
idCard.setUser(user);
session.save(idCard);
close();
}基于主键来进行映射(就是将用户表的主键作为身份证表的主键)
1>:用户的实体如下
public class User {
private int uId;
private String uName;
private String uAddress;
private IdCard idCard;
setter...
getter...
}2>:身份证的实体设计如下
public class IdCard {
private String cardNum; //身份证号码
private Date cardTime; //身份证的有效时间
private User user; //一个身份证对应了一个用户
//如果是基于主键来进行映射的话那么这里还需要一个字段 就是另外一个表的外键字段
private int uId; //这个就是我们维护的外键
setter...
getter...
}3>:用户的映射文件如下
4>:身份证的映射关系如下
user
5>:测试类如下
@Test
public void testOne2One() throws Exception {
//如果是基于外键映射的话那么只能通过有外键的一方来维护没有外键的这一方
//获取我们的Session对象
Session session=HibernateUtils.getSession();
User user=new User();
user.setuAddress("四川成都...");
user.setuName("小波波");
IdCard idCard=new IdCard();
idCard.setCardNum("510.....7890");
idCard.setCardTime(new Date(1234));
idCard.setUser(user);
session.save(idCard);
HibernateUtils.close();
}4>:一对多映射
需求:使用Hibernate描述部门和员工之间的关系(一个部门有多个员工 部门和员工之间的关系:一对多)
1>:描述部门的实体如下
public class Dept implements Serializable{
private int dId;
private String dName;
private String dDes;
private String dAddress;
private String dTelNum;
//一个部门有多个员工
private Set emps=new HashSet();
setter...
getter...
} 2>:描述员工的实体如下
public class Employee implements Serializable{
private int eId;
private String eName;
private String eTelNum;
private String eAddress;
private Dept dept;
setter...
getter..
}.3>:部门的映射文件如下
3>:员工的映射文件如下
4>:测试文件如下
public class Test_002 {
/**
* 测试下List集合
* @Title: testList
* @Description: TODO
* @param @throws Exception
* @return void
* @throws
*/
@Test
public void testOne2Many() throws Exception {
Session session=HibernateUtils1.getSession();
//初始化员工
Employee employee=new Employee();
employee.seteAddress("xxx");
employee.seteName("开发部");
employee.seteTelNum("112");
Employee employee1=new Employee();
employee1.seteAddress("xxx");
employee1.seteName("开发部");
employee1.seteTelNum("112");
Employee employee2=new Employee();
employee2.seteAddress("xxx");
employee2.seteName("开发部");
employee2.seteTelNum("112");
Employee employee3=new Employee();
employee3.seteAddress("xxx");
employee3.seteName("开发部");
employee3.seteTelNum("112");
Set emps=new HashSet();
emps.add(employee);
emps.add(employee1);
emps.add(employee2);
emps.add(employee3);
Dept dept=new Dept();
dept.setdAddress("18楼3教室");
dept.setdDes("JAVA教学部负责JAVA");
dept.setdName("JAVA教学部");
dept.setdTelNum("110");
dept.setEmps(emps);
session.save(dept);
HibernateUtils1.close();
}
@Test
public void testMany2One() throws Exception {
Session session=HibernateUtils1.getSession();
//因为配置了员工和部门之间的关系 所以这里是可以通过员工来维护部门的
// 维护 ：维护的是关联关系 这个所谓的关键关系指的是 两个表之间关联的字段
Employee employee=new Employee();
employee.seteAddress("xxx");
employee.seteName("铁蛋小");
employee.seteTelNum("112");
Dept dept=new Dept();
dept.setdAddress("ddd");
dept.setdDes("dddxxx");
dept.setdTelNum("120");
dept.setdName("开发部111");
employee.setDept(dept);
//最后进行保存数据
session.save(employee);
HibernateUtils1.close();
}
} 5>:多对多映射
需求:使用Hibernate描述程序员和项目之间的关系(一个程序员可以开发多个项目,一个项目可以被多个程序员来开发)
程序员------->项目 一对多
项目----------->程序员 一对多
综上所述:程序员和项目 (多对多)
1>:程序员的实体描述
public class Developer implements Serializable{
private int dId;
private String dName;
private String dTelNum;
private Set projects=new HashSet();
setter...
getter..
}. 2>:项目的实体描述
public class Project implements Serializable{
private int pId;
private String pName;
private String pDes;
private Date startTime;
private Date endTime;
private Set developers=new HashSet();
setter...
getter..
}. 3>:程序员映射文件
4>:项目的映射文件
5>:测试文件如下
@Test
public void testMany2Many() throws Exception {
Session session=HibernateUtils.getSession();
//首先准备Project
Project project=new Project();
project.setEndTime(new Date(1233444));
project.setStartTime(new Date(1233444));
project.setpName("医院床边信息娱乐系统");
project.setpDes("医院娱乐用的...");
Project project1=new Project();
project1.setEndTime(new Date(1233444));
project1.setStartTime(new Date(1233444));
project1.setpName("医院床边信息娱乐系统111");
project1.setpDes("医院娱乐用的...111");
Project project2=new Project();
project2.setEndTime(new Date(1233444));
project2.setStartTime(new Date(1233444));
project2.setpName("医院床边信息娱乐系统222");
project2.setpDes("医院娱乐用的...222");
Project project3=new Project();
project3.setEndTime(new Date(1233444));
project3.setStartTime(new Date(1233444));
project3.setpName("医院床边信息娱乐系统333");
project3.setpDes("医院娱乐用的...333");
Developer developer=new Developer();
developer.setdName("铁蛋");
developer.setdTelNum("120");
developer.getProjects().add(project);
developer.getProjects().add(project1);
developer.getProjects().add(project2);
developer.getProjects().add(project3);
//这里进行save保存
session.save(developer);
HibernateUtils.close();
}