hibernate映射 【映射组成关系】，初学例子五

customer，对应的关系数据库：

 

SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `t_customer`
-- ----------------------------
DROP TABLE IF EXISTS `t_customer`;
CREATE TABLE `t_customer` (
  `id` bigint(10) NOT NULL AUTO_INCREMENT,
  `name` varchar(10) NOT NULL,
  `phone` int(11) DEFAULT NULL,
  `married` bit(1) DEFAULT NULL,
  `sex` char(1) DEFAULT NULL,
  `image` blob,
  `registered_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  `home_address` varchar(100) DEFAULT NULL,
  `company_address` varchar(100) DEFAULT NULL,

注意，这里操作的地址，对应的事customer表中的两个字段，但是，对于关系模型，也就是实体类，确实完完整整的一个Address类，一个组件类
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=127 DEFAULT CHARSET=latin1;

 

address 组件类的代码：

package bean;

/**
 *
 * @author zwc
 *
 */
public class Address {
 private String name;
 private Customer customer;
 

注意：这里的address只是一个组件，他并没有oid，所以，无法，通过load，get，持久化他，

并且，这里要声明父类，也就是包含地址类，所对应的get，set方法
 public Customer getCustomer() {
  return customer;
 }
 public void setCustomer(Customer customer) {
  this.customer = customer;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}

 

customer类  很简单的pojo

package bean;

import java.io.Serializable;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Set;

@SuppressWarnings("serial")
public class Customer implements Serializable{
 private Long id;
 private String firstName = "N";
 private String lastName = "N";
 private int phone;
 private boolean married;
 private char sex;
 private byte[]image;
 private Timestamp registeredTime;
 private int count;
 private Address homeAddress;
 private Address companyAddress;
 
 
 private Set<Order> orderSet = new HashSet<Order>();
 
 public Customer(){
  //empty
 }
 
 public Long getId() {
  return id;
 }
 public void setId(Long id) {
  this.id = id;
 }
 public String getFirstName() {
  return firstName;
 }

 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }

 public String getLastName() {
  return lastName;
 }

 public void setLastName(String lastName) {
  this.lastName = lastName;
 }

 protected String getName() {
  return firstName + "-" + lastName;
 }
 protected void setName(String name) {
  String [] names = name.split("-");
  if(names.length >= 1){
   this.firstName = names[0];
  }
  if(names.length >= 2){
   this.lastName = names[1];
  }
 }
 public int getPhone() {
  return phone;
 }
 public void setPhone(int phone) {
  this.phone = phone;
 }
 public boolean isMarried() {
  return married;
 }
 public void setMarried(boolean married) {
  this.married = married;
 }
 public char getSex() {
  return sex;
 }
 public void setSex(char sex) {
  this.sex = sex;
 }
 public byte[] getImage() {
  return image;
 }
 public void setImage(byte[] image) {
  this.image = image;
 }
 public Timestamp getRegisteredTime() {
  return registeredTime;
 }
 public void setRegisteredTime(Timestamp registeredTime) {
  this.registeredTime = registeredTime;
 }

 public int getCount() {
  return count;
 }
 public void setCount(int count) {
  this.count = count;
 }

 public Set<Order> getOrderSet() {
  return orderSet;
 }

 public void setOrderSet(Set<Order> orderSet) {
  this.orderSet = orderSet;
 }

 public Address getHomeAddress() {
  return homeAddress;
 }

 public void setHomeAddress(Address homeAddress) {
  this.homeAddress = homeAddress;
 }

 public Address getCompanyAddress() {
  return companyAddress;
 }

 public void setCompanyAddress(Address companyAddress) {
  this.companyAddress = companyAddress;
 }
 
}

 

重点的事这里的，customer配置文件的设置

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="bean">
 <class name="bean.Customer" table="t_customer">
  <id name="id" column="id" type="long">
   <generator class="native"/>
  </id>
  <property name="name" column="name" type="string" not-null="true"/>
  <property name="phone" column="phone" type="integer"/>
  <property name="married" column="married" type="boolean"/>
  <property name="sex" column="sex" type="character"/>
  <property name="image" column="image" type="binary"/>
  <property name="registeredTime" column="registered_time" type="timestamp"/>
  
  <property name="count" formula="(select count(*) from t_customer as c)"/>
  
  <set name="orderSet" inverse="true">
   <key column="customer_id"/>
   <one-to-many class="bean.Order"/>
  </set>
  
  <component name="homeAddress" class="bean.Address">
   <parent name="customer"/>
   <property name="name" column="home_address"></property>
  </component>
  <component name="companyAddress" class="bean.Address">
   <parent name="customer"/>
   <property name="name" column="company_address"></property>
  </component>  
  说明：这里是配置，组件的代码，不能用

<one-to-many>  <many-to-many>

 

 </class>
</hibernate-mapping>

 

address  因为只是一个组件，是customer的一个组成部分，所以，他没有对应的配置文件

order bean   和 配置文件，可以参考前面的例子，这里，就不在给出代码了，

测试类：

package servlet;

import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Timestamp;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import bean.Address;
import bean.Customer;
import bean.Order;

@SuppressWarnings("serial")
public class OperateCustomer extends HttpServlet {
 private static Logger logger = Logger.getLogger(OperateCustomer.class);
 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  doPost(request,response);
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  response.setContentType("text/html;charset=UTF-8");
  response.setCharacterEncoding("UTF-8");
  request.setCharacterEncoding("UTF-8");
  PrintWriter out = response.getWriter();
  
  out.write("<title>Test-Hibernate</title>");
  Session session = new Configuration()
   .addClass(Customer.class)
   .addClass(Order.class)

这里的，说明：这里，不用添加逐渐address的类，因为，他不能持久化，
   .buildSessionFactory()
   .openSession();
  
  Transaction t = (Transaction) session.beginTransaction();
  Customer c = new Customer();  
  try {
   session.beginTransaction();
   
   c.setFirstName("IA");
   c.setLastName("IB");
   c.setMarried(false);
   c.setSex('F');
   c.setPhone(987654321);
   c.setRegisteredTime(new Timestamp(System.currentTimeMillis()));  

 

注意，基本上没有什么变化，按照正常的逻辑写，就可以了：
   Address a1 = new Address();
   a1.setName("HomeAddress");
   a1.setCustomer(c);
   Address a2 = new Address();
   a2.setName("CompanyAddress");
   a2.setCustomer(c);
   c.setHomeAddress(a1);
   c.setCompanyAddress(a2);
   
   
   Order order = new Order();
   order.setOrderNumber("fromCustomeIn"); 
   order.setCustomer(c);
   
   session.save(order);
   
   Set<Order> orderSet = new HashSet<Order>();
   orderSet.add(order);
   c.setOrderSet(orderSet);
   
   session.save(c);
   t.commit();
  } catch (Exception e) {
   logger.warn("保存Customer失败",e);
   try {
    t.rollback();
   } catch (Exception e1) {
    logger.warn("回滚失败");
   }
  }
  Query query = session.createQuery("from Customer");
  
  Iterator<Customer> i = (Iterator<Customer>) query.iterate();
  while(i.hasNext()){
   c = i.next();
   
   out.println("count：" + c.getOrderSet().size() + "..................."+ c.getFirstName() + ":" + c.getLastName());
   
  }
  
 }

}

 

 

 

 

 

 

 

 

引用文章中，一些说明，可以参考下：