十 组件关联

组件关联 
什么是组件关联呢？比如说一个用户，它的名称，有一个中文名，一个英文名 它有两个名称，相对于名称与用户来说
这是什么关系呢，一个用户多个名称 当然 是一对多的关系了，我们设计名称这个属性的时候，这时我们可以把名称设计为
一个实体类 Name 那么这个实体类就相对于用户名称来说，这个实体类就是组件了，那么用户名称与用户的关系，我们就称作
组件关联关系

平常我们设计关联的时候，比如说员工与部门，都是两张表的，一张员工表，一张部门表，当前我们不想把这个用户名称
与用户设计为两张表，怎么办呢？可以这样来做，可以把用户名称看成是一个组件，并且是作为用户的一个实体属性
现在就得设计两个s实体了，一个用户名称实体 这个用户名称实体存在两个属性 一个英文名 一个中文名 用户实体就是
一个用户id 用户名称（用户名称实体） 生日  我们不想把用户名称和用户设计为两张表，这时我们只需要在用户的映射文件
中引入组件这个节点 看component class是指定实体类 
<component name=”name” class=”com.test.hibernate.domain.Name”>
		<property name=”yingwenname”/>
		<property name=”zhongwenname”/>
</component>

下面我们来看一个完整的例子

用户名称实体

package dao.service;

public class Name {
   private String firstName;
   private String lastName;
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;
}
}

用户实体 User
package dao.service;

import java.util.Date;

public class User {
   private int id;
   private Name name;
   private Date birthday;
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public Name getName() {
	return name;
}
public void setName(Name name) {
	this.name = name;
}
public Date getBirthday() {
	return birthday;
}
public void setBirthday(Date birthday) {
	this.birthday = birthday;
}
}


映射文件
<?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="dao.service">
	<class name="User">	
	
		<id name="id">
		 
			<generator class="native"/>
		</id>
		<!--  <property name="name"/> -->
		<component name="name">
		<property name="firstName" column="frist_name"/>
		<property name="lastName" column="last_name"/>
		</component>
		<property name="birthday"/>	
	</class>
	
</hibernate-mapping>


测试类 
package dao.test;

import java.util.Date;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;

import dao.service.Name;
import dao.service.User;
import dao.util.HibernateUtil;

public class Base {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//对hibernate进行初始化操作
//		Configuration ctf=new Configuration();
//        ctf.configure();
//        //获取连接工厂
//        SessionFactory sf=ctf.buildSessionFactory();
//        //获取连接对象
//        Session s=sf.openSession();
//        Transaction tx=s.beginTransaction();
        User user=new User();
        user.setBirthday(new Date());
        Name n=new Name();
        n.setFirstName("firstName");
        n.setLastName("lastName");
        user.setName(n);
        addUser2(user);
       // System.out.println(user.getId());
       // getUser(user.getId());
      //  System.out.println(user.getName());
        
       query(user.getName().getFirstName());
        System.out.println(user.getBirthday());
        System.out.print("end");
	}
   static void addUser1(User user)
   {
	      Session s=null;
	      Transaction tx=null;
	      try{
	    	    s=HibernateUtil.getSession();
	    	    tx=s.beginTransaction();
	    	    s.save(user);
	    	    tx.commit();
	      }catch(HibernateException e)
	      {
	    	    if(tx!=null){
	    	    	tx.rollback();
	    	    	throw e;
	    	    }
	      }finally
	      {
	    	  if(s!=null)
	    	  {
	    		  s.close();
	    	  }
	      }
   }
   
   
   static void addUser2(User user)
   {
	      Session s=null;
	      Transaction tx=null;
	      try{
	    	    s=HibernateUtil.getSession();
	    	    tx=s.beginTransaction();
	    	    s.save(user);
	    	    tx.commit();
	      }finally
	      {
	    	  if(s!=null)
	    	  {
	    		  s.close();
	    	  }
	      }
   }
   
   /**
    * hibernate查询数据不需要开启事务
    * @param id
    * @return
    */
   
   //获取数据 get
   static User getUser(int id)
   {
	      Session s=null;
	      try{
	    	    s=HibernateUtil.getSession();
	    	   
	    	    Class classuser=User.class;
	    	    User user=(User)s.get(User.class, id);
	    	    return user;
	      }finally
	      {
	    	  if(s!=null)
	    	  {
	    		  s.close();
	    	  }
	      }
   }
   
   //获取数据 load
   static User loadUser(int id)
   {
	      Session s=null;
	      try{
	    	    s=HibernateUtil.getSession();
	    	    Class classuser=User.class;
	    	    User user=(User)s.load(User.class, id);
	    	    return user;
	      }finally
	      {
	    	  if(s!=null)
	    	  {
	    		  s.close();
	    	  }
	      }
   }
   
   static void query(String name){
	     Session session=null;
	     try{
	    	 session=HibernateUtil.getSession();
	    	 String hql="from User as u";
	    	 Query q=session.createQuery(hql);
	    	// q.setString("name", name);
	    	 List<User> l=q.list();
	    	 for(User u:l){
	    		 System.out.println(u.getName().getFirstName());
	    	 }
	     }finally{
	    	 
	     }
   }
}

现在我们来看表结构 命令行输入 show create table user;

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `frist_name` varchar(255) default NULL,
  `last_name` varchar(255) default NULL,
  `birthday` datetime default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
看两个名称是不是都在用户表里了呢？
现在明白了吧！

好了 现在我们来对关联关系查询规律总结下

关联关系总结
一对一关系 在查主对象数据的时候，是以一种左外连接的方式把从表和主表数据全都查询出来的 只有一条select语句 但是要是
查从表的数据，是分两次查询的，一次是查从表数据，一次是查主表数据 其它关系都是分两次查询的 比如多对多 一对多 多对一
关系的查询 不管是查主表还是从表数据，它都会进行两次查询 

end 完毕！