List映射表
List列表是一个java集合存储在序列中的元素，并允许重复的元素。此接口的用户可以精确地控制，其中列表中的每个元素插入。用户可以通过他们的整数索引访问元素，并搜索列表中的元素。更正式地说，列表通常允许对元素e1和e2，使得e1.equals（e2），它们通常允许多个null元素，如果他们允许的null元素。
List列表被映射在该映射表中的<list>元素，并将java.util.ArrayList中初始化。
定义RDBMS表：
考虑一个情况，需要员工记录存储在EMPLOYEE表，将有以下结构：
|
1
2
3
4
5
6
7
|
create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id)); |
此外，假设每个员工都可以有一个或多个与他/她相关的证书。List集合映射需要在一个集合表的索引列。索引列定义集合中的元素的位置。因此，我们将存储证书的相关信息在一个单独的表，该表具有以下结构：
|
1
2
3
4
5
6
7
|
create table CERTIFICATE ( id INT NOT NULL auto_increment, certificate_name VARCHAR(30) default NULL, idx INT default NULL, employee_id INT default NULL, PRIMARY KEY (id)); |
将有一个对多( one-to-many)的EMPLOYEE和证书对象之间的关系。
定义POJO类：
让我们实现一个POJO类员工将被用于保存与EMPLOYEE表中的对象和有证书的列表变量的集合。
|
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
|
import java.util.*;public class Employee { private int id; private String firstName; private String lastName; private int salary; private List certificates; public Employee() {} public Employee(String fname, String lname, int salary) { this.firstName = fname; this.lastName = lname; this.salary = salary; } public int getId() { return id; } public void setId( int id ) { this.id = id; } public String getFirstName() { return firstName; } public void setFirstName( String first_name ) { this.firstName = first_name; } public String getLastName() { return lastName; } public void setLastName( String last_name ) { this.lastName = last_name; } public int getSalary() { return salary; } public void setSalary( int salary ) { this.salary = salary; } public List getCertificates() { return certificates; } public void setCertificates( List certificates ) { this.certificates = certificates; }} |
我们需要相应的证书表定义另一个POJO类，这样的证书对象可以存储和检索到的证书表。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class Certificate{ private int id; private String name; public Certificate() {} public Certificate(String name) { 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; }} |
定义Hibernate映射文件：
让我们开发指定Hibernate如何定义的类映射到数据库表的映射文件。<list>元素将被用来定义使用List集合的规则。表的索引是整数类型总是和使用<list-index>元素定义映射。
|
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
|
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="Employee" table="EMPLOYEE"> <meta attribute="class-description"> This class contains the employee detail. </meta> <id name="id" type="int" column="id"> <generator class="native"/> </id> <list name="certificates" cascade="all"> <key column="employee_id"/> <list-index column="idx"/> <one-to-many class="Certificate"/> </list> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </class> <class name="Certificate" table="CERTIFICATE"> <meta attribute="class-description"> This class contains the certificate records. </meta> <id name="id" type="int" column="id"> <generator class="native"/> </id> <property name="name" column="certificate_name" type="string"/> </class></hibernate-mapping> |
应该保存的映射文件中的格式<classname>.hbm.xml。我们保存我们的映射文件中的文件Employee.hbm.xml。你已经熟悉了大部分的映射细节，映射文件中的所有元素：
映射文档是具有<hibernate-mapping>为对应于每一个类包含2个<class>元素的根元素的XML文档。
<class>元素被用于定义数据库表从一个Java类特定的映射。 Java类名指定使用class元素的name属性和使用表属性数据库表名指定。
<meta>元素是可选元素，可以用来创建类的描述。
<id>元素映射在类中的唯一ID属性到数据库表的主键。 id元素的name属性是指属性的类和column属性是指在数据库表中的列。 type属性保存了Hibernate映射类型，这种类型的映射将会从Java转换为SQL数据类型。
id元素内的<generator>元素被用来自动生成的主键值。将生成元素的class属性设置为原生让Hibernate拿起无论是identity，sequence或者hilo中的算法来创建主键根据底层数据库的支持能力。
<property>元素用于一个Java类的属性映射到数据库表中的列。元素的name属性是指属性的类和column属性是指在数据库表中的列。 type属性保存了Hibernate映射类型，这种类型的映射将会从Java转换为SQL数据类型。
<list>元素用于设置证书和Employee类之间的关系。我们使用cascade属性中<list>元素来告诉Hibernate来保存证书的对象，同时为Employee对象。 name属性被设置为在父类中定义的Listvariable，在我们的情况下，它是证书。
<key>元素是包含外键的父对象，即在证书表中的列。即，表EMPLOYEE。
<list-index>元素定义用于保持元件的位置，并与在该集合表的索引列映射。持久性列表的索引从零开始。你可以改变这一点，例如，在你的映射<list-index base="1".../>。
<one-to-many>元素表示一个Employee对象涉及到很多证书的对象，并因此，证书对象必须有与之劳动者家长有关。您可以根据您的需要使用任何和<one-to-one>，<many-to-one>进行或<many-to-many>这个元素。如果我们改变了这个例子使用一个many-to-many的关系，我们需要一个关联表到父和子对象之间的映射。
创建应用程序类：
最后，我们将创建应用程序类的main（）方法来运行应用程序。我们将使用这个应用程序，以节省一些员工的记录连同的证书，然后我们将申请CRUD操作上的记录。
|
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
import java.util.*; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;public class ManageEmployee { private static SessionFactory factory; public static void main(String[] args) { try{ factory = new Configuration().configure().buildSessionFactory(); }catch (Throwable ex) { System.err.println("Failed to create sessionFactory object." + ex); throw new ExceptionInInitializerError(ex); } ManageEmployee ME = new ManageEmployee(); /* Let us have a set of certificates for the first employee */ ArrayList set1 = new ArrayList(); set1.add(new Certificate("MCA")); set1.add(new Certificate("MBA")); set1.add(new Certificate("PMP")); /* Add employee records in the database */ Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, set1); /* Another set of certificates for the second employee */ ArrayList set2 = new ArrayList(); set2.add(new Certificate("BCA")); set2.add(new Certificate("BA")); /* Add another employee record in the database */ Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, set2); /* List down all the employees */ ME.listEmployees(); /* Update employee's salary records */ ME.updateEmployee(empID1, 5000); /* Delete an employee from the database */ ME.deleteEmployee(empID2); /* List down all the employees */ ME.listEmployees(); } /* Method to add an employee record in the database */ public Integer addEmployee(String fname, String lname, int salary, ArrayList cert){ Session session = factory.openSession(); Transaction tx = null; Integer employeeID = null; try{ tx = session.beginTransaction(); Employee employee = new Employee(fname, lname, salary); employee.setCertificates(cert); employeeID = (Integer) session.save(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } return employeeID; } /* Method to list all the employees detail */ public void listEmployees( ){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); List employees = session.createQuery("FROM Employee").list(); for (Iterator iterator1 = employees.iterator(); iterator1.hasNext();){ Employee employee = (Employee) iterator1.next(); System.out.print("First Name: " + employee.getFirstName()); System.out.print(" Last Name: " + employee.getLastName()); System.out.println(" Salary: " + employee.getSalary()); List certificates = employee.getCertificates(); for (Iterator iterator2 = certificates.iterator(); iterator2.hasNext();){ Certificate certName = (Certificate) iterator2.next(); System.out.println("Certificate: " + certName.getName()); } } tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } } /* Method to update salary for an employee */ public void updateEmployee(Integer EmployeeID, int salary ){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); Employee employee = (Employee)session.get(Employee.class, EmployeeID); employee.setSalary( salary ); session.update(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } } /* Method to delete an employee from the records */ public void deleteEmployee(Integer EmployeeID){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); Employee employee = (Employee)session.get(Employee.class, EmployeeID); session.delete(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } }} |
编译和执行：
下面是步骤来编译并运行上述应用程序。请确保您已在进行的编译和执行之前，适当地设置PATH和CLASSPATH。
- 创建hibernate.cfg.xml配置文件中配置章节解释。
- 创建Employee.hbm.xml映射文件，如上图所示。
- 创建Employee.java源文件，如上图所示，并编译它.
- 创建Certificate.java源文件，如上图所示，并编译它。
- 创建ManageEmployee.java源文件，如上图所示，并编译它。
- 执行ManageEmployee二进制文件来运行程序。
会在屏幕上获得以下结果，并同时记录会在员工和证书表被创建。可以看到证书已排序顺序相反。可以通过改变映射文件试试，只需设置sort="natural"和执行程序，并比较结果。
|
1
|
$java ManageEmployee |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........First Name: Manoj Last Name: Kumar Salary: 4000Certificate: MCACertificate: MBACertificate: PMPFirst Name: Dilip Last Name: Kumar Salary: 3000Certificate: BCACertificate: BAFirst Name: Manoj Last Name: Kumar Salary: 5000Certificate: MCACertificate: MBACertificate: PMP |
如果检查员工和证书表，就应该记录下了：
|
1
|
mysql> select * from EMPLOYEE; |
|
1
2
3
4
5
6
|
+----+------------+-----------+--------+| id | first_name | last_name | salary |+----+------------+-----------+--------+| 51 | Manoj | Kumar | 5000 |+----+------------+-----------+--------+1 row in set (0.00 sec) |
|
1
|
mysql> select * from CERTIFICATE; |
|
1
2
3
4
5
6
7
8
|
+----+------------------+------+-------------+| id | certificate_name | idx | employee_id |+----+------------------+------+-------------+| 6 | MCA | 0 | 51 || 7 | MBA | 1 | 51 || 8 | PMP | 2 | 51 |+----+------------------+------+-------------+3 rows in set (0.00 sec) |
或者，您也可以映射Java数组，而不是一个列表。一个数组的映射几乎是相同的前面的例子，除了与不同的元素和属性名称（<array>和<array-index>）。然而，原因如前所述，Hibernate应用程序很少使用数组。
Bag映射
Bag是一个java集合存储元素无需关心顺序，但允许列表中的重复元素。Bag是在列表中的对象的随机分组。
Collection集合被映射在该映射表中的<bag>元件和与java.util.ArrayList中初始化。
下面的示例中RDBMS表和POJO类依然使用上面定义好的。
定义Hibernate映射文件：
让我们开发指示Hibernate如何定义的类映射到数据库表的映射文件。<bag>元素将被用来定义所使用的集合规则。
|
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
|
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="Employee" table="EMPLOYEE"> <meta attribute="class-description"> This class contains the employee detail. </meta> <id name="id" type="int" column="id"> <generator class="native"/> </id> <bag name="certificates" cascade="all"> <key column="employee_id"/> <one-to-many class="Certificate"/> </bag> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </class> <class name="Certificate" table="CERTIFICATE"> <meta attribute="class-description"> This class contains the certificate records. </meta> <id name="id" type="int" column="id"> <generator class="native"/> </id> <property name="name" column="certificate_name" type="string"/> </class></hibernate-mapping> |
应该保存的映射文件中的格式<classname>.hbm.xml。我们保存映射文件Employee.hbm.xml。前面已经熟悉了大部分的映射细节，但让我们看到了映射文件中的所有元素再次：
映射文档是具有<hibernate-mapping>为对应于每一个类包含2个<class>元素的根元素的XML文档。
<class>元素被用于定义数据库表从一个Java类特定的映射。 Java类名指定使用class元素的name属性和使用表属性数据库表名指定。
<meta>元素是可选元素，可以用来创建类的描述。
<id>元素映射在类中的唯一ID属性到数据库表的主键。 id元素的name属性是指属性的类和column属性是指在数据库表中的列。 type属性保存了Hibernate映射类型，这种类型的映射将会从Java转换为SQL数据类型。
id元素内的<generator>元素被用来自动生成的主键值。将生成元素的class属性设置为原生让Hibernate拿起无论是identity，sequence或者hilo中的算法来创建主键根据底层数据库的支持能力。
<property>元素用于一个Java类的属性映射到数据库表中的列。元素的name属性是指属性的类和column属性是指在数据库表中的列。 type属性保存了Hibernate映射类型，这种类型的映射将会从Java转换为SQL数据类型。
<bag>元素用于设置证书和Employee类之间的关系。我们使用cascade属性的<bag>高的元素要告诉Hibernate来保存证书的对象，同时为Employee对象。 name属性被设置为在父类中的definedCollection变量，在我们的情况下，它是证书。
<key>元素是包含外键的父对象，即在证书表中的列。表EMPLOYEE。
<one-to-many>元素表示一个Employee对象涉及到很多证书的对象，并因此，证书对象必须有与Employee父类有关联。可以根据需要使用<one-to-one>，<many-to-one>或<many-to-many>这个元素。
创建应用程序类：
最后，我们将创建应用程序类的main（）方法来运行应用程序。我们将使用这个应用程序，以节省一些员工的记录连同的证书，然后我们将申请CRUD操作上的记录。
|
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
import java.util.*; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;public class ManageEmployee { private static SessionFactory factory; public static void main(String[] args) { try{ factory = new Configuration().configure().buildSessionFactory(); }catch (Throwable ex) { System.err.println("Failed to create sessionFactory object." + ex); throw new ExceptionInInitializerError(ex); } ManageEmployee ME = new ManageEmployee(); /* Let us have a set of certificates for the first employee */ ArrayList set1 = new ArrayList(); set1.add(new Certificate("MCA")); set1.add(new Certificate("MBA")); set1.add(new Certificate("PMP")); /* Add employee records in the database */ Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, set1); /* Another set of certificates for the second employee */ ArrayList set2 = new ArrayList(); set2.add(new Certificate("BCA")); set2.add(new Certificate("BA")); /* Add another employee record in the database */ Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, set2); /* List down all the employees */ ME.listEmployees(); /* Update employee's salary records */ ME.updateEmployee(empID1, 5000); /* Delete an employee from the database */ ME.deleteEmployee(empID2); /* List down all the employees */ ME.listEmployees(); } /* Method to add an employee record in the database */ public Integer addEmployee(String fname, String lname, int salary, ArrayList cert){ Session session = factory.openSession(); Transaction tx = null; Integer employeeID = null; try{ tx = session.beginTransaction(); Employee employee = new Employee(fname, lname, salary); employee.setCertificates(cert); employeeID = (Integer) session.save(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } return employeeID; } /* Method to list all the employees detail */ public void listEmployees( ){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); List employees = session.createQuery("FROM Employee").list(); for (Iterator iterator1 = employees.iterator(); iterator1.hasNext();){ Employee employee = (Employee) iterator1.next(); System.out.print("First Name: " + employee.getFirstName()); System.out.print(" Last Name: " + employee.getLastName()); System.out.println(" Salary: " + employee.getSalary()); Collection certificates = employee.getCertificates(); for (Iterator iterator2 = certificates.iterator(); iterator2.hasNext();){ Certificate certName = (Certificate) iterator2.next(); System.out.println("Certificate: " + certName.getName()); } } tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } } /* Method to update salary for an employee */ public void updateEmployee(Integer EmployeeID, int salary ){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); Employee employee = (Employee)session.get(Employee.class, EmployeeID); employee.setSalary( salary ); session.update(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } } /* Method to delete an employee from the records */ public void deleteEmployee(Integer EmployeeID){ Session session = factory.openSession(); Transaction tx = null; try{ tx = session.beginTransaction(); Employee employee = (Employee)session.get(Employee.class, EmployeeID); session.delete(employee); tx.commit(); }catch (HibernateException e) { if (tx!=null) tx.rollback(); e.printStackTrace(); }finally { session.close(); } }} |
编译和执行：
会在屏幕上获得以下结果，并同时记录会在员工和证书表被创建。可以看到证书已排序顺序相反。可以通过改变映射文件试试，只需设置sort="natural"和执行程序，并比较结果。
|
1
|
$java ManageEmployee |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........First Name: Manoj Last Name: Kumar Salary: 4000Certificate: MCACertificate: MBACertificate: PMPFirst Name: Dilip Last Name: Kumar Salary: 3000Certificate: BCACertificate: BAFirst Name: Manoj Last Name: Kumar Salary: 5000Certificate: MCACertificate: MBACertificate: PMP |
如果检查员工和证书表，就应该记录下了：
|
1
|
mysql> select * from EMPLOYEE; |
|
1
2
3
4
5
6
|
+----+------------+-----------+--------+| id | first_name | last_name | salary |+----+------------+-----------+--------+| 53 | Manoj | Kumar | 5000 |+----+------------+-----------+--------+1 row in set (0.00 sec) |
|
1
|
mysql> select * from CERTIFICATE; |
|
1
2
3
4
5
6
7
8
|
+----+------------------+-------------+| id | certificate_name | employee_id |+----+------------------+-------------+| 11 | MCA | 53 || 12 | MBA | 53 || 13 | PMP | 53 |+----+------------------+-------------+3 rows in set (0.00 sec) |
