详解Java的Hibernat框架中的Map映射与SortedMap映射
Map映射
Map映射是一个java集合存储在键-值对的元素，并且不允许在列表中重复的元素。Map接口提供三种collection视图，允许Map内容看作是一组键-值集合，或者设置键-值映射关系。
Map被映射到映射表中一个<map>元素和无序的地图可以在java.util.HashMap中被初始化。
定义RDBMS表：
考虑一个情况，我们需要员工记录存储在EMPLOYEE表，将有以下结构：
createtableEMPLOYEE( idINTNOTNULLauto_increment, first_nameVARCHAR(20)defaultNULL, last_nameVARCHAR(20)defaultNULL, salaryINTdefaultNULL, PRIMARYKEY(id) );
此外，假设每个员工都可以有一个或多个与他/她相关的证书。我们将存储证书的相关信息在一个单独的表，该表具有以下结构：
createtableCERTIFICATE( idINTNOTNULLauto_increment, certificate_typeVARCHAR(40)defaultNULL, certificate_nameVARCHAR(30)defaultNULL, employee_idINTdefaultNULL, PRIMARYKEY(id) );
有一个对多（one-to-many）的关系在EMPLOYEE和证书对象之间。
定义POJO类：
让我们实现一个POJO类员工将被用于保存与EMPLOYEE表中的对象和有证书的列表变量的集合。
importjava.util.*;
publicclassEmployee{
privateintid;
privateStringfirstName;
privateStringlastName;
privateintsalary;
privateMapcertificates;
publicEmployee(){}
publicEmployee(Stringfname,Stringlname,intsalary){
this.firstName=fname;
this.lastName=lname;
this.salary=salary;
}
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetFirstName(){
returnfirstName;
}
publicvoidsetFirstName(Stringfirst_name){
this.firstName=first_name;
}
publicStringgetLastName(){
returnlastName;
}
publicvoidsetLastName(Stringlast_name){
this.lastName=last_name;
}
publicintgetSalary(){
returnsalary;
}
publicvoidsetSalary(intsalary){
this.salary=salary;
}
publicMapgetCertificates(){
returncertificates;
}
publicvoidsetCertificates(Mapcertificates){
this.certificates=certificates;
}
}
我们需要相应的证书表定义另一个POJO类，这样的证书对象可以存储和检索到的证书表。
publicclassCertificate{
privateintid;
privateStringname;
publicCertificate(){}
publicCertificate(Stringname){
this.name=name;
}
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
}
定义Hibernate映射文件：
让我们开发指示Hibernate如何定义的类映射到数据库表的映射文件。<map>元素将被用于定义所使用的映射的规则。
<?xmlversion="1.0"encoding="utf-8"?> <!DOCTYPEhibernate-mappingPUBLIC "-//Hibernate/HibernateMappingDTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <classname="Employee"table="EMPLOYEE"> <metaattribute="class-description"> Thisclasscontainstheemployeedetail. </meta> <idname="id"type="int"column="id"> <generatorclass="native"/> </id> <mapname="certificates"cascade="all"> <keycolumn="employee_id"/> <indexcolumn="certificate_type"type="string"/> <one-to-manyclass="Certificate"/> </map> <propertyname="firstName"column="first_name"type="string"/> <propertyname="lastName"column="last_name"type="string"/> <propertyname="salary"column="salary"type="int"/> </class> <classname="Certificate"table="CERTIFICATE"> <metaattribute="class-description"> Thisclasscontainsthecertificaterecords. </meta> <idname="id"type="int"column="id"> <generatorclass="native"/> </id> <propertyname="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数据类型。
<map>元素用于设置证书和Employee类之间的关系。我们使用cascade属性的<map>元素来告诉Hibernate来保存证书的对象，同时为Employee对象。name属性设置为定义Mapvariable在父类中，在我们的案例中是证书。
<index>的元素用于表示键/值对地图的关键部位。该键将使用一个字符串类型的存储在列certificate_type。
<key>元素是包含外键的父对象，即在证书表中的列。表EMPLOYEE。
<one-to-many>元素表示一个Employee对象涉及到很多证书的对象，并因此，证书对象必须有与Employee父类有关。可以根据需要使用<one-to-one>，<many-to-one>或<many-to-many>这个元素。
创建应用程序类：
最后，创建应用程序类的main（）方法来运行应用程序。使用这个应用程序来保存员工记录地连同证书列表，然后在应用上执行CRUD操作上的记录。
importjava.util.*;
importorg.hibernate.HibernateException;
importorg.hibernate.Session;
importorg.hibernate.Transaction;
importorg.hibernate.SessionFactory;
importorg.hibernate.cfg.Configuration;
publicclassManageEmployee{
privatestaticSessionFactoryfactory;
publicstaticvoidmain(String[]args){
try{
factory=newConfiguration().configure().buildSessionFactory();
}catch(Throwableex){
System.err.println("FailedtocreatesessionFactoryobject."+ex);
thrownewExceptionInInitializerError(ex);
}
ManageEmployeeME=newManageEmployee();
/*Letushaveasetofcertificatesforthefirstemployee*/
HashMapset=newHashMap();
set.put("ComputerScience",newCertificate("MCA"));
set.put("BusinessManagement",newCertificate("MBA"));
set.put("ProjectManagement",newCertificate("PMP"));
/*Addemployeerecordsinthedatabase*/
IntegerempID=ME.addEmployee("Manoj","Kumar",4000,set);
/*Listdownalltheemployees*/
ME.listEmployees();
/*Updateemployee'ssalaryrecords*/
ME.updateEmployee(empID,5000);
/*Listdownalltheemployees*/
ME.listEmployees();
}
/*Methodtoaddanemployeerecordinthedatabase*/
publicIntegeraddEmployee(Stringfname,Stringlname,
intsalary,HashMapcert){
Sessionsession=factory.openSession();
Transactiontx=null;
IntegeremployeeID=null;
try{
tx=session.beginTransaction();
Employeeemployee=newEmployee(fname,lname,salary);
employee.setCertificates(cert);
employeeID=(Integer)session.save(employee);
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
returnemployeeID;
}
/*Methodtolistalltheemployeesdetail*/
publicvoidlistEmployees(){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Listemployees=session.createQuery("FROMEmployee").list();
for(Iteratoriterator1=
employees.iterator();iterator1.hasNext();){
Employeeemployee=(Employee)iterator1.next();
System.out.print("FirstName:"+employee.getFirstName());
System.out.print("LastName:"+employee.getLastName());
System.out.println("Salary:"+employee.getSalary());
Mapec=employee.getCertificates();
System.out.println("Certificate:"+
(((Certificate)ec.get("ComputerScience")).getName()));
System.out.println("Certificate:"+
(((Certificate)ec.get("BusinessManagement")).getName()));
System.out.println("Certificate:"+
(((Certificate)ec.get("ProjectManagement")).getName()));
}
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
/*Methodtoupdatesalaryforanemployee*/
publicvoidupdateEmployee(IntegerEmployeeID,intsalary){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Employeeemployee=
(Employee)session.get(Employee.class,EmployeeID);
employee.setSalary(salary);
session.update(employee);
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
/*Methodtodeleteanemployeefromtherecords*/
publicvoiddeleteEmployee(IntegerEmployeeID){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Employeeemployee=
(Employee)session.get(Employee.class,EmployeeID);
session.delete(employee);
tx.commit();
}catch(HibernateExceptione){
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二进制文件来运行程序。
会在屏幕上获得以下结果，并同时创建记录在员工和证书表。
$javaManageEmployee
.......VARIOUSLOGMESSAGESWILLDISPLAYHERE........
FirstName:ManojLastName:KumarSalary:4000 Certificate:MCA Certificate:MBA Certificate:PMP FirstName:ManojLastName:KumarSalary:5000 Certificate:MCA Certificate:MBA Certificate:PMP
如果检查员工和证书表，就应该记录下了：
mysql>select*fromEMPLOYEE;
+----+------------+-----------+--------+ |id|first_name|last_name|salary| +----+------------+-----------+--------+ |60|Manoj|Kumar|5000| +----+------------+-----------+--------+ 1rowinset(0.00sec)
mysql>select*fromCERTIFICATE;
+----+--------------------+------------------+-------------+ |id|certificate_type|certificate_name|employee_id| +----+--------------------+------------------+-------------+ |16|ProjectManagement|PMP|60| |17|BusinessManagement|MBA|60| |18|ComputerScience|MCA|60| +----+--------------------+------------------+-------------+ 3rowsinset(0.00sec)
SortedMap映射
SortedMap是存储在键-值对的元素，并提供键的总体排序类似java的集合作为映射。重复的元素未在映射不允许的。该映射是根据其键的自然顺序进行排序，或者通过提供通常在有序映射的创建时间比较。
SortedMap被映射在该映射表中的<map>元素和有序映射可以在java.util.TreeMap中被初始化。
我们依然使用上面定义的RDBMS表和POJO类来讲下面的例子：
定义Hibernate映射文件：
让我们开发指示Hibernate如何定义的类映射到数据库表的映射文件。<map>元素将被用于定义所使用的映射的规则。
<?xmlversion="1.0"encoding="utf-8"?> <!DOCTYPEhibernate-mappingPUBLIC "-//Hibernate/HibernateMappingDTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <classname="Employee"table="EMPLOYEE"> <metaattribute="class-description"> Thisclasscontainstheemployeedetail. </meta> <idname="id"type="int"column="id"> <generatorclass="native"/> </id> <mapname="certificates"cascade="all"sort="MyClass"> <keycolumn="employee_id"/> <indexcolumn="certificate_type"type="string"/> <one-to-manyclass="Certificate"/> </map> <propertyname="firstName"column="first_name"type="string"/> <propertyname="lastName"column="last_name"type="string"/> <propertyname="salary"column="salary"type="int"/> </class> <classname="Certificate"table="CERTIFICATE"> <metaattribute="class-description"> Thisclasscontainsthecertificaterecords. </meta> <idname="id"type="int"column="id"> <generatorclass="native"/> </id> <propertyname="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数据类型。
<map>元素用于设置证书和Employee类之间的关系。我们使用cascade属性的<map>元素来告诉Hibernate来保存证书的对象，同时为Employee对象。name属性被设置为在父类中的定义的SortedMap变量，在我们的情况下，它是证书。排序属性可以设置为自然有自然排序，也可以设置为自定义类实现为java.util.Comparator。我们已经使用了一个类MyClass，它实现为java.util.Comparator扭转证书类实现的排序顺序。
<index>元素用于表示键/值对映射的键部分。该键将使用一个字符串类型的存储在列certificate_type。
<key>元素是包含外键的父对象，即在证书表中的列。表EMPLOYEE。
<one-to-many>元素表示一个Employee对象涉及到很多证书的对象，并因此，证书对象必须有与Employee父有关联。可以根据需要使用<one-to-one>，<many-to-one>或<many-to-many>这个元素。
如果使用sort="natural"，然后我们并不需要创建一个单独的类，因为证书类已经实现了Comparable接口和hibernate会使用compareTo在证书类定义为比较的SortedMap（）方法。但是，我们使用的是在我们的映射文件自定义的比较器类MyClass，所以我们必须创建这个类的基础上我们的排序算法。让我们做降在映射上可用的按键排序。
importjava.util.Comparator;
publicclassMyClassimplementsComparator<String>{
publicintcompare(Stringo1,Stringo2){
finalintBEFORE=-1;
finalintAFTER=1;
/*Toreversethesortingorder,multipleby-1*/
if(o2==null){
returnBEFORE*-1;
}
ComparablethisCertificate=o1;
ComparablethatCertificate=o2;
if(thisCertificate==null){
returnAFTER*1;
}elseif(thatCertificate==null){
returnBEFORE*-1;
}else{
returnthisCertificate.compareTo(thatCertificate)*-1;
}
}
}
最后，我们将创建应用程序类的main（）方法来运行应用程序。我们将使用这个应用程序，以节省一些员工的记录地连同的证书，然后我们将提交CRUD操作上面的记录。
importjava.util.*;
importorg.hibernate.HibernateException;
importorg.hibernate.Session;
importorg.hibernate.Transaction;
importorg.hibernate.SessionFactory;
importorg.hibernate.cfg.Configuration;
publicclassManageEmployee{
privatestaticSessionFactoryfactory;
publicstaticvoidmain(String[]args){
try{
factory=newConfiguration().configure().buildSessionFactory();
}catch(Throwableex){
System.err.println("FailedtocreatesessionFactoryobject."+ex);
thrownewExceptionInInitializerError(ex);
}
ManageEmployeeME=newManageEmployee();
/*Letushaveasetofcertificatesforthefirstemployee*/
TreeMapset1=newTreeMap();
set1.put("ComputerScience",newCertificate("MCA"));
set1.put("BusinessManagement",newCertificate("MBA"));
set1.put("ProjectManagement",newCertificate("PMP"));
/*Addemployeerecordsinthedatabase*/
IntegerempID1=ME.addEmployee("Manoj","Kumar",4000,set1);
/*Anothersetofcertificatesforthesecondemployee*/
TreeMapset2=newTreeMap();
set2.put("ComputerScience",newCertificate("MCA"));
set2.put("BusinessManagement",newCertificate("MBA"));
/*Addanotheremployeerecordinthedatabase*/
IntegerempID2=ME.addEmployee("Dilip","Kumar",3000,set2);
/*Listdownalltheemployees*/
ME.listEmployees();
/*Updateemployee'ssalaryrecords*/
ME.updateEmployee(empID1,5000);
/*Deleteanemployeefromthedatabase*/
ME.deleteEmployee(empID2);
/*Listdownalltheemployees*/
ME.listEmployees();
}
/*Methodtoaddanemployeerecordinthedatabase*/
publicIntegeraddEmployee(Stringfname,Stringlname,
intsalary,TreeMapcert){
Sessionsession=factory.openSession();
Transactiontx=null;
IntegeremployeeID=null;
try{
tx=session.beginTransaction();
Employeeemployee=newEmployee(fname,lname,salary);
employee.setCertificates(cert);
employeeID=(Integer)session.save(employee);
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
returnemployeeID;
}
/*Methodtolistalltheemployeesdetail*/
publicvoidlistEmployees(){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Listemployees=session.createQuery("FROMEmployee").list();
for(Iteratoriterator1=
employees.iterator();iterator1.hasNext();){
Employeeemployee=(Employee)iterator1.next();
System.out.print("FirstName:"+employee.getFirstName());
System.out.print("LastName:"+employee.getLastName());
System.out.println("Salary:"+employee.getSalary());
SortedMap<String,Certificate>map=
employee.getCertificates();
for(Map.Entry<String,Certificate>entry:map.entrySet()){
System.out.print("\tCertificateType:"+entry.getKey());
System.out.println(",Name:"+
(entry.getValue()).getName());
}
}
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
/*Methodtoupdatesalaryforanemployee*/
publicvoidupdateEmployee(IntegerEmployeeID,intsalary){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Employeeemployee=
(Employee)session.get(Employee.class,EmployeeID);
employee.setSalary(salary);
session.update(employee);
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
/*Methodtodeleteanemployeefromtherecords*/
publicvoiddeleteEmployee(IntegerEmployeeID){
Sessionsession=factory.openSession();
Transactiontx=null;
try{
tx=session.beginTransaction();
Employeeemployee=
(Employee)session.get(Employee.class,EmployeeID);
session.delete(employee);
tx.commit();
}catch(HibernateExceptione){
if(tx!=null)tx.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
}
编译和执行：
可以看到证书已排序顺序相反。可以通过改变映射文件试试，只需设置sort="natural"和执行程序，并比较结果。
$javaManageEmployee
.......VARIOUSLOGMESSAGESWILLDISPLAYHERE........ FirstName:ManojLastName:KumarSalary:4000 CertificateType:ProjectManagement,Name:PMP CertificateType:ComputerScience,Name:MCA CertificateType:BusinessManagement,Name:MBA FirstName:DilipLastName:KumarSalary:3000 CertificateType:ComputerScience,Name:MCA CertificateType:BusinessManagement,Name:MBA FirstName:ManojLastName:KumarSalary:5000 CertificateType:ProjectManagement,Name:PMP CertificateType:ComputerScience,Name:MCA CertificateType:BusinessManagement,Name:MBA
如果检查员工和证书表，就应该记录下了：
mysql>select*fromEMPLOYEE;
+----+------------+-----------+--------+ |id|first_name|last_name|salary| +----+------------+-----------+--------+ |74|Manoj|Kumar|5000| +----+------------+-----------+--------+ 1rowinset(0.00sec)
mysql>select*fromCERTIFICATE;
+----+--------------------+------------------+-------------+ |id|certificate_type|certificate_name|employee_id| +----+--------------------+------------------+-------------+ |52|BusinessManagement|MBA|74| |53|ComputerScience|MCA|74| |54|ProjectManagement|PMP|74| +----+--------------------+------------------+-------------+ 3rowsinset(0.00sec)