<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-1-7 21:17:10 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="hellohibernate.helloword.News" table="NEWS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="title" type="java.lang.String">
            <column name="TITLE" />
        </property>
        <property name="author" type="java.lang.String">
            <column name="AUTHOR" />
        </property>
        <property name="date" type="timestamp">
            <column name="DATE" />
        </property>
    </class>
</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    	<!-- 配置数据库连接相关的信息 -->
    	<property name="connection.username">root</property>
    	<property name="connection.password">123</property>
    	<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    	<property name="connection.url">jdbc:mysql://localhost:3306/hellohibernate</property>
    	
    	<!-- 配置hibernate的基本信息 -->
    	<!-- 配置数据库方言 -->
    	<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
    	
    	<!-- 是否在控制台打印SQL -->
    	<property name="show_sql">true</property>
    	
    	<!-- 是否格式化SQL -->
    	<property name="format_sql">true</property>
    	
    	<!-- 指定自动生成数据表的策略  -->
    	<property name="hbm2ddl.auto">update</property>
    	
    	<!-- 指定关联的对象-数据关系映射文件，.hbm.xml文件 -->
    	<mapping resource="hellohibernate/helloword/News.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

//1. 创建一个 SessionFactory 对象
SessionFactory sessionFactory = null;

// configure方法默认Hibernate的配置文件是类根目录下的hibernate.cfg.xml文件
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();		
//2. 创建一个Session对象
Session session = sessionFactory.openSession();
//3. 开启事务
Transaction transaction = session.beginTransaction();
//4. 执行保存操作
News news = new News("Java", "ljy", new java.util.Date());		
session.save(news);
//5. 提交事务
transaction.commit();
//6. 关闭Session对象
session.close();
//7. 关闭SessionFactory对象
sessionFactory.close();		

public void testDoWork(){
	session.doWork(new Work() {
		@Override
		public void execute(Connection connection) throws SQLException {
			// connection 即是JDBC原生的连接对象						
		}
	});
}

<!-- 数据库连接池的最大连接数 -->
<property name="hibernate.c3p0.max_size">10</property>
<!-- 数据库连接池的最小连接数 -->
<property name="hibernate.c3p0.min_size">5</property>
<!-- 当连接池中的连接耗尽时，向数据库申请连接的数量 -->
<property name="c3p0.acquire_increment">2</property>
<!-- 连接池检测池中连接是否已超时的时间间隔 -->
<property name="c3p0.idle_test_period">2000</property>
<!-- 池中连接允许空闲的最长时间，超时后会被销毁 -->
<property name="c3p0.timeout">2000</property>
<!-- 允许缓存 Statement 对象的最大数量 -->
<property name="c3p0.max_statements">10</property>

<!-- 设定 JDBC 的 Statement 读取数据的时, 每次从数据库中取出的记录条数 -->
<property name="hibernate.jdbc.fetch_size">100</property>
<!-- 设定对数据库进行批量删除/更新/插入时, 批量的大小 -->
<property name="jdbc.batch_size">30</property>

• hibernate-mapping
  
• 类层次：class
• 主键: id
• generator   
• 基本类型: property
• 实体引用类: many-to-one  |  one-to-one
• 集合: set | list | map | array
• one-to-many
• many-to-many
• 子类: subclass | joined-subclass
• 其它: component | any 等
• 查询语句:query（用来放置查询语句，便于对数据库查询的统一管理和优化）

package hellohibernate.helloword;
public class Worker {
	
	private Integer id;
	private String name;
	
	private Pay pay;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Pay getPay() {
		return pay;
	}
	public void setPay(Pay pay) {
		this.pay = pay;
	}
}

package hellohibernate.helloword;
public class Pay {
	
	private int monthlyPay;
	private int yearPay;
	private int vocationWithPay;
	
	private Worker worker;
	
	public Worker getWorker() {
		return worker;
	}
	public void setWorker(Worker worker) {
		this.worker = worker;
	}
	public int getMonthlyPay() {
		return monthlyPay;
	}
	public void setMonthlyPay(int monthlyPay) {
		this.monthlyPay = monthlyPay;
	}
	public int getYearPay() {
		return yearPay;
	}
	public void setYearPay(int yearPay) {
		this.yearPay = yearPay;
	}
	public int getVocationWithPay() {
		return vocationWithPay;
	}
	public void setVocationWithPay(int vocationWithPay) {
		this.vocationWithPay = vocationWithPay;
	}	
}

<?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="hellohibernate.helloword">
    <class name="Worker" table="WORKERS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <!-- 映射组成关系 -->
        <component name="pay" class="Pay">
        	<parent name="worker"/>
        	<property name="monthlyPay"></property>
        	<property name="yearPay"></property>
        	<property name="vocationWithPay"></property>
        </component>
    </class>
</hibernate-mapping>

9.1.1. 单向一对多（1-n）

注意：这种映射模式在实践中并不推荐！

域模型：1端持有n端对象的集合，n端对象不含有1端对象的引用。

映射方向：从1端追溯到n端。

关系数据库模型：hibernate会自动在n端对应的数据表中引用1端对应的数据表，即以1端数据表的主键作为n端数据表的外键。

9.1.2. 单向多对一（n-1）

@Test
public void testMany2OneSave(){
	Customer customer = new Customer();
	customer.setCustomerName("BB");
	
	Order order1 = new Order();
	order1.setOrderName("ORDER-3");
	
	Order order2 = new Order();
	order2.setOrderName("ORDER-4");
	
	//设定关联关系
	order1.setCustomer(customer);
	order2.setCustomer(customer);
	
	//执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT
	//先插入 1 的一端, 再插入 n 的一端, 只有 INSERT 语句.
//	session.save(customer);
//	session.save(order1);
//	session.save(order2);
	
	//先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
	//先插入 n 的一端, 再插入 1 的一端, 会多出 UPDATE 语句!
	//因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句.
	//推荐先插入 1 的一端, 后插入 n 的一端
	session.save(order1);
	session.save(order2);
	session.save(customer);
}

@Test
public void testManyToOneGet(){	
	//1. 若查询多n端的一个对象, 则默认情况下, 只查询了n端的对象. 而没有查询关联的1那一端的对象!
	Order order = session.get(Order.class, 1);
	System.out.println(order.getOrderName());
	System.out.println(order.getCustomer().getClass().getName());
	
	//3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, 
	//若此时 session 已被关闭, 则默认情况下会发生 LazyInitializationException 异常
//	session.close();
	
	Customer customer = order.getCustomer();
	//2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句.
	System.out.println(customer.getCustomerName());
}

@Test
public void testDelete(){
	Customer customer = session.get(Customer.class, 1);
    // 在不设定级联关系的情况下，且 1 这一端的对象有 n 端的对象在引用，
    // 则不能直接删除 1 这一端的对象，否则会引发
    // org.hibernate.exception.ConstraintViolationException 异常
	session.delete(customer);
}

<hibernate-mapping package="hellohibernate.subclass.joined">
    <class name="Person" table="PERSON">
         <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>        
        
        <joined-subclass name="Student" table="STUDENT">
        	<key column="STUDENTID"/>
        	<property name="school" type="java.lang.String" column="SCHOOL"/>
        </joined-subclass>
    </class>
</hibernate-mapping>

10.3. 采用 union-subclass 元素的继承映射

实例如下，POJO：

public class Person {
	//因为要使用uuid主键生成策略，所以要改成字符串类型
	private String id;
	private String name;
	private int age;
    //...
}
public class Student extends Person{
	private String school;
    //...
}

.hbm.xml文件：

<hibernate-mapping package="hellohibernate.subclass.union">
    <class name="Person" table="PERSON">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <!-- 注意主键的生成策略 -->
            <generator class="uuid" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        <union-subclass name="Student" table="STUDENT">
        	<property name="school" column="SCHOOL" type="java.lang.String"/>
        </union-subclass>
    </class>
</hibernate-mapping>

10.4. 三种继承映射方式的比较

12.2.1. QBC 检索

public void testQBC(){
	//1. 创建一个 Criteria 对象
	Criteria criteria = session.createCriteria(Employee.class);
	
	//2. 添加查询条件: 在 QBC 中查询条件使用 Criterion 来表示
	//Criterion 可以通过 Restrictions 的静态方法得到
	criteria.add(Restrictions.eq("email", "SKUMAR"));
	criteria.add(Restrictions.gt("salary", 5000F));
	
	//3. 执行查询
	Employee employee = (Employee) criteria.uniqueResult();
	System.out.println(employee); 
}

public void testQBC2(){
	Criteria criteria = session.createCriteria(Employee.class);
	
	//1. AND: 使用 Conjunction 表示
	//Conjunction 本身就是一个 Criterion 对象
	//且其中还可以添加 Criterion 对象
	Conjunction conjunction = Restrictions.conjunction();
	conjunction.add(Restrictions.like("name", "a", MatchMode.ANYWHERE));
	Department dept = new Department();
	dept.setId(80);
	conjunction.add(Restrictions.eq("dept", dept));
	System.out.println(conjunction); 
	
	//2. OR
	Disjunction disjunction = Restrictions.disjunction();
	disjunction.add(Restrictions.ge("salary", 6000F));
	disjunction.add(Restrictions.isNull("email"));
	
	criteria.add(disjunction);
	criteria.add(conjunction);
	
	criteria.list();
}

public void testQBC3(){
	Criteria criteria = session.createCriteria(Employee.class);
	
	//统计查询: 使用 Projection 来表示: 可以由 Projections 的静态方法得到
	criteria.setProjection(Projections.max("salary"));
	
	System.out.println(criteria.uniqueResult()); 
}

public void testQBC4(){
	Criteria criteria = session.createCriteria(Employee.class);
	
	//1. 添加排序
	criteria.addOrder(Order.asc("salary"));
	criteria.addOrder(Order.desc("email"));
	
	//2. 添加翻页方法
	int pageSize = 5;
	int pageNo = 3;
	criteria.setFirstResult((pageNo - 1) * pageSize)
	        .setMaxResults(pageSize)
	        .list();
}

12.2.2. 本地 SQL 检索

14. 管理 Session

15. 批量处理数据