java之hibernate之组合主键映射
1.在应用中经常会有主键是由2个或多个字段组合而成的。比如成绩表：
第一种方式：把主键写为单独的类
2.类的设计：studentId,subjectId ,这两个主键是一个组件。所以可以采用组件映射的方式来完成。
主键写为单独类 ResultPk;
ResultPk.java
/**
*
*组合组件类必须实现序列化接口,只有实现了序列化才能使用
*session的get方法获取对象
*/
public class ResultPk implements Serializable{
private int studentId;
private int subjectId;
public ResultPk() {
}
public ResultPk(int studentId, int subjectId) {
super();
this.studentId = studentId;
this.subjectId = subjectId;
} public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
} }
Result.java
public class Result {
private ResultPk pk;
private int score;
private Date examDate;
public Result() {
}
public Result(ResultPk pk, int score, Date examDate) {
super();
this.pk = pk;
this.score = score;
this.examDate = examDate;
}
public ResultPk getPk() {
return pk;
}
public void setPk(ResultPk pk) {
this.pk = pk;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Date getExamDate() {
return examDate;
}
public void setExamDate(Date examDate) {
this.examDate = examDate;
}
}
3.映射文件
<hibernate-mapping package="cn.sxt.pojo">
<class name="Result" table="t_result">
<composite-id name="pk" class="ResultPk">
<key-property name="studentId"/>
<key-property name="subjectId"/>
</composite-id>
<property name="score"/>
<property name="examDate"/>
</class>
</hibernate-mapping>
4.测试
public class HibernateTest {
/**
* 生成数据库表的工具方法
* */
@Test
public void testCreateDB(){
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
//第一个参数 是否打印sql脚本
//第二个参数 是否将脚本导出到数据库中执行
se.create(true, true);
}
/**
* 初始化表数据
*/
@Test
public void testInit(){
Session session = null;
Transaction tx = null;
try {
session = HibernateUtil.getSession();
tx = session.beginTransaction();
ResultPk pk1 = new ResultPk(1, 1);
ResultPk pk2 = new ResultPk(1, 2);
Result r1 = new Result(pk1, 90, new SimpleDateFormat("yyyy-MM-dd").parse("2016-09-12"));
Result r2 = new Result(pk2, 83, new SimpleDateFormat("yyyy-MM-dd").parse("2016-09-22"));
session.save(r1);
session.save(r2);
tx.commit();
} catch (Exception e) {
if(tx!=null)
tx.rollback();
}finally {
HibernateUtil.close();
}
}
/**
*/
@Test
public void testGetData(){
Session session = HibernateUtil.getSession();
ResultPk pk1 = new ResultPk(1, 1);
Result result = (Result)session.get(Result.class, pk1);
System.out.println(result.getScore()+"---"+result.getExamDate());
HibernateUtil.close();
}
}
第二种方式：直接通过一个类来描述
5.组合主键的第二种实现方式，直接通过一个类来描述
类结构
/**
* 在类中有组合主键那么必须实现Serializable接口
*
*/
public class Result implements Serializable{
private int studentId;
private int subjectId;
private int score;
private Date examDate;
public Result() {
}
public Result(int studentId, int subjectId) {
super();
this.studentId = studentId;
this.subjectId = subjectId;
}
public Result(int studentId, int subjectId, int score, Date examDate) {
super();
this.studentId = studentId;
this.subjectId = subjectId;
this.score = score;
this.examDate = examDate;
}
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
} public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Date getExamDate() {
return examDate;
}
public void setExamDate(Date examDate) {
this.examDate = examDate;
}
}
6.映射文件
<hibernate-mapping package="cn.sxt.pojo">
<class name="Result" table="t_result">
<!-- 复合主键的映射 -->
<composite-id>
<key-property name="studentId"/>
<key-property name="subjectId"/>
</composite-id>
<property name="score"/>
<property name="examDate"/>
</class>
</hibernate-mapping>
7.测试
public class HibernateTest {
/**
* 生成数据库表的工具方法
* */
@Test
public void testCreateDB(){
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
//第一个参数 是否打印sql脚本
//第二个参数 是否将脚本导出到数据库中执行
se.create(true, true);
}
/**
* 初始化表数据
*/
@Test
public void testInit(){
Session session = null;
Transaction tx = null;
try {
session = HibernateUtil.getSession();
tx = session.beginTransaction();
Result r1 = new Result(1,1, 90, new SimpleDateFormat("yyyy-MM-dd").parse("2016-09-12"));
Result r2 = new Result(1,2, 83, new SimpleDateFormat("yyyy-MM-dd").parse("2016-09-22"));
session.save(r1);
session.save(r2);
tx.commit();
} catch (Exception e) {
if(tx!=null)
tx.rollback();
}finally {
HibernateUtil.close();
}
}
/**
*/
@Test
public void testGetData(){
Session session = HibernateUtil.getSession();
Result result = new Result(1, 1);
result = (Result)session.get(Result.class, result);
System.out.println(result.getScore()+"---"+result.getExamDate());
HibernateUtil.close();
}
}
第三种方式：表结构不改变，但是组合主键代表的是外键
8.表结构不改变，但是组合主键代表的是外键
Student.java
public class Student implements Serializable{
private int id;
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Subject.java
public class Subject implements Serializable{
private int id;
private String name;
public Subject() {
}
public Subject(String name) {
super();
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Result.java
/**
* 在类中有组合主键那么必须实现Serializable接口
*
*/
public class Result implements Serializable{
private Student student;
private Subject subject;
private int score;
private Date examDate;
public Result() {
}
public Result(Student student, Subject subject) {
super();
this.student = student;
this.subject = subject;
}
public Result(Student student, Subject subject, int score, Date examDate) {
super();
this.student = student;
this.subject = subject;
this.score = score;
this.examDate = examDate;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
public Subject getSubject() {
return subject;
}
public void setSubject(Subject subject) {
this.subject = subject;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public Date getExamDate() {
return examDate;
}
public void setExamDate(Date examDate) {
this.examDate = examDate;
}
}
9.映射文件
Student.hbm.xml
<hibernate-mapping package="cn.sxt.pojo">
<class name="Student" table="t_student">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"/>
<property name="age"/>
</class>
</hibernate-mapping>
Subject.hbm.xml
<hibernate-mapping package="cn.sxt.pojo">
<class name="Subject" table="t_subject">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
Result.hbm.xml
<hibernate-mapping package="cn.sxt.pojo">
<class name="Result" table="t_result">
<!-- 复合主键的映射 -->
<composite-id>
<key-many-to-one name="student" column="studentId"/>
<key-many-to-one name="subject" column="subjectId"/>
</composite-id>
<property name="score"/>
<property name="examDate"/>
</class>
</hibernate-mapping>
10.测试
public class HibernateTest {
/**
* 生成数据库表的工具方法
* */
@Test
public void testCreateDB(){
Configuration cfg = new Configuration().configure();
SchemaExport se = new SchemaExport(cfg);
//第一个参数 是否打印sql脚本
//第二个参数 是否将脚本导出到数据库中执行
se.create(true, true);
}
/**
* 初始化表数据
*/
@Test
public void testInit(){
Session session = null;
Transaction tx = null;
try {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
session = HibernateUtil.getSession();
tx = session.beginTransaction();
Student stu1 = new Student("张三疯",150);
Student stu2 = new Student("张无忌",15);
Subject sub1 = new Subject("太极拳");
Subject sub2 = new Subject("乾坤大罗移");
Result r1 = new Result(stu1, sub1,100,df.parse("1990-08-12"));
Result r2 = new Result(stu1, sub2,0,df.parse("1990-08-13"));
Result r3 = new Result(stu2, sub1,98,df.parse("1990-08-14"));
Result r4 = new Result(stu2, sub2,90,df.parse("1990-08-14"));
session.save(stu1);
session.save(stu2);
session.save(sub1);
session.save(sub2);
session.save(r1);
session.save(r2);
session.save(r3);
session.save(r4);
tx.commit();
} catch (Exception e) {
if(tx!=null)
tx.rollback();
}finally {
HibernateUtil.close();
}
}
/**
*/
@Test
public void testGetData(){
Session session = HibernateUtil.getSession();
/*Student stu = (Student)session.get(Student.class, 1);
Subject sub = (Subject)session.get(Subject.class, 1);
Result result = new Result(stu, sub);
result = (Result)session.get(Result.class, result);*/
List<Result> list = session.createCriteria(Result.class).list();
for(Result result:list)
System.out.println(result.getStudent().getName()+"----"+result.getSubject().getName()+"----"+result.getScore());
HibernateUtil.close();
}
}
这里：注释掉的部分是取单个值，而下面的是取列表
java之hibernate之组合主键映射的更多相关文章
- hibernate笔记--组合主键映射方法
一个数据库表中其主键有可能不止一个属性,同样映射到实体类中,可能有两个或多个属性共同配置成为一个主键,假设一个实体类Score,其主键有两个属性stuId(学生编号)和subjectId(科目编号), ...
- Hibernate 组合主键映射
在开发过程中创建数据库表时,有时候会发现单纯的创建一个主键是不可行的,有时候就需要多个字段联合保持唯一,本文讲述如何创建组合主键的映射. 例如:记录一个班的考试成绩.学生跟科目是多对多的关系,只有一个 ...
- hibernate中基于主键映射1-1关联关系和基于外键映射1-1关联关系的不同
基于主键映射1-1关联关系和基于外键映射1-1关联关系的不同,主要区别是在配置映射文件上会有区别 两个持久化类为Manager和Department 1:基于主键映射1-1关联关系 1)使用其他持久化 ...
- Hibernate 中 联合主键映射 组合关系映射 大对象映射(或者说文本大对象,二进制数据大对象)
Clob:文本大对象,最长4G Blob:二进制数据大对象,最长4G util: public class HibUtil { private static SessionFactory sessio ...
- java之hibernate之基于主键的双向一对一关联映射
这篇 基于主键的双向一对一关联映射 1.依然考察人和身份证的一对一关系,如果采用主键关联,那么其表结构为: 2.类结构 Person.java public class Person implemen ...
- java之hibernate之基于主键的单向一对一关联映射
这篇讲 基于主键的单向一对一关联映射 1.依然考察人和身份证的一对一关系,如果采用主键关联,那么其表结构应该为: 2.类结构 Person.java public class Person imple ...
- Hibernate之基于主键映射的一对一关联关系
1. 基于主键的映射策略:指一端的主键生成器使用foreign策略,表明根据"对方"的主键来生成自己的主键,自己并不能独立生成主键.并用<param> 子元素指定使用当 ...
- hibernate 注解 联合主键映射
联合主键用Hibernate注解映射方式主要有三种: 第一.将联合主键的字段单独放在一个类中,该类需要实现java.io.Serializable接口并重写equals和hascode,再将 该类注解 ...
- hibernate 联合主键生成机制（组合主键XML配置方式）
hibernate 联合主键生成机制(组合主键XML配置方式) 如果数据库中用多个字段而不仅仅是一个字段作为主键,也就是联合主键,这个时候就可以使用hibernate提供的联合主键生成策略. 具体 ...
随机推荐
- 数位dp技巧
一个奇怪的东西 正反都能dp!: 正常我们数位dp都是从高到低,以这样的方式保证其小于给定数-> ll n; int num[N],l; ll dp[]; ll dfs(int p,int li ...
- XMLHttpRequest用法介绍
前言: 传统的Web应用请求服务器返回的一般是是完整的HTML页面,这样往往就需要页面进行刷新操作,不仅耗时而且用户体验度也不好.最典型的代表就是form表单登录操作了.如果登录失败往往是跳转到原网页 ...
- 如何将 普通代码变成 java lamband表达式
public static void main(String[] args) { Map<String, String> map = new HashMap<>(); List ...
- [BUAA 软工]提问回顾与个人总结
项目 内容 这个作业属于哪个课程 北航软工 这个作业的要求在哪里 提问回顾与个人总结 我在这个课程的目标是 学习如何以团队的形式开发软件,提升个人软件开发能力 这个作业在哪个具体方面帮助我实现目标 督 ...
- 使用MeadCo's ScriptX控件做WEB打印
官方网址:http://www.meadroid.com/scriptx/index.asp MeadCo's ScriptX控件有两种使用方式,一种是做为免费版本使用,一种是做为收费版本使用,免费版 ...
- MORMOT REST文件上传
MORMOT REST文件上传 上传数据格式必须是:MULTIPART/FORM-DATA uses SynCommons 后端处理参照下列代码: 后端处理参照下列代码: procedure TWeb ...
- How to receive a million packets per second
Last week during a casual conversation I overheard a colleague saying: "The Linux network stack ...
- BATJ都爱问的多线程面试题
# 一 面试中关于 synchronized 关键字的 5 连击 ### 1.1 说一说自己对于 synchronized 关键字的了解 synchronized关键字解决的是多个线程之间访问资源的同 ...
- Cassandra开发入门文档第四部分（集合类型、元组类型、时间序列、计数列）
Cassandra 提供了三种集合类型,分别是Set,List,MapSet: 非重复集,存储了一组类型相同的不重复元素,当被查询时会返回排好序的结果,但是内部构成是无序的值,应该是在查询时对结果进行 ...
- LeetCode_475. Heaters
475. Heaters Easy Winter is coming! Your first job during the contest is to design a standard heater ...