Hibernate4Step4

发表于   |   分类于   |     |   阅读次数

hardwork

本着应用的目的快速学习Hibernate4框架

  • Hibernate映射类型

前面的话

本节主要介绍：

本文主要讲解Hibernate4的类型映射，主要包括如下：

  1. 基本类型映射
  2. 集合类型映射

基本类型映射

basicDataTypeMapping

据此编写一个图书的Demo，以了解常用基本类型映射的应用：1.编写Book类；2.编写映射文件；3.编写测试类（测试类只写了保存图书的方法)。

编写Book类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package cn.codeforgod.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="cn.codeforgod.model">

    <class name="Book" table="t_book">
        <id name="id" column="bookId">
            <generator class="native"></generator>
        </id>

        <property name="bookName" column="bookName" type="string"
            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="introduction" column="introduction" type="text"></property>
        <property name="author" column="author" type="string" length="20"></property>
        <property name="bookPic" column="bookPic" type="blob"></property>

    </class>

</hibernate-mapping>

编写BookTest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package cn.codeforgod.test;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Blob;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import org.hibernate.LobHelper;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import cn.codeforgod.model.Book;
import cn.codeforgod.util.HibernateUtil;

public class BookTest
{
	public static void main(String[] args) throws ParseException, IOException
	{
		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		
		Book book = new Book();
		book.setBookName("java编程思想");
		book.setPrice(100);
		book.setSpecialPrice(true);
		book.setPublishDate(new SimpleDateFormat("yyyy-MM-dd").parse("2012-1-1"));
		book.setAuthor("埃克尔");
		book.setIntroduction("简介...");
		LobHelper lobHelper = session.getLobHelper();
		InputStream in = new FileInputStream("image/java编程思想.jpg");
		Blob bookPic = lobHelper.createBlob(in, in.available());
		book.setBookPic(bookPic);
		
		session.save(book);
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
}

Tips:别忘了在hibernate.cfg.xml配置<mapping resource="cn/codeforgod/model/Book.hbm.xml"/>

集合类型映射

集合类型映射包括4种，分别如下：

  1. Set 无序 元素不可重复
  2. List 有序 元素可重复
  3. Map 无序 键值对 键不可重复
  4. Bag 无序 元素可重复

Tips：这里的有序无序是相对于数据获取而言，如List，在数据库中必须有一个可以表示顺序的字段与之对应顺序，则称为有序。

这里也写了个Demo，以了解集合类型映射的应用：1.编写Student类，Student对象中有4个集合属性，分别对应不同的集合类型映射；2.编写映射文件；3.编写测试类（测试时，别忘了在hibernate.cfg.xml中配置）

Student类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package cn.codeforgod.model;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Student
{
	private long id;
	private String name;
	private Set<String> images1;	// Set 无序 元素不可重复
	private List<String> images2;	// List 有序 元素可重复
	private Map<String, String> images3;	// Map 无序 键值对 键不可重复
	private List<String> images4;	// Bag 无序 元素可重复
	
	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> getImages1()
	{
		return images1;
	}
	public void setImages1(Set<String> images1)
	{
		this.images1 = images1;
	}
	public List<String> getImages2()
	{
		return images2;
	}
	public void setImages2(List<String> images2)
	{
		this.images2 = images2;
	}
	public Map<String, String> getImages3()
	{
		return images3;
	}
	public void setImages3(Map<String, String> images3)
	{
		this.images3 = images3;
	}
	public List<String> getImages4()
	{
		return images4;
	}
	public void setImages4(List<String> images4)
	{
		this.images4 = images4;
	}
}

Student.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="cn.codeforgod.model">

    <class name="Student" table="t_student">
        <id name="id" column="studentId">
            <generator class="native"></generator>
        </id>

        <property name="name" column="studentName"></property>

        <set name="images1" table="t_image1">
            <key column="studentId"></key>
            <element column="imageName" type="string"></element>
        </set>

        <list name="images2" table="t_image2">
            <key column="studentId"></key>
            <!-- list需要索引 -->
            <index column="imageIndex"></index>
            <element column="imageName" type="string"></element>
        </list>

        <map name="images3" table="t_image3">
            <key column="studentId"></key>
            <map-key column="imageKey" type="string"></map-key>
            <element column="imageName" type="string"></element>
        </map>

        <idbag name="images4" table="t_image4">
            <collection-id column="imageId" type="long">
                <generator class="increment"></generator>
            </collection-id>
            <key column="studentId"></key>
            <element column="imageName" type="string"></element>
        </idbag>
    </class>

</hibernate-mapping>

StudentTest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package cn.codeforgod.test;

import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import cn.codeforgod.model.Student;
import cn.codeforgod.util.HibernateUtil;

public class StudentTest
{
	public static void main(String[] args) throws ParseException, IOException
	{
		testStudent();
	}
	
	public static void testStudent()
	{
		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		
		// 存
		Session session1 = sessionFactory.openSession();
		Transaction transaction1 = session1.beginTransaction();
		
		Set<String> images1 = new HashSet<String>();
		images1.add("image1.png");
		images1.add("image2.png");
		images1.add("image3.png");
		
		List<String> images2 = new ArrayList<String>();
		images2.add("image1.png");
		images2.add("image2.png");
		images2.add("image3.png");
		// 重复
		images2.add("image3.png");
		
		Map<String, String> images3 = new HashMap<String, String>();
		images3.put("key1", "image1.png");
		images3.put("key2", "image2.png");
		images3.put("key3", "image3.png");
		
		List<String> images4 = new ArrayList<String>();
		images4.add("image1.png");
		images4.add("image2.png");
		images4.add("image3.png");
		images4.add("image4.png");
		images4.add("image5.png");
		images4.add("image6.png");
		images4.add("image7.png");
		images4.add("image8.png");
		images4.add("image9.png");
		// 重复
		images4.add("image9.png");
		
		
		Student s1 = new Student();
		s1.setImages1(images1);
		s1.setImages2(images2);
		s1.setImages3(images3);
		s1.setImages4(images4);
		
		session1.save(s1);
		transaction1.commit();
		session1.close();
		
		// 取
		Session session2 = sessionFactory.openSession();
		Transaction transaction2 = session2.beginTransaction();
		
		Student student = (Student) session2.get(Student.class, Long.valueOf(1));
		
		Set<String> imgs1 = student.getImages1();
		System.out.println("set,images1");
		for(String imgStr : images1)
		{
			System.out.println(imgStr);
		}
		
		List<String> imgs2 = student.getImages2();
		System.out.println("list,images2");
		for(String imgStr : images2)
		{
			System.out.println(imgStr);
		}
		
		Map<String, String> imgs3 = student.getImages3();
		System.out.println("map,images3");
		for(Entry entry : imgs3.entrySet())
		{
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
		
		List<String> imgs4 = student.getImages4();
		System.out.println("list,images4");
		for(String imgStr : images4)
		{
			System.out.println(imgStr);
		}
		
		transaction2.commit();
		session2.close();
		
		sessionFactory.close();
	}
}

表之间的关系如下图：

collectionMapping

代码写的好，话不用多说，还是啰嗦一句，根据OID获取对象后获取集合元素时，除了list是根据设置的索引的顺序的字段，其余的都是根据id，当你看到有序时，请不要见怪，因为插入的记录多了，根据id来，不就没有顺序了么。

Paul

人最宝贵的东西是生命,生命属于人只有一次.一个人的一生应该是这样度过的：当他回首往事的时候，他不会因为虚度年华而悔恨，也不会因为碌碌无为而羞耻；这样，在临死的时候，他就能够说：“我的整个生命和全部精力，都已经献给世界上最壮丽的事业——为人类的解放而斗争。”

坚持原创技术分享，您的支持将鼓励我继续创作