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提供的联合主键生成策略. 具体 ...
随机推荐
- 第一章 Electron介绍 | Electron in Action(中译)
Github 官方地址 代表作: Visual Studio Code Atom - Code editor. Github开源的代码编辑器,Electron起源地 Visual Studio Cod ...
- UDF——Fluent与Matlab数据耦合
本文编译工具:VC++ UDF Studio 该插件可以直接在Visual Studio中一键编译.加载.调试UDF源码,极大提高编写排错效率,且支持C++,MFC,Windows API和第三方库, ...
- 安装tensorflow-gpu2.0(windows)
anaconda安装见前一篇https://www.cnblogs.com/wintersoft/p/11609188.html https://mirrors.tuna.tsinghua.edu.c ...
- SpringCloud之application.properties和bootstrap.properties区别
Spring是有上下文一说的,也叫Application Context,Application Context又是有父子关系的,所以必须要理解ApplicationContext是什么.Spring ...
- TP 控制器和模型里面order 写法不同
控制器: Db::table('think_user')->where('status=1')->order('id desc')->limit(5)->select(); ...
- Metasploit使用内网跳板， 扫描局域网主机
最近,拿到一台内网机器, 苦于无法使用nmap扫描改主机的内网, 所以才有此文 在跳板机子获取一定权限后,需要积极的向内网主机权限发展,获取指定的目标信息,探查系统漏洞,借助msf已经得到的meter ...
- 网页版查看Android源码地址
Android社区 http://www.androidos.net.cn/sourcecode
- Golang常见小细节总结（1）
本系列不定期更新,用于记录平常开发过程中出现的一些小问题 Array 类型的值作为函数参数    可以理解slice是对array的一个视图,底层还是array所以会被修改 通过map的ok来确 ...
- TransactionScope处理分布式事物时提示"事务已被隐式或显式提交,或已终止"
在连接字符串中加入"Enlist=false",问题就这样解决了. ConnectionString = "Data Source=.;Initial Catalog=c ...
- 大数据 -- kafka学习笔记：知识点整理（部分转载）
一 为什么需要消息系统 1.解耦 允许你独立的扩展或修改两边的处理过程,只要确保它们遵守同样的接口约束. 2.冗余 消息队列把数据进行持久化直到它们已经被完全处理,通过这一方式规避了数据丢失风险.许多 ...