主键映射和Hibernate映射

组件映射

类组合关系的映射，也叫做组件映射！

　　注意：组件类和被包含的组件类，共同映射到一张表！

　　需求：如汽车与车轮

代码示例：

1、JavaBean

Wheel.java

package com.gqx.component;
/**
 * 车轮
 * @author 郭庆兴
 *
 */
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;
	}

}

Car.java

package com.gqx.component;

public class Car {
	private int id;
	private String brand;
	//车轮
	private Wheel wheel;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public Wheel getWheel() {
		return wheel;
	}
	public void setWheel(Wheel wheel) {
		this.wheel = wheel;
	}

}

2、映射文件

<?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.gqx.component">

	<class name="Car" table="t_car" >
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="brand" length="20"></property>

		<!-- 组件映射 -->
		<component name="wheel">
			<property name="count"></property>
			<property name="size"></property>
		</component>
	</class>
</hibernate-mapping>

3、测试程序

package com.gqx.component;

import static org.junit.Assert.*;

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

import com.gqx.collection.User;

public class App {
	private static SessionFactory sf;
	static{
		sf=new Configuration().configure()
				.addClass(Car.class)
				.buildSessionFactory();
	}
	@Test
	public void test() {
		Session session=sf.openSession();
		session.beginTransaction();

		//轮子
		Wheel wheel=new Wheel();
		wheel.setCount(4);
		wheel.setSize(40);
		//汽车
		Car car=new Car();
		car.setBrand("BMW");
		car.setWheel(wheel);
		//保存
		session.save(car);
		session.getTransaction().commit();
		session.close();
	}

}

继承映射

　　如：父类——动物

　　　　　　子类：猫，猴子

1、JavaBean文件

Animal.java

package com.gqx.extends1;
/**
 * 动物类
 * @author 郭庆兴
 *
 */
public abstract 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;
	}
}

Cat.java

package com.gqx.extends1;

public class Cat extends Animal {
	//抓老鼠
	private String catchMouse;

	public String getCatchMouse() {
		return catchMouse;
	}

	public void setCatchMouse(String catchMouse) {
		this.catchMouse = catchMouse;
	}

}

Monkey.java

package com.gqx.extends2;

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

	public String getEatBanana() {
		return eatBanana;
	}

	public void setEatBanana(String eatBanana) {
		this.eatBanana = eatBanana;
	}

}

2、映射文件

简单继承映射

<?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.gqx.extends1">

	<class name="Cat" table="t_cat" >
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="catchMouse" length="20"></property>
		<property name="name" length="20"></property>
	</class>
</hibernate-mapping>

3、测试文件

package com.gqx.extends1;

import static org.junit.Assert.*;

import java.util.List;

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

import com.gqx.collection.User;

public class App {
	private static SessionFactory sf;
	static{
		sf=new Configuration().configure()
				.addClass(Cat.class)
				.buildSessionFactory();
	}
	@Test
	public void test() {
		Session session=sf.openSession();
		session.beginTransaction();

		Cat cat=new Cat();
		cat.setName("龙猫");
		cat.setCatchMouse("抓小老鼠");

		session.save(cat);

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

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

//		Query q=session.createQuery("from Cat");
//		List<Cat> list=q.list();
//		如果通过父类查询，需要说明包
		Query q=session.createQuery("from com.gqx.extends1.Cat");
		List<Animal> list=q.list();
		System.out.println(list);

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

}

映射文件也可以分为三种类型去实现

一、所有子类映射到一张表 (1张表)

什么情况用？

子类教多，且子类较为简单，即只有个别属性！

好处：因为使用一个映射文件，减少了映射文件的个数。

缺点：（不符合数据库设计原则）

　　一个映射文件： Animal.hbm.xml

<?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.gqx.extends2">

	<class name="Animal" table="t_animal" >
		<id name="id">
			<generator class="native"></generator>
		</id>
		<!-- 指定鉴别器字段（区分不同的子类） -->
		<discriminator column="type_"></discriminator>
		<property name="name" length="20"></property>

		<!-- 每个子类都用subclass映射
			 注意：一定要指定鉴别器字段，否则报错！
			 鉴别器字段：作用是在数据库中区别每一个子类信息，就是一个列的信息
		 -->
		<!-- 子类：猫
			 discriminator-value：
			 指定鉴别器字段，即type_字段的值
			 如果不指定，默认为当前子类的全名
		-->
		<subclass name="Cat" discriminator-value="cat_">
			<property name="catchMouse"></property>
		</subclass>
		<!-- 子类：狗 -->
		<subclass name="Monkey" discriminator-value="monkey_">
			<property name="eatBanana"></property>
		</subclass>
	</class>
</hibernate-mapping>

结果如图：

总结：

写法较为简单：所有子类用一个映射文件，且映射到一张表！

但数据库设计不合理!

二、每个类映射一张表(3张表)

数据库

T_anmal （存储父类信息）

T_cat （引用父类的主键）

T_monkey（引用父类的主键）

映射文件

<?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.gqx.extends3">

	<class name="Animal" table="t_animal" >
		<id name="id">
			<generator class="native"></generator>
		</id>
		<property name="name" length="20"></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张表)

这个时候要把Animal类的id改一下

private String id;