1、component(组件)映射:在hibernate中,component是某个实体的逻辑组成部分,它与实体的根本区别是没有oid,component可以成为是值对象(DDD)
采用component映射的好处:它实现了对象模型的细粒度划分,层次会更分明,复用率会更高
2、复合(联合)主键映射:通常将复合主键相关的属性,单独放到一个类中
* 此类必须实现序列化接口
* 覆写hashcode和equals方法
3、set、list、array、map
采用component映射的好处:它实现了对象模型的细粒度划分,层次会更分明,复用率会更高
//model
public class Contact {
private String email;
private String address;
private String zipCode;
private String contactTel;
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getZipCode() {
return zipCode;
}
public void setZipCode(String zipCode) {
this.zipCode = zipCode;
}
public String getContactTel() {
return contactTel;
}
public void setContactTel(String contactTel) {
this.contactTel = contactTel;
}
}
public class User {
private int id;
private String name;
private Contact contact; // 持有对contact的引用
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 Contact getContact() {
return contact;
}
public void setContact(Contact contact) {
this.contact = contact;
}
}
//User.hbm.xml
<hibernate-mapping>
<class name="com.bjsxt.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name" length = "10"/>
<component name="contact"><!-- component映射联系类 -->
<property name="email" length = "10"/>
<property name="address" length = "10"/>
<property name="zipCode" length = "10"/>
<property name="contactTel" length = "10"/>
</component>
</class>
</hibernate-mapping>
//test
import org.hibernate.Session;
import junit.framework.TestCase;
public class ComponentMappingTest extends TestCase {
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user = new User();
user.setName("张三");
Contact contact = new Contact();
contact.setAddress("xxxxx");
contact.setEmail("xx@rr.com");
contact.setZipCode("1111111");
contact.setContactTel("9999999");
user.setContact(contact); //contact不是实体,是一个附属的类
session.save(user); // update、save的对象为实体
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
2、复合(联合)主键映射:通常将复合主键相关的属性,单独放到一个类中
* 此类必须实现序列化接口
* 覆写hashcode和equals方法
//model
import java.io.Serializable;
@SuppressWarnings("serial")
public class FiscalYearPeriodPK implements Serializable { // 实现序列化接口
//核算年
private int fiscalYear;
//核算月
private int fiscalPeriod;
public int getFiscalYear() {
return fiscalYear;
}
public void setFiscalYear(int fiscalYear) {
this.fiscalYear = fiscalYear;
}
public int getFiscalPeriod() {
return fiscalPeriod;
}
public void setFiscalPeriod(int fiscalPeriod) {
this.fiscalPeriod = fiscalPeriod;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + fiscalPeriod;
result = prime * result + fiscalYear;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final FiscalYearPeriodPK other = (FiscalYearPeriodPK) obj;
if (fiscalPeriod != other.fiscalPeriod)
return false;
if (fiscalYear != other.fiscalYear)
return false;
return true;
}
}
import java.util.Date;
/**
* 核算期间
* @author wangy
*
*/
public class FiscalYearPeriod {
private FiscalYearPeriodPK fiscalYearPeriodPK;
//开始日期
private Date beginDate;
//结束日期
private Date endDate;
//状态
private String periodSts;
public Date getBeginDate() {
return beginDate;
}
public void setBeginDate(Date beginDate) {
this.beginDate = beginDate;
}
public Date getEndDate() {
return endDate;
}
public void setEndDate(Date endDate) {
this.endDate = endDate;
}
public String getPeriodSts() {
return periodSts;
}
public void setPeriodSts(String periodSts) {
this.periodSts = periodSts;
}
public FiscalYearPeriodPK getFiscalYearPeriodPK() {
return fiscalYearPeriodPK;
}
public void setFiscalYearPeriodPK(FiscalYearPeriodPK fiscalYearPeriodPK) {
this.fiscalYearPeriodPK = fiscalYearPeriodPK;
}
}
//FiscalYearPeriod.hbm.xml
<hibernate-mapping>
<class name="com.bjsxt.hibernate.FiscalYearPeriod" table="t_fiscal_year_period">
<composite-id name="fiscalYearPeriodPK"><!-- 映射联合主键 -->
<key-property name="fiscalYear"/>
<key-property name="fiscalPeriod"/>
</composite-id>
<property name="beginDate"/>
<property name="endDate"/>
<property name="periodSts"/>
</class>
</hibernate-mapping>
//test
import java.util.Date;
import org.hibernate.Session;
import junit.framework.TestCase;
public class CompositeMappingTest extends TestCase {
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
FiscalYearPeriod fiscalYearPeriod = new FiscalYearPeriod();// 实体类
FiscalYearPeriodPK pk = new FiscalYearPeriodPK(); // 主键附属类
pk.setFiscalYear(2008);
pk.setFiscalPeriod(8);
fiscalYearPeriod.setFiscalYearPeriodPK(pk);
fiscalYearPeriod.setBeginDate(new Date());
fiscalYearPeriod.setEndDate(new Date());
fiscalYearPeriod.setPeriodSts("Y");
session.save(fiscalYearPeriod);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
FiscalYearPeriodPK pk = new FiscalYearPeriodPK();
pk.setFiscalYear(2008);
pk.setFiscalPeriod(8);
// 根据主键加载实体类
FiscalYearPeriod fiscalYearPeriod = (FiscalYearPeriod)session.load(FiscalYearPeriod.class, pk);
System.out.println(fiscalYearPeriod.getPeriodSts());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
3、set、list、array、map
//model
import java.util.List;
import java.util.Map;
import java.util.Set;
public class CollectionMapping {
private int id;
private String name;
private Set<String> setValue;
private List<String> listValue;
private String[] arrayValue;
private Map<String, String> mapValue;
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 String[] getArrayValue() {
return arrayValue;
}
public void setArrayValue(String[] arrayValue) {
this.arrayValue = arrayValue;
}
public void setListValue(List<String> listValue) {
this.listValue = listValue;
}
public List<String> getListValue() {
return listValue;
}
public void setSetValue(Set<String> setValue) {
this.setValue = setValue;
}
public Set<String> getSetValue() {
return setValue;
}
public void setMapValue(Map<String, String> mapValue) {
this.mapValue = mapValue;
}
public Map<String, String> getMapValue() {
return mapValue;
}
}
//CollectionMapping.hbm.xml
<hibernate-mapping>
<class name="com.bjsxt.hibernate.CollectionMapping" table="t_CollectionMapping">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="setValue" table="t_set_value"><!-- 映射集合Set,将CollectionMapping普通属性setValue映射成表 -->
<key column="set_id"/><!-- 增加字段set_id,作为外键指向t_CollectionMapping -->
<element type="string" column="set_value"/><!-- t_set_value表中保存集合Set的值 -->
</set>
<list name="listValue" table="t_list_value"><!-- List集合有顺序 -->
<key column="list_id"/>
<list-index column="list_index"/><!-- 加入索引,用于保证顺序 -->
<element type="string" column="list_value"/>
</list>
<array name="arrayValue" table="t_array_value"><!-- 数组有顺序 -->
<key column="array_id"/>
<list-index column="array_index"/>
<element type="string" column="array_value"/>
</array>
<map name="mapValue" table="t_map_value">
<key column="map_id"/>
<map-key type="string" column="map_key"/><!-- key-value -->
<element type="string" column="map_value"/>
</map>
</class>
</hibernate-mapping>
//test
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.Session;
import junit.framework.TestCase;
public class CollectionMappintTest extends TestCase {
public void testSave1() {
CollectionMapping c = new CollectionMapping();
c.setName("xxx");
Set<String> setValue = new HashSet<String>();
setValue.add("a");
setValue.add("b");
c.setSetValue(setValue);
List<String> listValue = new ArrayList<String>();
listValue.add("c");
listValue.add("d");
c.setListValue(listValue);
String[] arrayValue = new String[]{"e", "f"};
c.setArrayValue(arrayValue);
Map<String, String> mapValue = new HashMap<String, String>();
mapValue.put("k1", "v1");
mapValue.put("k2", "v2");
c.setMapValue(mapValue);
Session session = null;
try { // 一般只需要包含会出异常代码
session = HibernateUtils.getSession();
session.beginTransaction();
session.save(c);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
//根据主键加载实体类
CollectionMapping c = (CollectionMapping)session.load(CollectionMapping.class, 1);
System.out.println("name=" + c.getName());
System.out.println("setvalue=" + c.getSetValue());
System.out.println("mapvalue=" + c.getMapValue());
System.out.println("listvalue=" + c.getListValue());
System.out.println("arrayValue=" + c.getArrayValue().length);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}