第34天(就业班) 对象状态、一级缓存、session的一级缓存、懒加载、一对一映射、组件映射、继承映射

3/8/2017来源:ASP.NET技巧人气:2922

1.一对多、多对一、多对多的回顾

一对多:
	<set name="映射的集合属性" table="(可选)集合属性对应的外键表">
	   <key column="外键表的,外键字段" />
	   <one-to-many class="集合元素的类型" />
	</set>

多对一:
    <many-to-one name="对象属性" class="对象类型" column="外键字段字段" />

多对多
    <set name="" table="">
        <key column="" />
        <many-to-many column="" class="">
    </set>2.对象状态
a) Hibernate中持久化对象的状态
 瞬时/临时状态(Transient Objects)     
       使用new操作符初始化的对象不是立刻就持久化的,他们的状态是瞬时的。
       (1) 不处于session的缓存中,也可以说,不被任何一个Session实例关联。
       (2) 在数据库中没有对应的记录。
 持久化状态(Persist Objects)
       持久实例是任何具有数据库标识的实例。它有持久化管理器Session统一管理,持久实例是在事务中进行操作的———他们的状态在事务结束时同数据库进行同步。
(1) 位于一个Session实例的缓存中,也可以说,持久化对象总是被一个Session实例关联。
(2) 持久化对象和数据库中的相关记录对应。
(3) Session在清理缓存时,会根据持久化对象的属性变化,来同步更新数据库。
(4) 当调用session的save/saveOrUpdate/get/load/list等方法的时候,对象就是持久化状态。处于持久化状态的对象,当对对象属性进行更改的时候,会反映到数据库中!
特点:
处于session的管理;
数据库中有对应的记录;
 离线/游离对象(Detached Objects)
      Session关闭之后,持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步,他们不再受Hibernate管理。
       (1) 不再位于Session的缓存中,也可以说,游离对象不被Session关联。
       (2) 游离对象是由持久化对象转变过来的,因此在数据库中可能还存在与它对应的记录
          (前提条件是没有其他程序删除了这条记录)。  不处于session的管理;数据库中有对应的记录
Session关闭后,对象的状态;
b) hibernate持久化对象的状态转换过程

/*  * 临时:对象不在session管理,与数据库无对应的记录  * 特点:  * new出  * 持久:对象在session管理, 与数据库有对应的记录  * 特点:  * 有oid  * 对对象修改会同步到数据库  * 游离:对象不在session管理,但与数据库有对应的记录.   * 特点:  * 修改对象,不会影响数据库  */

Session session = SessionUtils.getSession();
Transaction transaction = session.beginTransaction();
		
User  user = (User) session.get(User.class, 1);
user.setName(“jack”);
user.setAge(30);
user.setBirthday(new Date());
transaction.commit();
package com.xp.a_status;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;


public class App1_status {
    PRivate static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(User.class) // 测试时候使用
            .buildSessionFactory();
    }

    //1. 对象状态的转换
    @Test
    public void testSaveSet() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        // 创建对象						【临时状态】
        //		User user = new User();
        //		user.setUserName("Jack22222");
        // 保存							【持久化状态】
        //		session.save(user);		
        //		user.setUserName("Jack333333");  // 会反映到数据库

        // 查询
        User user = (User) session.get(User.class, 5);
        user.setUserName("Tomcat"); // hibernate会自动与数据库匹配(一级缓存),如果一样就更新数据库

        session.getTransaction().commit();
        session.close();

        user.setUserName("Jack444444444");
        // 打印							【游离状态】
        System.out.println(user.getUserId());
        System.out.println(user.getUserName());
    }

    @Test
    public void bak() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();
        session.getTransaction().commit();
        session.close();
    }
}3. 一级缓存
为什么要用缓存?
目的:减少对数据库的访问次数!从而提升hibernate的执行效率!
Hibernate中缓存分类:
一级缓存
二级缓存
a) Hibernate3中Session缓存即一级缓存
 Session缓存    
      Hibernate的一级缓存是由Session提供的,因此它存在于Session的整个生命周期中,当程序调用save()/update()/saveOrupdate()/get()等及查询接口方法list()/iterator()方法时候,如果session中不存在该对象,那么会先将本次的对象存储到一级缓存中便于以后使用,当Session关闭时同时清空一级缓存数据。clear()/evict()
 Session的缓存作用
       减少访问数据库的次数,进而提高效率。保证缓存中的对象与数据库的记录保持
       同步,当缓存的对象改变后,session不会立即执行sql,而是将多个sql语句合并
       为一条sql进行执行,提高效率。
 session的缓存举例
      当用户需要对指定的对象进行修改的时候,如果对于同一个属性修改了多次,其实hibernate的session缓存并不是执行多个update语句,而是以最后一个更新为准而发送一条更新的sql。
b)hibernate中的session缓存问题
Get()先将获取的对象存储到一级缓存,当再次加载同一个持久化对象的时候先检测一级缓存中是否有该对象,如果有直接获取,不会发送SQL语句,否则才发送SQL

public void cache(){
	Session session = SessionUtils.getCurrentSession();
	session.beginTransaction();
	Query query = null;
	DataType dataType = null;
       DataType dataType1 = null;
	try {
		// 获取要修改的对象
		dataType = (DataType) session.get(DataType.class, new Long(1));
		// session.evict(dataType);和session.clear();方法会清理缓存
		dataType1 = (DataType) session.get(DataType.class, new Long(1));
		System.out.println(dataType == dataType1);
		session.getTransaction().commit();
	} catch (Exception e) {
                  e.printStackTrace();
                  session.getTransaction().rollback();
	}
	}
public void cache(){
	Session session = SessionUtils.getCurrentSession();
	session.beginTransaction();
	Query query = null;
	try {
		query = session.createQuery("from DataType");
		List list = query.list();
		System.out.println(list);
		// session.clear();
		Iterator<DataType> it = query.iterate();
		while(it.hasNext()){
		     System.out.println(it.next());
		}
		session.getTransaction().commit();
	} catch (Exception e) {
                  e.printStackTrace();
                  session.getTransaction().rollback();
	}
	}

List()查询出来的结果会被缓存起来,那么当

terator()再查看的时候会先发送查询id的SQL,

但是查询实体的SQL不会发出,因为它首先回去一

级缓存中获取已经缓存的数据。

D)缓存相关几个方法的作用

session.flush();       让一级缓存与数据库同步

        session.evict(arg0);    清空一级缓存中指定的对象

        session.clear();       清空一级缓存中缓存的所有对象

在什么情况用上面方法?

       批量操作使用使用:

            Session.flush();   // 先与数据库同步

            Session.clear();   // 再清空一级缓存内容

1)Hibenate中一级缓存,也叫做session的缓存,它可以在session范围内减少数据库的访问次数!  只在session范围有效!Session关闭,一级缓存失效!

2)当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候,都会把对象放入session的缓存中。

3)Session的缓存由hibernate维护, 用户不能操作缓存内容; 如果想操作缓存内容,必须通过hibernate提供的evit/clear方法操作。

特点:

    只在(当前)session范围有效,作用时间短,效果不是特别明显!

    在短时间内多次操作数据库,效果比较明显!

  面试题1: 不同的session是否会共享缓存数据?

不会。

Session session1=sessionFactory.openSession();Session session2=sessionFactory.openSession();
Transaction tx1 = session1.beginTransaction();     Transaction tx2 = session2.beginTransaction();
//Customer对象被session1关联
Customer c=(Customer)session1.get(Customer.class,new Long(1)); 
//Customer对象被session2关联
session2.update(c); 
c.setName("Jack"); //修改Customer对象的属性
tx1.commit(); //执行update语句    tx2.commit();  //执行update语句
session1.close();   session2.close();
当执行session1的load()方法时,OID为1的Customer对象被加入到session1的缓存中,因此它
是session1的持久化对象,此时它还没有被session2关联,因此相对于session2,它处于游离状
态。当执行session2的update()方法时,Customer对象被加入到session2的缓存中,因此也成
为session2的持久化对象。接下来修改Customer对象的name属性,会导致两个Session实例在
清理各自的缓存时,都执行相同的update语句:
update CUSTOMERS set NAME='Jack' …… where ID=1;
	面试题2: list与iterator查询的区别?
list() 
一次把所有的记录都查询出来,
会放入缓存,但不会从缓存中获取数据
	Iterator
		N+1查询; N表示所有的记录总数
		即会先发送一条语句查询所有记录的主键(1),
再根据每一个主键再去数据库查询(N)!
会放入缓存,也会从缓存中取数据!
package com.xp.a_status;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;


public class App2_cache {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(User.class) // 测试时候使用
            .buildSessionFactory();
    }

    @Test
    public void testCache() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        User user = null;
        // 查询
        user = (User) session.get(User.class, 5); // 先检查缓存中是否有数据,如果有不查询数据库,直接从缓存中获取
        user = (User) session.get(User.class, 5); // 先检查缓存中是否有数据,如果有不查询数据库,直接从缓存中获取

        session.getTransaction().commit();
        session.close();
    }

    @Test
    public void flush() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        User user = null;
        user = (User) session.get(User.class, 5);
        user.setUserName("Jack");
        // 缓存数据与数据库同步
        session.flush();

        user.setUserName("Jack_new");

        session.getTransaction().commit(); // session.flush();
        session.close();
    }

    @Test
    public void clear() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        User user = null;
        // 查询
        user = (User) session.get(User.class, 5);
        // 清空缓存内容 
        //		session.clear(); // 清空所有
        session.evict(user); // 清除指定

        user = (User) session.get(User.class, 5);

        session.getTransaction().commit(); // session.flush();
        session.close();
    }

    @Test
    public void sessionTest() throws Exception {
        Session session1 = sf.openSession();
        session1.beginTransaction();

        Session session2 = sf.openSession();
        session2.beginTransaction();

        // user放入session1的缓存区
        User user = (User) session1.get(User.class, 1);
        // user放入session2的缓存区
        session2.update(user);

        // 修改对象
        user.setUserName("New Name"); // 2条update

        session1.getTransaction().commit(); // session1.flush();
        session1.close();
        session2.getTransaction().commit(); // session2.flush();
        session2.close();
    }
}

package com.xp.a_status;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;


public class App3_list_iterator {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(User.class) // 测试时候使用
            .buildSessionFactory();
    }

    /**
     * list与iterator区别
     * 1. list 方法
     * 2. iterator 方法
     * 3. 缓存
     * @throws Exception
     */

    //1.  list 方法
    @Test
    public void list() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        // HQL查询
        Query q = session.createQuery("from User ");

        // list()方法
        List<User> list = q.list();

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        session.getTransaction().commit();
        session.close();
    }

    //2. iterator 方法
    @Test
    public void iterator() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        // HQL查询
        Query q = session.createQuery("from User ");

        // iterator()方法
        Iterator<User> it = q.iterate();

        while (it.hasNext()) {
            // 得到当前迭代的每一个对象
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();
        session.close();
    }

    //3. 缓存
    @Test
    public void cache() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        /**************执行2次list*****************
        Query q = session.createQuery("from User");
        List<User> list = q.list();      // 【会放入?】
        for (int i=0; i<list.size(); i++){
                System.out.println(list.get(i));
        }
        System.out.println("=========list===========");
        list = q.list();                                // 【会放入?】
        for (int i=0; i<list.size(); i++){
                System.out.println(list.get(i));
        }

        /**************执行2次iteator******************/
        Query q = session.createQuery("from User ");
        Iterator<User> it = q.iterate(); // 【放入缓存】

        while (it.hasNext()) {
            User user = it.next();
            System.out.println(user);
        }

        System.out.println("==========iterate===========");
        it = q.iterate(); // 【也会从缓存中取】

        while (it.hasNext()) {
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();
        session.close();
    }

    // 测试list方法会放入缓存
    @Test
    public void list_iterator() throws Exception {
        Session session = sf.openSession();
        session.beginTransaction();

        // 得到Query接口的引用
        Query q = session.createQuery("from User ");

        // 先list  【会放入缓存,但不会从缓存中获取数据】
        List<User> list = q.list();

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 再iteraotr  (会从缓存中取)
        Iterator<User> it = q.iterate();

        while (it.hasNext()) {
            User user = it.next();
            System.out.println(user);
        }

        session.getTransaction().commit();
        session.close();
    }
}4.懒加载

 面试题3: get、load方法区别? get: 及时加载,只要调用get方法立刻向数据库查询 load:默认使用懒加载,当用到数据的时候才向数据库查询。   懒加载:(lazy) 概念:当用到数据的时候才向数据库查询,这就是hibernate的懒加载特性。 目的:提供程序执行效率!  lazy 值 true   使用懒加载 false   关闭懒加载 extra   (在集合数据懒加载时候提升效率) 在真正使用数据的时候才向数据库发送查询的sql; 如果调用集合的size()/isEmpty()方法,只是统计,不真正查询数据!  懒加载异常  Session关闭后,不能使用懒加载数据!  如果session关闭后,使用懒加载数据报错: org.hibernate.LazyInitializationException: could not initialize proxy - no Session 如何解决session关闭后不能使用懒加载数据的问题?         // 方式1: 先使用一下数据 //dept.getDeptName(); // 方式2:强迫代理对象初始化 Hibernate.initialize(dept); // 方式3:关闭懒加载 设置lazy=false; // 方式4: 在使用数据之后,再关闭session! 

package com.xp.b_one2many;

public class Employee {

	private int empId;
	private String empName;
	private double salary;
	// 【多对一】员工与部门
	private Dept dept;;
	
	
	public int getEmpId() {
		return empId;
	}
	public void setEmpId(int empId) {
		this.empId = empId;
	}
	public String getEmpName() {
		return empName;
	}
	public void setEmpName(String empName) {
		this.empName = empName;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public Dept getDept() {
		return dept;
	}
	public void setDept(Dept dept) {
		this.dept = dept;
	}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.xp.b_one2many">
	
	<class name="Employee" table="t_employee">
		<id name="empId">
			<generator class="native"></generator>
		</id>	
		<property name="empName" length="20"></property>
		<property name="salary" type="double"></property>
		
		<many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>
		 
	</class>

</hibernate-mapping>
package com.xp.b_one2many;

import java.util.HashSet;
import java.util.Set;

public class Dept {
	private int deptId;
	private String deptName;
	// 【一对多】 部门对应的多个员工
	private Set<Employee> emps = new HashSet<Employee>();
	
	public int getDeptId() {
		return deptId;
	}
	public void setDeptId(int deptId) {
		this.deptId = deptId;
	}
	public String getDeptName() {
		return deptName;
	}
	public void setDeptName(String deptName) {
		this.deptName = deptName;
	}
	public Set<Employee> getEmps() {
		return emps;
	}
	public void setEmps(Set<Employee> emps) {
		this.emps = emps;
	}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.xp.b_one2many">
	<class name="Dept" table="t_dept" >
		<id name="deptId">
			<generator class="native"></generator>
		</id>	
		<property name="deptName" length="20"></property>
		<!-- 
			集合属性,默认使用懒加载 
			lazy
				true 懒加载
				extra 懒加载(智能)
				false 关闭懒加载
		-->
		 <set name="emps" lazy="extra">
		 	 <key column="dept_id"></key>
		 	 <one-to-many class="Employee"/>
		 </set>
	</class>
</hibernate-mapping>
package com.xp.b_one2many;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {
	private static SessionFactory sf;
	static {
		sf = new Configuration()
			.configure()
			.addClass(Dept.class)   
			.addClass(Employee.class)   // 测试时候使用
			.buildSessionFactory();
	}

	//1. 主键查询,及区别
	@Test
	public void get_load() {
		
		Session session = sf.openSession();
		session.beginTransaction();
		Dept dept = new Dept();
		// get: 及时查询
//		dept = (Dept) session.get(Dept.class, 9);
//		System.out.println(dept.getDeptName());
		
		// load,默认懒加载, 及在使用数据的时候,才向数据库发送查询的sql语句!
		dept = (Dept)session.load(Dept.class, 9);
		// 方式1: 先使用一下数据
		//dept.getDeptName();
		// 方式2:强迫代理对象初始化
		Hibernate.initialize(dept);
		// 方式3:关闭懒加载
		
		session.getTransaction().commit();
		session.close();
		
		// 在这里使用
		System.out.println(dept.getDeptName());
	}


	//1. 主键查询,及区别
	@Test
	public void set() {
		Session session = sf.openSession();
		session.beginTransaction();
		Dept dept = (Dept) session.get(Dept.class, 10);
		System.out.println(dept.getDeptName());
		System.out.println("------");
		System.out.println(dept.getEmps().isEmpty());  //  SQL
		
		session.getTransaction().commit();
		session.close();
		
	}
}
5.一对一映射
需求: 用户与身份证信息
	 一条用户记录对应一条身份证信息!  一对一的关系!
设计数据库:
JavaBean:
映射:
package com.xp.c_one2one;

public class IdCard {
	// 身份证号(主键)
		private String cardNum;// 对象唯一表示(Object Identified, OID)
		private String place; //  身份证地址
		// 身份证与用户,一对一的关系
		private User user;
		public String getCardNum() {
			return cardNum;
		}
		public void setCardNum(String cardNum) {
			this.cardNum = cardNum;
		}
		public String getPlace() {
			return place;
		}
		public void setPlace(String place) {
			this.place = place;
		}
		public User getUser() {
			return user;
		}
		public void setUser(User user) {
			this.user = user;
		}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.xp.c_one2one">
    <class name="IdCard" table="t_IdCard">
        <id name="cardNum">
            <generator class="assigned"></generator>
        </id>
        <property name="place" length="20"></property>
        <!-- 
                        一对一映射,有外键方
                        unique="true"   给外键字段添加唯一约束
                 -->
        <many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
    </class>
</hibernate-mapping>
package com.xp.c_one2one;

public class User {
    private int userId;
    private String userName;

    // 用户与身份证信息, 一对一关系
    private IdCard idCard;

    public IdCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IdCard idCard) {
        this.idCard = idCard;
    }

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.xp.c_one2one">
    <class name="User" table="t_user">
        <id name="userId">
            <generator class="native"></generator>
        </id>
        <property name="userName" length="20"></property>
        <!-- 
                        一对一映射: 没有外键方
                 -->
        <one-to-one name="idCard" class="IdCard"></one-to-one>
    </class>
</hibernate-mapping>
package com.xp.c_one2one;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;


public class App {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(IdCard.class)
                                .addClass(User.class) // 测试时候使用
            .buildSessionFactory();
    }

    @Test
    public void getSave() {
        Session session = sf.openSession();
        session.beginTransaction();

        // 用户
        User user = new User();
        user.setUserName("Jack");

        // 身份证
        IdCard idCard = new IdCard();
        idCard.setCardNum("441202XXX");
        idCard.setPlace("广州XXX");
        // 关系
        idCard.setUser(user);

        // ----保存----
        session.save(idCard);

        session.getTransaction().commit();
        session.close();
    }
}
基于主键的映射
// 身份证
public class IdCard {

	private int user_id;
	// 身份证号
	private String cardNum;
	private String place; //  身份证地址
	// 身份证与用户,一对一的关系
	private User user;
	
	

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.c_one2one2">
	
	<class name="IdCard" table="t_IdCard">
		<id name="user_id">
			<!-- 
				id 节点指定的是主键映射, 即user_id是主键
				主键生成方式: foreign  即把别的表的主键作为当前表的主键;
						property (关键字不能修改)指定引用的对象     对象的全名 cn..User、  对象映射 cn.User.hbm.xml、   table(id)
			 -->
			<generator class="foreign">
				<param name="property">user</param>
			</generator>
		</id>	
		<property name="cardNum" length="20"></property>
		<property name="place" length="20"></property>
		
		<!-- 
			一对一映射,有外键方
			(基于主键的映射)
			 constrained="true"  指定在主键上添加外键约束
		 -->
		<one-to-one name="user" class="User" constrained="true"  cascade="save-update"></one-to-one>
			
	</class>
</hibernate-mapping>
6.组件映射
类组合关系的映射,也叫做组件映射!
注意:组件类和被包含的组件类,共同映射到一张表!
需求: 汽车与车轮
数据库 
	T_car
		主键   汽车名称  轮子大小  个数
package com.xp.d_component;
public class Wheel {
	private int count;
	private int size;
	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
}
package com.xp.d_component;

public class Car {
	private int id;
	private String name;
	// 车轮
	private Wheel wheel;
	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 Wheel getWheel() {
		return wheel;
	}
	public void setWheel(Wheel wheel) {
		this.wheel = wheel;
	}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.xp.d_component">
    <class name="Car" table="t_car">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="name" length="20"></property>
        <!-- 组件映射 -->
        <component name="wheel">
            <property name="size"></property>
            <property name="count"></property>
        </component>
    </class>
</hibernate-mapping>
package com.xp.d_component;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.junit.Test;


public class App {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(Car.class)
                                .buildSessionFactory();
    }

    @Test
    public void getSave() {
        Session session = sf.openSession();
        session.beginTransaction();

        // 轮子
        Wheel wheel = new Wheel();
        wheel.setSize(38);
        wheel.setCount(4);

        // 汽车
        Car car = new Car();
        car.setName("BMW");
        car.setWheel(wheel);

        // 保存
        session.save(car);

        session.getTransaction().commit();
        session.close();
    }
}
7.继承映射
需求:动物
猫
猴子
动物类
public class Animal {
	private int id;
	private String name;
}
package com.xp.e_extends1;

public class Cat extends Animal{

	// 抓老鼠
	private String catchMouse;

	public String getCatchMouse() {
		return catchMouse;
	}

	public void setCatchMouse(String catchMouse) {
		this.catchMouse = catchMouse;
	}
}
package com.xp.e_extends1;

public class Monkey {
	// 吃香蕉
		private String eatBanana;
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
	简单继承
 -->
<hibernate-mapping package="com.xp.e_extends1">
 <class name="Cat" table="t_Cat">
  <!-- 简单继承映射: 父类属性直接写 -->
  <id name="id">
   <generator class="native"/>
  </id>
  <property generated="never" lazy="false" name="name"/>
  <property generated="never" lazy="false" name="catchMouse"/>
 </class>
</hibernate-mapping>

 package com.xp.e_extends1;

import org.hibernate.Query;
import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.hibernate.classic.Session;

import org.junit.Test;

import java.util.List;


public class App {
    private static SessionFactory sf;

    static {
        sf = new Configuration().configure().addClass(Cat.class)
                                .buildSessionFactory();
    }

    @Test
    public void getSave() {
        Session session = sf.openSession();
        session.beginTransaction();

        // 保存
        //		Cat cat = new Cat();
        //		cat.setName("大花猫");
        //		cat.setCatchMouse("抓小老鼠");
        //		session.save(cat);

        // 获取时候注意:当写hql查询的使用,通过父类查询必须写上类的全名
        Query q = session.createQuery("from cn.itcast.e_extends1.Animal");
        List<Animal> list = q.list();
        System.out.println(list);

        session.getTransaction().commit();
        session.close();
    }
}
	简单继承映射,有多少个子类,写多少个映射文件!

8.继承映射2
需求:猫、猴子、动物。
所有子类映射到一张表 (1张表)
什么情况用?
	子类教多,且子类较为简单,即只有个别属性!
	好处:因为使用一个映射文件, 减少了映射文件的个数。
	缺点:(不符合数据库设计原则)
一个映射文件: Animal.hbm.xml
			(如何区分是哪个子类的信息?)
数据库:
	T_animal (要存储所有的子类信息)                 “鉴别器”
		Id   name     catchMouse      eatBanana		  type_(区别是哪个子类)
         1   大马猴       NULL        吃10个香蕉     猴子
		 2   大花猫     不抓老鼠         NULL          猫
package com.xp.e_extends2;

public class Animal {

	private int id;
	private String name;
	
	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;
	}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                                   "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
	继承映射, 所有的子类都映射到一张表
 -->
<hibernate-mapping package="com.xp.e_extends2">
 <class name="Animal" table="t_animal">
  <id name="id">
   <generator class="native"/>
  </id>
  <discriminator column="type_" force="false" insert="true" not-null="true"/>
  <property generated="never" lazy="false" name="name"/>
  <!-- 
			子类:猫
				每个子类都用subclass节点映射
				注意:一定要指定鉴别器字段,否则报错!
				鉴别器字段:作用是在数据库中区别每一个子类的信息, 就是一个列
			discriminator-value="cat_"
				指定鉴别器字段,即type_字段的值
				如果不指定,默认为当前子类的全名
		 -->
  <subclass discriminator-value="cat_" name="Cat" select-before-update="false">
   <property generated="never" lazy="false" name="catchMouse"/>
  </subclass>
  <!-- 
		 	子类:猴子
		  -->
  <subclass discriminator-value="monkey_" name="Monkey" select-before-update="false">
   <property generated="never" lazy="false" name="eatBanana"/>
  </subclass>
 </class>
</hibernate-mapping>

package com.xp.e_extends2;
public class Monkey extends Animal{
	// 吃香蕉
		private String eatBanana;

		public String getEatBanana() {
			return eatBanana;
		}
		public void setEatBanana(String eatBanana) {
			this.eatBanana = eatBanana;
		}
}
package com.xp.e_extends2;

public class Cat extends Animal{
	// 抓老鼠
	private String catchMouse;
	public String getCatchMouse() {
		return catchMouse;
	}
	public void setCatchMouse(String catchMouse) {
		this.catchMouse = catchMouse;
	}
}
package com.xp.e_extends2;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;


public class App {
	private static SessionFactory sf;
	static {
		sf = new Configuration()
			.configure()
			.addClass(Animal.class)   
			.buildSessionFactory();
	}
	@Test
	public void getSave() {
		
		Session session = sf.openSession();
		session.beginTransaction();
		
		// 保存
		Cat cat = new Cat();
		cat.setName("大花猫");
		cat.setCatchMouse("抓小老鼠");
		
		Monkey m = new Monkey();
		m.setName("猴子");
		m.setEatBanana("吃10个香蕉");
		
		// 保存
		session.save(cat);
		session.save(m);
		
		session.getTransaction().commit();
		session.close();
		
	}
}



总结:
	写法较为简单:所有子类用一个映射文件,且映射到一张表!
	但数据库设计不合理!
	(不推荐用。)
每个类映射一张表(3张表)
数据库
  T_anmal (存储父类信息)
	1   大花猫
  T_cat (引用父类的主键)
     1  抓小老鼠
T_monkey(引用父类的主键)

Javabean设计一样,映射实现不同:

<!-- 
	继承映射, 每个类对应一张表(父类也对应表)
 -->
<hibernate-mapping package="cn.itcast.e_extends3">
	
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		
		<!-- 
			子类:猫  t_cat
			key 指定_cat表的外键字段
		-->
		<joined-subclass name="Cat" table="t_cat">
			<key column="t_animal_id"></key>
			<property name="catchMouse"></property>
		</joined-subclass>
		
		<!-- 子类:猴子  t_monkey -->
		<joined-subclass name="Monkey" table="t_monkey">
			<key column="t_animal_id"></key>
			<property name="eatBanana"></property>
		</joined-subclass>
		
	</class>
	

</hibernate-mapping>



总结:
	一个映射文件,存储所有的子类; 子类父类都对应表;
   缺点:表结构比较负责,插入一条子类信息,需要用2条sql: 往父类插入、往子类插入!
(推荐)每个子类映射一张表, 父类不对应表(2张表)
数据库:
	T_cat
		Id   name   catchMounse
	T_monkey
		Id    name   eatBanana

<union-subclass name="Cat" table="t_cat">
			<property name="catchMouse"></property>
		</union-subclass>
注意:主键不能是自增长!

总结:
	所有的子类都写到一个映射文件;
父类不对应表; 每个子类对应一张表
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 
	继承映射, 每个类对应一张表(父类也对应表)
 -->
<hibernate-mapping package="com.xp.e_extends3">
	
	<class name="Animal" table="t_animal">
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name"></property>
		
		<!-- 
			子类:猫  t_cat
			key 指定_cat表的外键字段
		-->
		<joined-subclass name="Cat" table="t_cat">
			<key column="t_animal_id"></key>
			<property name="catchMouse"></property>
		</joined-subclass>
		
		<!-- 子类:猴子  t_monkey -->
		<joined-subclass name="Monkey" table="t_monkey">
			<key column="t_animal_id"></key>
			<property name="eatBanana"></property>
		</joined-subclass>
	</class>
</hibernate-mapping>
或
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!-- 
	继承映射, 每个类对应一张表(父类不对应表)
 -->
<hibernate-mapping package="cn.itcast.e_extends4">
	<!-- 
		 abstract="true"  指定实体类对象不对应表,即在数据库段不生成表
	 -->
	<class name="Animal" abstract="true">
		<!-- 如果用union-subclass节点,主键生成策略不能为自增长! -->
		<id name="id">
			<generator class="uuid"></generator>
		</id>
		<property name="name"></property>
		
		<!-- 
			子类:猫  t_cat
			union-subclass  
				table 指定为表名, 表的主键即为id列
		-->
		<union-subclass name="Cat" table="t_cat">
			<property name="catchMouse"></property>
		</union-subclass>
		
		<!-- 子类:猴子  t_monkey -->
		<union-subclass name="Monkey" table="t_monkey">
			<property name="eatBanana"></property>
		</union-subclass>
	</class>
</hibernate-mapping>
Hibernate中映射:
	多对一
	一对多
	多对多
	一对一  (多对一的特殊应用)
	组件
	继承