Hibernate学习6—Hibernate 映射类型
第一节:基本类型映射

com.cy.model.Book.java:
package com.cy.model; import java.sql.Blob;
import java.util.Date; public class Book {
private int id;
private String bookName; // 图书名称
private float price; //图书价格
private boolean specialPrice; //是否是特价
private Date publishDate; // 发布日期
private String author; // 作者
private String introduction; // 简介
private Blob bookPic; // 图书图片 public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public boolean isSpecialPrice() {
return specialPrice;
}
public void setSpecialPrice(boolean specialPrice) {
this.specialPrice = specialPrice;
}
public Date getPublishDate() {
return publishDate;
}
public void setPublishDate(Date publishDate) {
this.publishDate = publishDate;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getIntroduction() {
return introduction;
}
public void setIntroduction(String introduction) {
this.introduction = introduction;
}
public Blob getBookPic() {
return bookPic;
}
public void setBookPic(Blob bookPic) {
this.bookPic = bookPic;
} }
Book.hbm.xml:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.cy.model">
<class name="Book" table="t_book">
<id name="id" column="bookId">
<generator class="native"></generator>
</id>
<!--
type是对应的hibernate映射类型
length=“40”表示字符串长度为40
-->
<property name="bookName" column="bookName" length="40"></property>
<property name="price" column="price" type="float"></property>
<property name="specialPrice" column="specialPrice" type="boolean"></property>
<property name="publishDate" column="publishDate" type="date"></property>
<property name="author" column="author" length="20"></property>
<property name="introduction" column="introduction" type="text"></property>
<property name="bookPic" column="bookPic" type="blob"></property>
</class>
</hibernate-mapping>
BookTest.java测试代码:
public class BookTest {
public static void main(String[] args) throws ParseException, IOException {
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
Book book = new Book();
book.setBookName("java编程思想");
book.setPrice(100);
book.setSpecialPrice(true);
book.setAuthor("埃克尔");
book.setPublishDate(new SimpleDateFormat("yyyy-MM-dd").parse("2017-1-1"));
book.setIntroduction("简介...");
LobHelper lobHelper = session.getLobHelper();
InputStream in = new FileInputStream("c://java编程思想.jpg");
Blob bookPic = lobHelper.createBlob(in, in.available());
book.setBookPic(bookPic);
session.save(book);
session.getTransaction().commit();
session.close();
}
}
结果:
t_book:

存数据后:

第二节:集合类型映射

1.Set集合映射:
Student.java:
package com.cy.model;
import java.util.Set;
public class Student {
private long id;
private String name;
private Set<String> images;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<String> getImages() {
return images;
}
public void setImages(Set<String> images) {
this.images = images;
}
}
Student.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Student" table="t_student">
<id name="id" column="stuId">
<generator class="native"></generator>
</id>
<property name="name" column="stuName"></property>
<!-- t_image表的外键studentId关联Student表的主键
element元素是集合的元素
-->
<set name="images" table="t_image">
<key column="studentId"></key>
<element column="imageName" type="string"></element>
</set>
</class>
</hibernate-mapping>
测试:
@Test
public void testSetSave(){
Set<String> imageSet=new HashSet<String>();
imageSet.add("image1.png");
imageSet.add("image2.png");
imageSet.add("image3.png");
imageSet.add("image3.png"); Student s1=new Student();
s1.setImages(imageSet);
session.save(s1);
} @Test
public void testSetFetch(){
Student student=(Student)session.get(Student.class, Long.valueOf(1));
Iterator it = student.getImages().iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
执行testSetSave后:
t_student

t_image:外键studentId 参考t_student的主键列

2.List集合映射:
Student2.java:
package com.cy.model;
import java.util.List;
public class Student2 {
private long id;
private String name;
private List<String> images;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getImages() {
return images;
}
public void setImages(List<String> images) {
this.images = images;
}
}
Student2.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Student2" table="t_student">
<id name="id" column="stuId">
<generator class="native"></generator>
</id>
<property name="name" column="stuName"></property>
<list name="images" table="t_image2">
<key column="studentId"></key>
<list-index column="imageIndex"></list-index>
<element column="imageName" type="string"></element>
</list>
</class>
</hibernate-mapping>
测试代码:
@Test
public void testListSave(){
List<String> imageList=new ArrayList<String>();
imageList.add("image1.png");
imageList.add("image2.png");
imageList.add("image3.png");
imageList.add("image3.png"); Student2 s2=new Student2();
s2.setImages(imageList);
session.save(s2);
} @Test
public void testListFetch(){
Student2 student2=(Student2)session.get(Student2.class, Long.valueOf(2));
Iterator it = student2.getImages().iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
t_student:

t_image2:

3.Bag集合映射:
package com.cy.model;
import java.util.List;
public class Student3 {
private long id;
private String name;
private List<String> images;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getImages() {
return images;
}
public void setImages(List<String> images) {
this.images = images;
}
}
Student3.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Student3" table="t_student">
<id name="id" column="stuId">
<generator class="native"></generator>
</id>
<property name="name" column="stuName"></property>
<idbag name="images" table="t_image3">
<collection-id type="long" column="imageId">
<generator class="increment"></generator>
</collection-id>
<key column="studentId"></key>
<element column="imageName" type="string"></element>
</idbag>
</class>
</hibernate-mapping>
测试代码:
@Test
public void testBagSave(){
List<String> imageList=new ArrayList<String>();
imageList.add("image1.png");
imageList.add("image2.png");
imageList.add("image3.png");
imageList.add("image3.png"); Student3 s3=new Student3();
s3.setImages(imageList);
session.save(s3);
} @Test
public void testBagFetch(){
Student3 student3 =(Student3)session.get(Student3.class, Long.valueOf(3));
Iterator it = student3.getImages().iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}


4.Map集合映射
Student4.java:
package com.cy.model;
import java.util.Map;
public class Student4 {
private long id;
private String name;
private Map<String, String> images;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<String, String> getImages() {
return images;
}
public void setImages(Map<String, String> images) {
this.images = images;
}
}
Student4.hbm.xml:
<hibernate-mapping package="com.cy.model">
<class name="Student4" table="t_student">
<id name="id" column="stuId">
<generator class="native"></generator>
</id>
<property name="name" column="stuName"></property>
<map name="images" table="t_image4">
<key column="studentId"></key>
<map-key column="imageKey" type="string"></map-key>
<element column="imageName" type="string"></element>
</map>
</class>
</hibernate-mapping>
测试代码:
@Test
public void testMapSave(){
Map<String, String> imageMap = new HashMap<String, String>();
imageMap.put("i1", "image1.png");
imageMap.put("i2", "image2.png");
imageMap.put("i3", "image3.png");
imageMap.put("i4", "image4.png"); Student4 s4=new Student4();
s4.setImages(imageMap);
session.save(s4);
} @Test
public void testMapFetch(){
Student4 student4 =(Student4)session.get(Student4.class, Long.valueOf(4));
/**
* 遍历map,方法一
*/
Iterator<Entry<String, String>> it = student4.getImages().entrySet().iterator();
while(it.hasNext()){
Entry<String, String> entry = it.next();
System.out.println(entry.getKey() + "----" + entry.getValue());
} System.out.println("------------------------------------------------"); /**
* 方法二
*/
Map<String, String> imageMap = student4.getImages();
Set<String> imageKey = imageMap.keySet();
Iterator<String> its = imageKey.iterator();
while(its.hasNext()){
String key = its.next();
System.out.println(key + ":" + imageMap.get(key));
}
}
执行testMapSave:
t_image4表结构:



执行testMapFetch:

Hibernate学习6—Hibernate 映射类型的更多相关文章
- [原创]java WEB学习笔记86:Hibernate学习之路-- -映射 n-n 关系,单向n-n,双向n-n
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- [原创]java WEB学习笔记85:Hibernate学习之路-- -映射 一对一关系 ,基于主键方式实现
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- [原创]java WEB学习笔记84:Hibernate学习之路-- -映射 一对一关系 ,基外键的方式实现
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- [原创]java WEB学习笔记82:Hibernate学习之路---映射 一对多关联关系,配置,CRUD方法测试及注意点
本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱 ...
- Hibernate学习(二)关系映射----基于外键的单向一对一
事实上,单向1-1与N-1的实质是相同的,1-1是N-1的特例,单向1-1与N-1的映射配置也非常相似.只需要将原来的many-to-one元素增加unique="true"属性, ...
- Hibernate学习笔记-Hibernate关系映射
1. 初识Hibernate——关系映射 http://blog.csdn.net/laner0515/article/details/12905711 2. Hibernate 笔记8 关系映射1( ...
- Hibernate学习0.Hibernate入门
Hibernate是什么 面向java环境的对象/关系数据库映射工具. 1.开源的持久层框架. 2.ORM(Object/Relational Mapping)映射工具,建立面向对象的域模型和关系数据 ...
- hibernate学习之Hibernate API
1. Hibernate Api分类 1)提供访问数据库的操作(如保存,更新,删除,查询)的接口.这些接口包括:Session, Transaction,,Query接口. 2)由于配置Hiberna ...
- Hibernate学习笔记-Hibernate HQL查询
Session是持久层操作的基础,相当于JDBC中的Connection,通过Session会话来保存.更新.查找数据.session是Hibernate运作的中心,对象的生命周期.事务的管理.数据库 ...
随机推荐
- ios 第3天
在手动引用计数中 每一次调用 retain retainCount 就会加一 每一次release retainCount就会减一 当retainCount 为零时 就会free (p) ; ...
- C语言动态库和静态库的使用及实践
转自:https://www.cnblogs.com/CoderTian/p/5902154.html 1.C语言中的链接器 (1)每个 C 语言源文件被编译后生成目标文件,这些目标文件最终要被链接 ...
- Java多线程编程实战指南(核心篇)读书笔记(一)
(尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/76422930冷血之心的博客) 博主准备恶补一番Java高并发编程相 ...
- 随手一写就是一个侧滑关闭activity
刚忙完一段时间,今天刚清闲会,就把以前写的东西整理整理.于是冥冥中发现有些东西完全可以共享出来,毕竟那么常见,而且简单实用. 实现原因 其实侧滑关闭activity在网上也有大量的文章去介绍他,我也有 ...
- Swift 保存pdf并在webview显示
本例中服务器返回的是base64 字符串,也可以直接返回byte[],看server接口的定义 let nsData = NSData(base64Encoded: data!!) 拿到nsData以 ...
- java入门学习(6)—封装,继承,多态,this,super,初始代码块
1.[封装]:将对象的状态信息隐藏,不允许直接访问,而是通过该类提供的的方法阿里实现内部信息的访问和操作. 使用到的修饰符:private,不用修饰符(default),protected,publi ...
- clean-css 安装 使用
https://github.com/jakubpawlowicz/clean-css-cli https://davidwalsh.name/clean-css
- Python3 移动文件——合集
文件/文件夹操作头文件 import os import shutil 参考 Python3批量移动指定文件到指定文件夹
- 【剑指offer】栈的压入弹出序列,C++实现(举例)
原创文章,转载请注明出处! 本题牛客网地址 博客文章索引地址 博客文章中代码的github地址 1.题目 输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为第一个序列的出栈序列.注意 ...
- 【机器学习】集成学习之sklearn中的xgboost基本用法
原创博文,转载请注明出处!本文代码的github地址 博客索引地址 1.数据集 数据集使用sklearn自带的手写数字识别数据集mnist,通过函数datasets导入.mnist共1797个样 ...