详解Java的Hibernate框架中的set映射集与SortedSet映射

时间:2021-10-25 20:53:53

Set
集合Set是一个java集合不包含任何重复的元素。更正式地说,Set不包含任何元素对e1和e2,使得e1.equals(e2),和至多一个空元素。所以被添加到一组对象必须实现equals()和hashCode()方法,使Java可以判断任何两个元素/对象是否是相同的。

集被映射到与映射表中<set>元素,并在java.util.HashSet中初始化。可以使用Set集合在类时,有一个集合中不需要重复的元素。

定义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)
);

此外,假设每个员工都可以有一个或多个与他/她相关的证书。因此,我们将存储证书的相关信息在一个单独的表,该表具有以下结构:

?
1
2
3
4
5
6
create table CERTIFICATE (
 id INT NOT NULL auto_increment,
 certificate_name VARCHAR(30) default NULL,
 employee_id INT default NULL,
 PRIMARY KEY (id)
);

将有一个对多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 Set 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 Set getCertificates() {
  return certificates;
 }
 public void setCertificates( Set certificates ) {
  this.certificates = certificates;
 }
}

现在让我们定义另一个POJO类对应的表的证书,这样的证书对象可以存储和检索到的CERTIFICATE表。这个类还应该同时实现了equals()和hashCode()方法,使Java可以判断任意两个元素/对象是否相同。

?
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
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;
 }
 public boolean equals(Object obj) {
  if (obj == null) return false;
  if (!this.getClass().equals(obj.getClass())) return false;
 
  Certificate obj2 = (Certificate)obj;
  if((this.id == obj2.getId()) && (this.name.equals(obj2.getName())))
  {
   return true;
  }
  return false;
 }
 public int hashCode() {
  int tmp = 0;
  tmp = ( id + name ).hashCode();
  return tmp;
 }
}

 

定义Hibernate映射文件:
让我们开发指定Hibernate如何定义的类映射到数据库表的映射文件。<SET>元素将被用来定义用于设置集合的规则。

?
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>
  <set name="certificates" cascade="all">
   <key column="employee_id"/>
   <one-to-many class="Certificate"/>
  </set>
  <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数据类型。

<SET>元素是新的,已被引入到设置CERTIFICATE 和Employee类之间的关系。我们使用cascade属性中的<set>元素来告诉Hibernate来保存CERTIFICATE 对象,同时为Employee对象。name属性被设置为在父类中的定义设置变量,在我们的情况下,它是CERTIFICATE 。对于每一组变量,我们需要定义在映射文件中单独的一组元素。

<key>元素是包含外键的父对象,即在certificate表中的列。表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 */
  HashSet set1 = new HashSet();
  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 */
  HashSet set2 = new HashSet();
  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, Set 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());
   Set 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二进制文件来运行程序。

会在屏幕上获得以下结果,并同时记录会在员工和证书表被创建。

?
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: 4000
Certificate: MBA
Certificate: PMP
Certificate: MCA
First Name: Dilip Last Name: Kumar Salary: 3000
Certificate: BCA
Certificate: BA
First Name: Manoj Last Name: Kumar Salary: 5000
Certificate: MBA
Certificate: PMP
Certificate: MCA

如果检查员工和证书表,就应该记录下了:

?
1
mysql> select * from employee;
?
1
2
3
4
5
6
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | 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 |
+----+------------------+-------------+
| 1 | MBA    |   1 |
| 2 | PMP    |   1 |
| 3 | MCA    |   1 |
+----+------------------+-------------+
3 rows in set (0.00 sec)
?
1
mysql>

SortedSet
SortedSet是java集合,该集合不包含任何重复的元素和元素使用提供他们的自然顺序,或由一个比较器进行排序。

一个SortedSet映射,在映射表<set>元素和java.util.TreeSet中初始化。排序属性可以被设置为一个比较器或自然顺序。如果使用自然顺序,那么它的迭代器遍历的集合元素升序排列。

我们依然使用上面示例中所定义的RDBMS表,将有一个对多EMPLOYEE和证书对象之间的关系,POJO类也是如上定义。

让我们实现POJO类员工将被用于保存EMPLOYEE表中的对象和有证书的SortedSet变量的集合。

现在让我们定义另一个POJO类对应的表的证书,这样的证书对象可以存储和检索到的证书表。这个类还应该实现Comparable接口和compareTo方法将被用来设置sort="natural" 在映射文件(见下面的映射文件)的情况下,元素进行排序。

?
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
public class Certificate implements Comparable <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;
 }
 public int compareTo(Certificate that){
  final int BEFORE = -1;
  final int AFTER = 1;
 
  if (that == null) {
   return BEFORE;
  }
 
  Comparable thisCertificate = this.getName();
  Comparable thatCertificate = that.getName();
 
  if(thisCertificate == null) {
   return AFTER;
  } else if(thatCertificate == null) {
   return BEFORE;
  } else {
   return thisCertificate.compareTo(thatCertificate);
  }
 }
}

定义Hibernate映射文件:
让我们开发指定Hibernate如何定义的类映射到数据库表的映射文件。该<set>元素将被用来定义所使用的SortedSet集合的规则。

?
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>
  <set name="certificates" cascade="all" sort="MyClass">
   <key column="employee_id"/>
   <one-to-many class="Certificate"/>
  </set>
  <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数据类型。

<set>元素用于设置证书和Employee类之间的关系。我们使用cascade属性中的<set>元素来告诉Hibernate来保存证书的对象,同时为Employee对象。 name属性被设置为在父类中的定义的SortedSet的变量,在我们的情况下,它是证书。排序属性可以设置为自然有自然排序,也可以设置为自定义类实现为java.util.Comparator。我们已经使用了一个类MyClass,它实现为java.util.Comparator扭转证书类实现的排序顺序。

<key>元素是包含外键的父对象,即在证书表中的列。表EMPLOYEE。

该<one-to-many>元素表示一个Employee对象涉及到很多证书的对象,并因此,证书对象必须有与父Employee有关。可以根据需要使用任何和<one-to-one>,<many-to-one>进行或<many-to-many>这个元素。

如果使用sort="natural"的设置,并不需要创建一个单独的类,因为证书类已经实现了Comparable接口和hibernate会使用compareTo(在证书类定义为比较证书名称)方法。但是,我们使用的是在我们的映射文件自定义的比较器类MyClass,所以必须创建这个类的基础上实现排序算法。降序时使用这个类在这个类排序。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Comparator;
 
public class MyClass implements Comparator<Certificate>{
 public int compare(Certificate o1, Certificate o2) {
  final int BEFORE = -1;
  final int AFTER = 1;
 
  /* To reverse the sorting order, multiple by -1 */
  if (o2 == null) {
   return BEFORE * -1;
  }
 
  Comparable thisCertificate = o1.getName();
  Comparable thatCertificate = o2.getName();
 
  if(thisCertificate == null) {
   return AFTER * 1;
  } else if(thatCertificate == null) {
   return BEFORE * -1;
  } else {
   return thisCertificate.compareTo(thatCertificate) * -1;
  }
 }
}

创建应用程序类:
最后,我们将创建应用程序类的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 */
  TreeSet set1 = new TreeSet();
  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 */
  TreeSet set2 = new TreeSet();
  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, SortedSet 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());
   SortedSet 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: 4000
Certificate: PMP
Certificate: MCA
Certificate: MBA
First Name: Dilip Last Name: Kumar Salary: 3000
Certificate: BCA
Certificate: BA
First Name: Manoj Last Name: Kumar Salary: 5000
Certificate: PMP
Certificate: MCA
Certificate: MBA

如果检查员工和证书表,就应该记录下了:

?
1
mysql> select * from employee;
?
1
2
3
4
5
6
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 1 | 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 |
+----+------------------+-------------+
| 1 | MBA    |   1 |
| 2 | PMP    |   1 |
| 3 | MCA    |   1 |
+----+------------------+-------------+
3 rows in set (0.00 sec)