java高级框架应用开发案例教程八

Java高级框架应用开发案例教程(八)

Hibernate实体关系映射

主要内容8.1多对一/一对多关系8.2一对一关系8.3多对多关系8.4项目案例8.1多对一/一对多关系8.1多对一/一对多关系我们以Department(部门)/Usr（用户）为例首先介绍多对一/一对多关系的处理1．数据库建表语句：CREATETABLE`department`(`id`int(10)unsignedNOTNULLauto_increment,`name`varchar(100)defaultNULL,`description`varchar(200)defaultNULL,`status`varchar(45)defaultNULL,`goal`varchar(45)defaultNULL,PRIMARYKEY(`id`))ENGINE=InnoDBDEFAULTCHARSET=gb2312;8.1多对一/一对多关系CREATETABLE`usr`(`id`int(10)unsignedNOTNULLauto_increment,`name`varchar(45)defaultNULL,`password`varchar(45)defaultNULL,`address`varchar(45)defaultNULL,`phone`int(10)unsigneddefaultNULL,`title`varchar(45)defaultNULL,`power`varchar(45)defaultNULL,`auth`varchar(45)defaultNULL,`deptid`int(10)unsigneddefaultNULL,`homephone`int(10)unsigneddefaultNULL,`superauth`varchar(45)defaultNULL,`groupid`int(10)unsigneddefaultNULL,`birthdate`varchar(45)defaultNULL,`gender`varchar(45)defaultNULL,`email`varchar(45)defaultNULL,`nickname`varchar(45)defaultNULL,PRIMARYKEY(`id`))ENGINE=InnoDBDEFAULTCHARSET=gb2312;

altertable`usr`addforeignkey`FK_usr`(`deptid`)references`department`(`id`)8.1多对一/一对多关系2．hbm.xml文件Department.hbm.xml文件<hibernate-mappingpackage="com.ascent.po"> <classname="Department"table="department"> <idname="id"column="id"type="integer"> <generatorclass="native"/> </id> <propertyname="name"type="string"> <columnname="name"length="100"/> </property> <propertyname="description"type="string"> <columnname="description"length="200"/> </property>8.1多对一/一对多关系 <propertyname="status"type="string"> <columnname="status"length="45"/> </property> <propertyname="goal"type="string"> <columnname="goal"length="45"/> </property><setname="users"table="usr"lazy="false"inverse="false" cascade="all"sort="unsorted"> <keycolumn="deptid"/> <one-to-manyclass="com.ascent.po.Usr"/> </set></class></hibernate-mapping>8.1多对一/一对多关系Usr.hbm.xml文件<hibernate-mappingpackage="com.ascent.po"> <classname="Usr"table="usr"> <idname="id"column="id"type="integer"> <generatorclass="native"/> </id> <propertyname="name"type="string"> <columnname="name"length="45"/> </property> <propertyname="password"type="string"> <columnname="password"length="45"/> </property> <propertyname="address"type="string"> <columnname="address"length="45"/> </property>8.1多对一/一对多关系 <propertyname="address"type="string"> <columnname="address"length="45"/> </property> <propertyname="phone"type="integer"> <columnname="phone"/> </property> <propertyname="title"type="string"> <columnname="title"length="45"/> </property> <propertyname="power"type="string"> <columnname="power"length="45"/> </property> <propertyname="auth"type="string"> <columnname="auth"length="45"/> </property>8.1多对一/一对多关系 <propertyname="deptid"type="integer"> <columnname="deptid"/> </property> <propertyname="homephone"type="integer"> <columnname="homephone"/> </property> <propertyname="superauth"type="string"> <columnname="superauth"length="45"/> </property> <propertyname="groupid"type="integer"> <columnname="groupid"/> </property> <propertyname="birthdate"type="string"> <columnname="birthdate"length="45"/> </property>8.1多对一/一对多关系 <propertyname="gender"type="string"> <columnname="gender"length="45"/> </property> <propertyname="email"type="string"> <columnname="email"length="45"/> </property> <propertyname="nickname"type="string"> <columnname="nickname"length="45"/> </property><many-to-onename="department“class="com.ascent.po.Department"cascade="all"outer-join="false" update="false"insert="false"column="id"not-null="true"/>

</class></hibernate-mapping>8.1多对一/一对多关系配置文件解释如下。1）映射集合（MappingCollection）在Hibernate配置文件中使用<set>、<list>、<map>、<bag>、<array>和<primitive-array>等元素来定义集合，而<map>是最典型的一个。<mapname="propertyName" ①table="table_name" ②schema="schema_name" ③lazy="true|false" ④inverse="true|false" ⑤cascade="all|none|save-update|delete|all-delete-orphan" ⑥sort="unsorted|natural|comparatorClass" ⑦8.1多对一/一对多关系order-by="column_nameasc|desc" ⑧where="arbitrarysqlwherecondition" ⑨outer-join="true|false|auto" ⑩batch-size="N"access="field|property|ClassName" >

<key..../><index..../><element..../></map>8.1多对一/一对多关系①name：集合属性的名称。②table（可选，默认为属性的名称）：这个集合表的名称（不能在一对多的关联关系中使用）。③schema（可选）：表的schema的名称，它将覆盖在根元素中定义的schema。④lazy（可选，默认为false）：允许延迟加载（lazyinitialization）。⑤inverse（可选，默认为false）：标记这个集合作为双向关联关系中的方向一端。⑥cascade（可选，默认为none）：让操作级联到子实体。⑦sort（可选）：指定集合的排序顺序，其可以为自然的（natural）或者给定一个用来比较的类。⑧order-by（可选，仅用于JDK1.4）：指定表的字段（一个或几个），再加上asc或者desc（可选），定义Map、Set和Bag的迭代顺序。⑨where（可选）：指定任意的SQLWHERE条件，该条件将在重新载入或者删除这个集合时使用（当集合中的数据仅仅是所有可用数据的一个子集时这个条件非常

有用）。⑩outer-join（可选）：指定这个集合，只要可能，应该通过外连接（OuterJoin）取得。在每一个SQL语句中，只能有一个集合可以通过外连接抓取。batch-size（可选，默认为1）：指定通过延迟加载取得集合实例的批处理块大小（BatchSize）。access（可选，默认为属性property）：Hibernate取得属性值时使用的策略。8.1多对一/一对多关系2）多对一（many-to-one）通过many-to-one元素，可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联（实际上是一个对象引用）。<many-to-one name="propertyName" ①column="column_name" ②class="ClassName" ③cascade="all|none|save-update|delete" ④outer-join="true|false|auto" ⑤update="true|false" ⑥insert="true|false" ⑥property-ref="propertyNameFromAssociatedClass" ⑦access="field|property|ClassName" ⑧/>①name：属性名。②column（可选）：字段名。③class（可选，默认是通过反射得到属性类型）：关联的类的名字。④cascade（级联）（可选）：指明哪些操作会从父对象级联到关联的对象。8.1多对一/一对多关系⑤outer-join（外连接）（可选，默认为自动）：当设置hibernate.use_outer_join时，对这个关联允许外连接抓取。⑥update、insert（可选，默认为true）：指定对应的字段是否在用于UPDATE和/或INSERT的SQL语句中包含。如果二者都是false，则这是一个纯粹的“衍生（Derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他属性得到的，或者通过Trigger（触发器），或者其他程序。⑦property-ref：（可选）：指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。⑧access（可选，默认是property）：Hibernate用来访问属性的策略。cascade属性允许下列值：all、save-update、delete、none。设置除了none以外的其他值会传播特定的操作到关联的（子）对象中。outer-join参数允许下列3个不同值。auto（默认）：如果被关联的对象没有代理（Proxy），使用外连接抓取关联（对象）；true：一直使用外连接来抓取关联；false：永远不使用外连接来抓取关联。8.1多对一/一对多关系3）<one-to-many><one-to-many>标记指明了一个一对多的关联。<one-to-manyclass="ClassName"/>class（必需）：被关联类的名称。3．PO类Departmrnt.java类：packagecom.ascent.po;importjava.util.HashSet;importjava.util.Set;publicclassDepartmentimplementsjava.io.Serializable{

privateIntegerid; privateStringname; privateStringdescription; privateStringstatus; privateStringgoal; privateSetusrs=newHashSet(0);8.1多对一/一对多关系publicDepartment(){}publicDepartment(Stringname,Stringdescription,Stringstatus, Stringgoal,Setusrs){ =name; this.description=description; this.status=status; this.goal=goal; this.usrs=usrs;}//属性的setter和getter方法省

publicSetgetUsrs(){ returnthis.usrs; } publicvoidsetUsrs(Setusrs){ this.usrs=usrs; }}8.1多对一/一对多关系Usr.java类：packagecom.ascent.po;publicclassUsrimplementsjava.io.Serializable{

privateIntegerid; privateDepartmentdepartment; privateStringname; privateStringpassword; privateStringaddress; privateIntegerphone; privateStringtitle; privateStringpower; privateStringauth; privateIntegerhomephone; privateStringsuperauth; privateIntegergroupid; privateStringbirthdate; privateStringgender; privateStringemail; privateStringnickname;//构造方法省略//属性的setter和getter方法省略}8.1多对一/一对多关系4、DAO类在DAO类中，我们可以通过getter/setter来使用关系，完成联表操作。packagecom.ascent.dao;importjava.util.ArrayList;importjava.util.HashSet;importjava.util.List;importorg.hibernate.Session;importorg.hibernate.Transaction;importcom.ascent.po.Department;importcom.ascent.po.Usr;importcom.ascent.util.HibernateSessionFactory;publicclassUserAndDeptDAOImpl{8.1多对一/一对多关系publicvoidsaveObject(DepartmentdeptObj,ListuserObj)throwsException{ Sessionsession=HibernateSessionFactory.getSession(); Transactiontx=null; try{ tx=session.beginTransaction(); for(inti=0;i<userObj.size();i++){ Usruser=(Usr)userObj.get(i); user.setDepartment(deptObj); deptObj.getUsrs().add(user); } session.save(deptObj); mit(); }catch(Exceptione){ if(tx!=null){ tx.rollback(); } e.printStackTrace(); }finally{ //Nomatterwhat,closethesession session.close(); }}8.1多对一/一对多关系publicstaticvoidmain(Stringargs[])throwsException{ Departmentpt=newDepartment(); Listlist=newArrayList(); pt.setName("测试部"); pt.setDescription("市场调查人员"); pt.setStatus("1"); pt.setUsrs(newHashSet()); Usruser1=newUsr(); user1.setName("admin"); user1.setPassword("123"); user1.setAddress("北京"); user1.setNickname("管理员"); list.add(user1); Usruser2=newUsr(); user2.setName("user_1"); user2.setPassword("123"); user2.setAddress("秦皇岛"); user2.setNickname("李明"); list.add(user2); newUserAndDeptDAOImpl().saveObject(pt,list); }}8.2一对一关系8.2一对一关系接下来我们以Address（地址）和Customer（客户）为例介绍一对一关系的处理1．数据库建表语句：createtable`customer`(`id`intNOTNULLAUTO_INCREMENT,`name`varchar(25)NOTNULL,PRIMARYKEY(`id`));createtable`address`(`id`intNOTNULL,`street`varchar(128)NULL,`city`varchar(128)NULL,`provice`varchar(128)NULL,`zipcode`varchar(6)NULL,PRIMARYKEY(`id`));altertable`address`addforeignkey`FK_address`(`id`)references`customer`(`id`);8.2一对一关系2．hbm.xml文件内容如下：Customer.hbm.xml文件<?xmlversion="1.0"encoding="utf-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"""><!--MappingfileautogeneratedbyMyEclipsePersistenceTools--><hibernate-mapping><classname="com.ascent.po.Customer"table="customer"catalog="hibernate_anli"><idname="id"type="integer"><columnname="id"/><generatorclass="native"/></id><propertyname="name"type="string"><columnname="name"length="25"not-null="true"/></property><one-to-onename="address"class="com.ascent.po.Address"cascade="all"></one-to-one></class></hibernate-mapping>8.2一对一关系Address.hbm.xml文件<?xmlversion="1.0"encoding="utf-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"""><hibernate-mapping><classname="com.ascent.po.Address"table="address"catalog="hibernate_anli"><idname="id"type="integer"><columnname="id"/><generatorclass="foreign"> <paramname="property">customer</param></generator></id><one-to-onename="customer"class="com.ascent.po.Customer"constrained="true"></one-to-one><propertyname="street"type="string"><columnname="street"length="128"/></property>8.2一对一关系<propertyname="city"type="string"><columnname="city"length="128"/></property><propertyname="province"type="string"><columnname="province"length="128"/></property><propertyname="zipcode"type="string"><columnname="zipcode"length="6"/></property></class></hibernate-mapping>8.2一对一关系持久化对象之间一对一的关联关系是通过one-to-one元素定义的。<one-to-onename="propertyName"(1)class="ClassName"(2)cascade="all|none|save-update|delete"(3)constrained="true|false"(4)outer-join="true|false|auto"(5)property-ref="propertyNameFromAssociatedClass"(6)access="field|property|ClassName"(7)

/>8.2一对一关系（1）name：属性的名字。

（2）class（可选-默认是通过反射得到的属性类型）：被关联的类的名字。

（3）cascade（级联）（可选）表明操作是否从父对象级联到被关联的对象。（4）constrained（约束）（可选）表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序（也在schemaexporttool中被使用）。

（5）outer-join（外连接）（可选-默认为自动）：当设置hibernate.use_outer_join的时候，对这个关联允许外连接抓取。

（6）property-ref：（可选）指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键。

（7）access（可选-默认是property）：Hibernate用来访问属性的策略。8.2一对一关系3.POclass：Customer.javapackagecom.ascent.po;publicclassCustomerimplementsjava.io.Serializable{

privateIntegerid; privateStringname; privateAddressaddress;//构造方法省略//属性的setter和getter方法省略}8.2一对一关系Address.javapackagecom.ascent.po;publicclassAddressimplementsjava.io.Serializable{

privateIntegerid; privateCustomercustomer; privateStringstreet; privateStringcity; privateStringprovince; privateStringzipcode;//构造方法省略//属性的setter和getter方法省略}8.2一对一关系4．DAO在DAO类中，我们可以通过getter/setter来使用关系，完成联表操作：packagecom.ascent.dao;importorg.hibernate.Session;importorg.hibernate.Transaction;importcom.ascent.po.Address;importcom.ascent.po.Customer;importcom.ascent.util.HibernateSessionFactory;publicclassCustomerAndAddressDAO{

8.2一对一关系 /** *案例模拟保存客户操作级联插入相关联的Address *@paramcustomer */ publicvoidsaveCustomer(Customercustomer){ Sessionsession=HibernateSessionFactory.getSession(); Transactiontx=null; try{ tx=session.beginTransaction(); session.save(customer); mit(); }catch(Exceptione){ if(tx!=null){ tx.rollback(); } }finally{ session.close(); } }8.2一对一关系 /** *案例模拟根据id查询Customer方法 */ publicCustomerfindCustomerById(intid){ Customercustomer=null; Sessionsession=HibernateSessionFactory.getSession(); customer=(Customer)session.get(Customer.class,id); session.close(); returncustomer; }8.2一对一关系//模拟测试 publicstaticvoidmain(String[]args){ CustomerAndAddressDAOdao=newCustomerAndAddressDAO(); //创建一个Customer对象 Customercustomer=newCustomer(); //创建一个Address对象 Addressaddress=newAddress(); address.setProvince("province1"); address.setCity("city1"); address.setStreet("street1"); address.setZipcode("100085");8.2一对一关系 //设置Address对象和Customer对象关系 address.setCustomer(customer); customer.setName("Peter"); //设置Customer对象和Address对象关系 customer.setAddress(address); //测试保存Customer对象 dao.saveCustomer(customer); //测试根据id查询Customer方法 Customerc=dao.findCustomerById(customer.getId()); //打印Customer信息及一一对应的Address对象信息 System.out.println("CustomerID:"+c.getId()); System.out.println("CustomerName:"+c.getName()); System.out.println("CustomerAddress'id:"+c.getAddress().getId()); System.out.println("CustomerAddress'street:"+c.getAddress().getStreet()); System.out.println("CustomerAddress'province:"+c.getAddress().getProvince()); System.out.println("CustomerAddress'city:"+c.getAddress().getCity()); }}8.3多对多关系8.3多对多关系最后我们以Student（学生）／Course（课程）为例来介绍多对多关系：一般来说，在数据库设计阶段，对于有多对多关系的两个表，我们会增加一个代表关系的中间表。在这个例子中，我们在student和course之间建立stu_course中间表1．数据库建表语句：createtable`student`(`id`intNOTNULLAUTO_INCREMENT,`name`varchar(20)NOTNULL,PRIMARYKEY(`id`));createtable`course`(`id`intNOTNULLAUTO_INCREMENT,`name`varchar(20)NOTNULL,PRIMARYKEY(`id`));createtable`stu_course`(`stu_id`intNULL,`course_id`intNULL);altertable`stu_course`addforeignkey`FK_stu_course`(`course_id`)references`course`(`id`);altertable`stu_course`addforeignkey`FK_course_stu`(`stu_id`)references`student`(`id`);8.3多对多关系hbmfiles：Student.hbm.xml<?xmlversion="1.0"encoding="utf-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"""><hibernate-mapping><classname="com.ascent.po.Student"table="student"catalog="hibernate_anli"><idname="id"type="integer"><columnname="id"/><generatorclass="native"/></id>8.3多对多关系<propertyname="name"type="string"><columnname="name"length="20"not-null="true"/></property><setname="courses"table="stu_course"catalog="hibernate_anli"cascade="save-update"lazy="false"><key><columnname="stu_id"/></key><many-to-manyentity-name="com.ascent.po.Course"><columnname="course_id"/></many-to-many></set></class></hibernate-mapping>8.3多对多关系Course.hbm.xml<?xmlversion="1.0"encoding="utf-8"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN"""><hibernate-mapping><classname="com.ascent.po.Course"table="course"catalog="hibernate_anli"><idname="id"type="integer"><columnname="id"/><generatorclass="native"/></id>8.3多对多关系<propertyname="name"type="string"><columnname="name"length="20"not-null="true"/></property><setname="students"inverse="true"table="stu_course"catalog="hibernate_anli"cascade="save-update"lazy="false"><key><columnname="course_id"/></key><many-to-manyentity-name="com.ascent.po.Student"><columnname="stu_id"/></many-to-many></set></class></hibernate-mapping>8.3多对多关系除了前面所讲到的<set>定义以外，持久化对象之间多对多的关联关系是通过many-to-many元素定义的。<many-to-manycolumn="column_name"(1)class="ClassName"(2)outer-join="true|false|auto"(3)/>（1）column（必需）：这个元素的外键关键字段名

（2）class（必需）：关联类的名称

（3）outer-join（可选-默认为auto）：在Hibernate系统参数中hibernate.use_outer_join被打开的情况下，该参数用来允许使用outerjoin来载入此集合的数据。8.3多对多关系2．POclass：Student.javapackagecom.ascent.po;importjava.util.HashSet;importjava.util.Set;publicclassStudentimplementsjava.io.Serializable{ //Fields privateIntegerid; privateStringname; privateSetcourses=newHashSet(0);//构造方法省略//属性setter和getter方法省略}8.3多对多关系Course.javapackagecom.ascent.po;importjava.util.HashSet;importjava.util.Set;publicclassCourseimplementsjava.io.Serializable{

//Fields privateIntegerid; privateStringname; privateSetstudents=newHashSet(0);//构造方法省略//属性setter和getter方法省略}8.3多对多关系3．DAOclass：packagecom.ascent.dao;importjava.util.Iterator;importjava.util.List;importjava.util.Set;importorg.hibernate.HibernateException;import