Hibernate-2映射 Java 的时间, 日期类型

2. 映射 Java 的时间, 日期类型


1). 两个基础知识:


I. 在 Java 中, 代表时间和日期的类型包括: java.util.Date 和 java.util.Calendar. 
此外, 在 JDBC API 中还提供了 3 个扩展了 java.util.Date 类的子类: java.sql.Date, java.sql.Time 
和 java.sql.Timestamp, 这三个类分别和标准 SQL 类型中的 DATE, TIME 和 TIMESTAMP 类型对应


II. 在标准 SQL 中, DATE 类型表示日期, TIME 类型表示时间, TIMESTAMP 类型表示时间戳, 同时包含日期和时间信息. 


2). 如何进行映射 ?


I. 因为 java.util.Date 是 java.sql.Date, java.sql.Time 和 java.sql.Timestamp 的父类, 所以 java.util.Date
可以对应标准 SQL 类型中的 DATE, TIME 和 TIMESTAMP


II. 基于 I, 所以在设置持久化类的 Date 类型是, 设置为 java.util.Date. 


III. 如何把 java.util.Date 映射为 DATE, TIME 和 TIMESTAMP ?


可以通过 property 的 type 属性来进行映射: 


例如:


<property name="date" type="timestamp">
    <column name="DATE" />
</property>


<property name="date" type="data">
    <column name="DATE" />
</property>


<property name="date" type="time">
    <column name="DATE" />
</property>


其中 timestamp, date, time 既不是 Java 类型, 也不是标准 SQL 类型, 而是 hibernate 映射类型. 


1. 在 hibernate 中使用 C3P0 数据源:


1). 导入 jar 包:


hibernate-release-4.2.4.Final\lib\optional\c3p0\*.jar


2). 加入配置:


hibernate.c3p0.max_size: 数据库连接池的最大连接数
hibernate.c3p0.min_size: 数据库连接池的最小连接数
hibernate.c3p0.acquire_increment: 当数据库连接池中的连接耗尽时, 同一时刻获取多少个数据库连接


hibernate.c3p0.timeout:   数据库连接池中连接对象在多长时间没有使用过后，就应该被销毁
hibernate.c3p0.idle_test_period:  表示连接池检测线程多长时间检测一次池内的所有链接对象是否超时. 
连接池本身不会把自己从连接池中移除，而是专门有一个线程按照一定的时间间隔来做这件事，
这个线程通过比较连接对象最后一次被使用时间和当前时间的时间差来和 timeout 做对比，进而决定是否销毁这个连接对象。 

hibernate.c3p0.max_statements:  缓存 Statement 对象的数量

代码

1、hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"><hibernate-configuration>    <session-factory>        <!-- Hibernate 连接数据库的基本信息 -->    <property name="connection.username">root</property>    <property name="connection.password">1230</property>    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>    <property name="connection.url">jdbc:mysql:///hibernate5</property><!-- Hibernate 的基本配置 --><!-- Hibernate 使用的数据库方言 --><property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property><!-- 运行时是否打印 SQL -->    <property name="show_sql">true</property>        <!-- 运行时是否格式化 SQL -->    <property name="format_sql">true</property>        <!-- 生成数据表的策略 -->    <property name="hbm2ddl.auto">update</property>        <!-- 设置 Hibernate 的事务隔离级别 -->    <property name="connection.isolation">2</property>        <!-- 删除对象后, 使其 OID 置为 null -->    <property name="use_identifier_rollback">true</property>        <!-- 配置 C3P0 数据源 -->    <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>        <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 映射文件 .hbm.xml --><!--      <mapping resource="com/atguigu/hibernate/entities/News.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/entities/Worker.hbm.xml"/>        <mapping resource="com/atguigu/hibernate/entities/n21/Customer.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/entities/n21/Order.hbm.xml"/>-->    <mapping resource="com/atguigu/hibernate/entities/n21/both/Customer.hbm.xml"/>    <mapping resource="com/atguigu/hibernate/entities/n21/both/Order.hbm.xml"/>        </session-factory></hibernate-configuration>

com.atguigu.hibernate.entities包

2、HibernateTest.java

package com.atguigu.hibernate.entities;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.sql.Blob;import java.sql.Connection;import java.sql.SQLException;import java.util.Date;import org.hibernate.Hibernate;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.jdbc.Work;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.After;import org.junit.Before;import org.junit.Test;public class HibernateTest {private SessionFactory sessionFactory;private Session session;private Transaction transaction;@Beforepublic void init(){Configuration configuration = new Configuration().configure();ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())                            .buildServiceRegistry();sessionFactory = configuration.buildSessionFactory(serviceRegistry);session = sessionFactory.openSession();transaction = session.beginTransaction();}@Afterpublic void destroy(){transaction.commit();session.close();sessionFactory.close();}@Testpublic void testComponent(){Worker worker = new Worker();Pay pay = new Pay();pay.setMonthlyPay(1000);pay.setYearPay(80000); pay.setVocationWithPay(5);worker.setName("ABCD");worker.setPay(pay);session.save(worker);}@Testpublic void testBlob() throws Exception{//News news = new News();//news.setAuthor("cc");//news.setContent("CONTENT");//news.setDate(new Date());//news.setDesc("DESC");//news.setTitle("CC");////InputStream stream = new FileInputStream("Hydrangeas.jpg");//Blob image = Hibernate.getLobCreator(session)//              .createBlob(stream, stream.available());//news.setImage(image);////session.save(news);News news = (News) session.get(News.class, 1);Blob image = news.getImage();InputStream in = image.getBinaryStream();System.out.println(in.available()); }@Testpublic void testPropertyUpdate(){News news = (News) session.get(News.class, 1);news.setTitle("aaaa"); System.out.println(news.getDesc());System.out.println(news.getDate().getClass()); }@Testpublic void testIdGenerator() throws InterruptedException{News news = new News("AA", "aa", new java.sql.Date(new Date().getTime()));session.save(news); //Thread.sleep(5000); }@Testpublic void testDynamicUpdate(){News news = (News) session.get(News.class, 1);news.setAuthor("AABCD");}@Testpublic void testDoWork(){session.doWork(new Work() {@Overridepublic void execute(Connection connection) throws SQLException {System.out.println(connection); //调用存储过程. }});}/** * evict: 从 session 缓存中把指定的持久化对象移除 */@Testpublic void testEvict(){News news1 = (News) session.get(News.class, 1);News news2 = (News) session.get(News.class, 2);news1.setTitle("AA");news2.setTitle("BB");session.evict(news1); }/** * delete: 执行删除操作. 只要 OID 和数据表中一条记录对应, 就会准备执行 delete 操作 * 若 OID 在数据表中没有对应的记录, 则抛出异常 *  * 可以通过设置 hibernate 配置文件 hibernate.use_identifier_rollback 为 true, * 使删除对象后, 把其 OID 置为  null */@Testpublic void testDelete(){//News news = new News();//news.setId(11);News news = (News) session.get(News.class, 163840);session.delete(news); System.out.println(news);}/** * 注意: * 1. 若 OID 不为 null, 但数据表中还没有和其对应的记录. 会抛出一个异常.  * 2. 了解: OID 值等于 id 的 unsaved-value 属性值的对象, 也被认为是一个游离对象 */@Testpublic void testSaveOrUpdate(){News news = new News("FFF", "fff", new Date());news.setId(11);session.saveOrUpdate(news); }/** * update: * 1. 若更新一个持久化对象, 不需要显示的调用 update 方法. 因为在调用 Transaction * 的 commit() 方法时, 会先执行 session 的 flush 方法. * 2. 更新一个游离对象, 需要显式的调用 session 的 update 方法. 可以把一个游离对象 * 变为持久化对象 *  * 需要注意的: * 1. 无论要更新的游离对象和数据表的记录是否一致, 都会发送 UPDATE 语句.  *    如何能让 updat 方法不再盲目的出发 update 语句呢 ? 在 .hbm.xml 文件的 class 节点设置 *    select-before-update=true (默认为 false). 但通常不需要设置该属性.  *  * 2. 若数据表中没有对应的记录, 但还调用了 update 方法, 会抛出异常 *  * 3. 当 update() 方法关联一个游离对象时,  * 如果在 Session 的缓存中已经存在相同 OID 的持久化对象, 会抛出异常. 因为在 Session 缓存中 * 不能有两个 OID 相同的对象! *     */@Testpublic void testUpdate(){News news = (News) session.get(News.class, 1);transaction.commit();session.close();//news.setId(100);session = sessionFactory.openSession();transaction = session.beginTransaction();//news.setAuthor("SUN"); News news2 = (News) session.get(News.class, 1);session.update(news);}/** * get VS load: *  * 1. 执行 get 方法: 会立即加载对象.  *    执行 load 方法, 若不适用该对象, 则不会立即执行查询操作, 而返回一个代理对象 *     *    get 是 立即检索, load 是延迟检索.  *  * 2. load 方法可能会抛出 LazyInitializationException 异常: 在需要初始化 * 代理对象之前已经关闭了 Session *  * 3. 若数据表中没有对应的记录, Session 也没有被关闭.   *    get 返回 null *    load 若不使用该对象的任何属性, 没问题; 若需要初始化了, 抛出异常.   */@Testpublic void testLoad(){News news = (News) session.load(News.class, 10);System.out.println(news.getClass().getName()); //session.close();//System.out.println(news); }@Testpublic void testGet(){News news = (News) session.get(News.class, 1);//session.close();System.out.println(news); }/** * persist(): 也会执行 INSERT 操作 *  * 和 save() 的区别 :  * 在调用 persist 方法之前, 若对象已经有 id 了, 则不会执行 INSERT, 而抛出异常 */@Testpublic void testPersist(){News news = new News();news.setTitle("EE");news.setAuthor("ee");news.setDate(new Date());news.setId(200); session.persist(news); }/** * 1. save() 方法 * 1). 使一个临时对象变为持久化对象 * 2). 为对象分配 ID. * 3). 在 flush 缓存时会发送一条 INSERT 语句. * 4). 在 save 方法之前的 id 是无效的 * 5). 持久化对象的 ID 是不能被修改的! */@Testpublic void testSave(){News news = new News();news.setTitle("CC");news.setAuthor("cc");news.setDate(new Date());news.setId(100); System.out.println(news);session.save(news);System.out.println(news);//news.setId(101); }/** * clear(): 清理缓存 */@Testpublic void testClear(){News news1 = (News) session.get(News.class, 1);session.clear();News news2 = (News) session.get(News.class, 1);}/** * refresh(): 会强制发送 SELECT 语句, 以使 Session 缓存中对象的状态和数据表中对应的记录保持一致! */@Testpublic void testRefresh(){News news = (News) session.get(News.class, 1);System.out.println(news);session.refresh(news); System.out.println(news); }/** * flush: 使数据表中的记录和 Session 缓存中的对象的状态保持一致. 为了保持一致, 则可能会发送对应的 SQL 语句. * 1. 在 Transaction 的 commit() 方法中: 先调用 session 的 flush 方法, 再提交事务 * 2. flush() 方法会可能会发送 SQL 语句, 但不会提交事务.  * 3. 注意: 在未提交事务或显式的调用 session.flush() 方法之前, 也有可能会进行 flush() 操作. * 1). 执行 HQL 或 QBC 查询, 会先进行 flush() 操作, 以得到数据表的最新的记录 * 2). 若记录的 ID 是由底层数据库使用自增的方式生成的, 则在调用 save() 方法时, 就会立即发送 INSERT 语句.  * 因为 save 方法后, 必须保证对象的 ID 是存在的! */@Testpublic void testSessionFlush2(){News news = new News("Java", "SUN", new Date());session.save(news);}@Testpublic void testSessionFlush(){News news = (News) session.get(News.class, 1);news.setAuthor("Oracle");//session.flush();//System.out.println("flush");News news2 = (News) session.createCriteria(News.class).uniqueResult();System.out.println(news2);}@Testpublic void testSessionCache(){News news = (News) session.get(News.class, 1);System.out.println(news); News news2 = (News) session.get(News.class, 1);System.out.println(news2);}}

3、News.java

package com.atguigu.hibernate.entities;import java.sql.Blob;import java.util.Date;public class News {private Integer id;private String title;private String author;private Date date;//该属性值为： title: authorprivate String desc;//大文本private String content;//二进制数据private Blob image;public String getContent() {return content;}public void setContent(String content) {this.content = content;}public Blob getImage() {return image;}public void setImage(Blob image) {this.image = image;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) {super();this.title = title;this.author = author;this.date = date;}public News() {// TODO Auto-generated constructor stub}@Overridepublic String toString() {return "News [id=" + id + ", title=" + title + ", author=" + author+ ", date=" + date + "]";}public String getDesc() {return desc;}public void setDesc(String desc) {this.desc = desc;}}

4、Pay.java

package com.atguigu.hibernate.entities;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;}}

5、Worker.java

package com.atguigu.hibernate.entities;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;}}

6、News.hbm.xml

<?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="com.atguigu.hibernate.entities">    <class name="News" table="NEWS" dynamic-update="true">            <id name="id" type="java.lang.Integer">            <column name="ID" />            <generator class="native" />        </id>                <property name="title" type="string" column="TITLE"        unique="true" update="false" index="news_index" length="20">        </property>                <property name="author" type="java.lang.String" index="news_index">            <column name="AUTHOR" />        </property>                <property name="date" type="time">            <column name="DATE" />        </property>                <!-- 映射派生属性 -->        <property name="desc" formula="(SELECT concat(author, ': ', title) FROM NEWS n WHERE n.id = id)"></property>                <!-- 映射大对象 -->        <!-- 若希望精确映射 SQL 类型, 可以使用 sql-type 属性. -->        <property name="content">        <column name="CONTENT" sql-type="mediumtext"></column>        </property>                <property name="image">        <column name="IMAGE" sql-type="mediumblob"></column>        </property>            </class>    </hibernate-mapping>

7、Worker.hbm.xml

<?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 2014-1-2 16:14:33 by Hibernate Tools 3.4.0.CR1 --><hibernate-mapping package="com.atguigu.hibernate.entities">    <class name="Worker" table="WORKER">        <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" column="MONTHLY_PAY"></property>        <property name="yearPay" column="YEAR_PAY"></property>        <property name="vocationWithPay" column="VOCATION_WITH_PAY"></property>        </component>            </class></hibernate-mapping>

com.atguigu.hibernate.entities.n21包

8、Customer.java

package com.atguigu.hibernate.entities.n21;public class Customer {private Integer customerId;private String customerName;public Integer getCustomerId() {return customerId;}public void setCustomerId(Integer customerId) {this.customerId = customerId;}public String getCustomerName() {return customerName;}public void setCustomerName(String customerName) {this.customerName = customerName;}}

9、HibernateTest.java

package com.atguigu.hibernate.entities.n21;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.sql.Blob;import java.sql.Connection;import java.sql.SQLException;import java.util.Date;import org.hibernate.Hibernate;import org.hibernate.LazyInitializationException;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.jdbc.Work;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.After;import org.junit.Before;import org.junit.Test;public class HibernateTest {private SessionFactory sessionFactory;private Session session;private Transaction transaction;@Beforepublic void init(){Configuration configuration = new Configuration().configure();ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())                            .buildServiceRegistry();sessionFactory = configuration.buildSessionFactory(serviceRegistry);session = sessionFactory.openSession();transaction = session.beginTransaction();}@Afterpublic void destroy(){transaction.commit();session.close();sessionFactory.close();}@Testpublic void testDelete(){//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象Customer customer = (Customer) session.get(Customer.class, 1);session.delete(customer); }@Testpublic void testUpdate(){Order order = (Order) session.get(Order.class, 1);order.getCustomer().setCustomerName("AAA");}@Testpublic void testMany2OneGet(){//1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的//1 的那一端的对象!Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName()); System.out.println(order.getCustomer().getClass().getName());session.close();//2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句. Customer customer = order.getCustomer();System.out.println(customer.getCustomerName()); //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, //若此时 session 已被关闭, 则默认情况下//会发生 LazyInitializationException 异常//4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!}@Testpublic 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);}}

10、Order.java

package com.atguigu.hibernate.entities.n21;public class Order {private Integer orderId;private String orderName;private Customer customer;public Integer getOrderId() {return orderId;}public void setOrderId(Integer orderId) {this.orderId = orderId;}public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}public Customer getCustomer() {return customer;}public void setCustomer(Customer customer) {this.customer = customer;}}

11、Customer.hbm.xml

<?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>        <class name="com.atguigu.hibernate.entities.n21.Customer" table="CUSTOMERS">            <id name="customerId" type="java.lang.Integer">            <column name="CUSTOMER_ID" />            <generator class="native" />        </id>            <property name="customerName" type="java.lang.String">            <column name="CUSTOMER_NAME" />        </property>            </class>    </hibernate-mapping>

12、Order.hbm.xml

<?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="com.atguigu.hibernate.entities.n21">    <class name="Order" table="ORDERS">        <id name="orderId" type="java.lang.Integer">            <column name="ORDER_ID" />            <generator class="native" />        </id>                <property name="orderName" type="java.lang.String">            <column name="ORDER_NAME" />        </property>        <!-- 映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 name: 多这一端关联的一那一端的属性的名字class: 一那一端的属性对应的类名column: 一那一端在多的一端对应的数据表中的外键的名字--><many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>    </class></hibernate-mapping>

com.atguigu.hibernate.entities.n21.both包
1、Customer.java

package com.atguigu.hibernate.entities.n21.both;import java.util.HashSet;import java.util.Set;public class Customer {private Integer customerId;private String customerName;/* * 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取 * 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的 * 集合实现.  * 2. 需要把集合进行初始化, 可以防止发生空指针异常 */private Set<Order> orders = new HashSet<>();public Integer getCustomerId() {return customerId;}public void setCustomerId(Integer customerId) {this.customerId = customerId;}public String getCustomerName() {return customerName;}public void setCustomerName(String customerName) {this.customerName = customerName;}public Set<Order> getOrders() {return orders;}public void setOrders(Set<Order> orders) {this.orders = orders;}}

2、HibernateTest.java

package com.atguigu.hibernate.entities.n21.both;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.After;import org.junit.Before;import org.junit.Test;public class HibernateTest {private SessionFactory sessionFactory;private Session session;private Transaction transaction;@Beforepublic void init(){Configuration configuration = new Configuration().configure();ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())                            .buildServiceRegistry();sessionFactory = configuration.buildSessionFactory(serviceRegistry);session = sessionFactory.openSession();transaction = session.beginTransaction();}@Afterpublic void destroy(){transaction.commit();session.close();sessionFactory.close();}@Testpublic void testCascade(){Customer customer = (Customer) session.get(Customer.class, 3);customer.getOrders().clear();}@Testpublic void testDelete(){//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象Customer customer = (Customer) session.get(Customer.class, 1);session.delete(customer); }@Testpublic void testUpdat2(){Customer customer = (Customer) session.get(Customer.class, 1);customer.getOrders().iterator().next().setOrderName("GGG"); }@Testpublic void testUpdate(){Order order = (Order) session.get(Order.class, 1);order.getCustomer().setCustomerName("AAA");}@Testpublic void testOne2ManyGet(){//1. 对 n 的一端的集合使用延迟加载Customer customer = (Customer) session.get(Customer.class, 7);System.out.println(customer.getCustomerName()); //2. 返回的多的一端的集合时 Hibernate 内置的集合类型. //该类型具有延迟加载和存放代理对象的功能. System.out.println(customer.getOrders().getClass()); //session.close();//3. 可能会抛出 LazyInitializationException 异常 System.out.println(customer.getOrders().size()); //4. 再需要使用集合中元素的时候进行初始化. }@Testpublic void testMany2OneGet(){//1. 若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象. 而没有查询关联的//1 的那一端的对象!Order order = (Order) session.get(Order.class, 1);System.out.println(order.getOrderName()); System.out.println(order.getCustomer().getClass().getName());session.close();//2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句. Customer customer = order.getCustomer();System.out.println(customer.getCustomerName()); //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, //若此时 session 已被关闭, 则默认情况下//会发生 LazyInitializationException 异常//4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!}@Testpublic void testMany2OneSave(){Customer customer = new Customer();customer.setCustomerName("AA");Order order1 = new Order();order1.setOrderName("ORDER-1");Order order2 = new Order();order2.setOrderName("ORDER-2");//设定关联关系order1.setCustomer(customer);order2.setCustomer(customer);customer.getOrders().add(order1);customer.getOrders().add(order2);//执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT, 2 条 UPDATE//因为 1 的一端和 n 的一端都维护关联关系. 所以会多出 UPDATE//可以在 1 的一端的 set 节点指定 inverse=true, 来使 1 的一端放弃维护关联关系!//建议设定 set 的 inverse=true, 建议先插入 1 的一端, 后插入多的一端//好处是不会多出 UPDATE 语句session.save(customer);//session.save(order1);//session.save(order2);//先插入 Order, 再插入 Cusomer, 3 条 INSERT, 4 条 UPDATE//session.save(order1);//session.save(order2);////session.save(customer);}}

3、Order.java

package com.atguigu.hibernate.entities.n21.both;public class Order {private Integer orderId;private String orderName;private Customer customer;public Integer getOrderId() {return orderId;}public void setOrderId(Integer orderId) {this.orderId = orderId;}public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}public Customer getCustomer() {return customer;}public void setCustomer(Customer customer) {this.customer = customer;}}

4、Customer.hbm.xml

<?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="com.atguigu.hibernate.entities.n21.both">        <class name="Customer" table="CUSTOMERS">            <id name="customerId" type="java.lang.Integer">            <column name="CUSTOMER_ID" />            <generator class="native" />        </id>            <property name="customerName" type="java.lang.String">            <column name="CUSTOMER_NAME" />        </property>                <!-- 映射 1 对多的那个集合属性 -->        <!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">        <!-- 执行多的表中的外键列的名字 -->        <key column="CUSTOMER_ID"></key>        <!-- 指定映射类型 -->        <one-to-many class="Order"/>        </set>            </class>    </hibernate-mapping>

5、Order.hbm.xml

<?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="com.atguigu.hibernate.entities.n21.both">    <class name="Order" table="ORDERS">        <id name="orderId" type="java.lang.Integer">            <column name="ORDER_ID" />            <generator class="native" />        </id>                <property name="orderName" type="java.lang.String">            <column name="ORDER_NAME" />        </property>        <!-- 映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 name: 多这一端关联的一那一端的属性的名字class: 一那一端的属性对应的类名column: 一那一端在多的一端对应的数据表中的外键的名字--><many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>    </class></hibernate-mapping>