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运作的中心,对象的生命周期.事务的管理.数据库 ...
随机推荐
- Partition 1 does not start on physical sector boundary.分区信息不正常
[root@v1 ~]# df -h Filesystem Size Used Avail Use% Mounted on /dev/sda2 20G 3.3G 16G ...
- Node.js 全栈开发(一)——Web 开发技术演化
这些年一直不断接触学习 Node 技术栈,个人的技术开发学习兴趣也越来越倾向 node 流.也许是由于英语的关系,也许是因为墙增加了学习国外一手资料的难度,加上现在流行的 web 开发技术并不太容易上 ...
- hystrix 线程数,超时时间设置测试
拜读了大拿的文章,收藏起来 https://mp.weixin.qq.com/s?__biz=MzU0OTk3ODQ3Ng==&mid=2247483791&idx=1&sn= ...
- OC-初识面向对象
面向对象和面向过程思想 OC是面向对象的,C是面向过程的.面向对象和面向过程只是解决问题的两种不同思想 面向对象和面向过程的区别 以用电脑听歌为例子 面向过程 打开电脑 播放电脑中的歌曲 关闭电脑 面 ...
- dilworth定理+属性排序(木棍加工)
P1233 木棍加工 题目描述 一堆木头棍子共有n根,每根棍子的长度和宽度都是已知的.棍子可以被一台机器一个接一个地加工.机器处理一根棍子之前需要准备时间.准备时间是这样定义的: 第一根棍子的准备时间 ...
- L156
China has specified the definition and diagnosis standard for internet addiction in its latest adole ...
- Datesheet 参数手册
1 明白P/N每一个字是代表什么含义... 这很重要! EP6095-01-381 (CL10C010CBNNNC=CL10C010CB8NNNC ?)----8 代表Ni plating in te ...
- js之3D轮播图
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...
- Python源码分析(一)
最近想学习下Python的源码,希望写个系列博客,记录的同时督促自己学习. Python源码目录 从Python.org中下载源代码压缩包并解压,我下载的是Python2.7.12,解压后: 对于主要 ...
- NGUI动态给EventDelegate加参数
示例代码如下: 响应的函数声明为: void OnChange(UIToggle toggle) { if(toggle.value) { // do something } } 添加响应的代码如 ...