<hibernate-mapping package="com.alice.hibernate03.vo">

     <class name="Address" table="t_address">

        <id name="id" column="id">

           <generator class="native"></generator>

        </id>

        <property name="name" column="name" type="string"></property>

        <!-- 一对一：特殊的多对一，使用外键的方式 -->

        <many-to-one name="company" class="Company" column="cid" update="true"></many-to-one>

     </class>

</hibernate-mapping>

<hibernate-mapping package="com.alice.hibernate03.vo">

     <class name="Company" table="t_company">

        <id name="id" column="id">

           <generator class="native"></generator>

        </id>

        <property name="name" column="name" type="string"></property>

        <!-- 一对一关系 -->

        <one-to-one name="address" class="Address" property-ref="company"></one-to-one>

     </class>

</hibernate-mapping>

package com.alice.hibernate03.one;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;

import com.alice.hibernate03.util.HibernateUtil;

import com.alice.hibernate03.vo.Address;

import com.alice.hibernate03.vo.Company;

public class OneTest {

    @Test

	public void test01(){

    	Session session = HibernateUtil.openSession();

    	Transaction tran = session.beginTransaction();

    	Company company = new Company();

    	company.setName("西电");

    	Address address = new Address();

    	address.setName("雁塔区");

        //注意，在一对一使用外键时，外键所在对象才能维护关系，另一方无法维护

    	address.setCompany(company);

    	session.save(company);

    	session.save(address);

    	tran.commit();

    	session.close();

    }

    @Test

    public void test02(){

    	Session session = HibernateUtil.openSession();

    	Transaction tran = session.beginTransaction();

    	Company company = (Company) session.get(Company.class, 1);

    	System.out.println(company);

    	tran.commit();

    	session.close();

    }

}

 <class name="Address" table="t_address">

        <id name="id" column="id">

           <!-- foreign: 该主键既是主键又是外键 -->

           <generator class="foreign">

              <!-- 作为外键时引用哪个属性 -->

              <param name="property">company</param>

           </generator>

        </id>

        <property name="name" column="name" type="string"></property>

       <!-- 配置一对一关系 -->

        <one-to-one name="company" class="Company" constrained="true"></one-to-one>

 <class name="Company" table="t_company">

        <id name="id" column="id">

           <generator class="native"></generator>

        </id>

        <property name="name" column="name" type="string"></property>

        <!-- 配置一对一

		one-to-one : 默认使用主键同步策略完成一对一的表关系体现.

		cascade:

		fetch:

		lazy:

		 -->

        <one-to-one name="address" class="Address"></one-to-one>

     </class>

<!-- 配置使用二级缓存 -->

    <property name="hibernate.cache.use_second_level_cache">true</property>

    <!--配置二级缓存的实现类 : EHCache -->

    <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

    <!-- 开启查询缓存  hibernate.cache.use_query_cache true -->

    <property name="hibernate.cache.use_query_cache">true</property>

    <!-- 引入ORM 映射文件 ，填写src之后的路径 -->

    <mapping resource="com/alice/hibernate02/vo/User.hbm.xml" />

    <mapping resource="com/alice/hibernate02/vo/Customer.hbm.xml" />

    <mapping resource="com/alice/hibernate02/vo/Order.hbm.xml" />

    <!-- 配置类缓存区中,缓存哪个类-->

    <class-cache usage="read-only" class="com.alice.hibernate02.vo.Customer"/>

    <class-cache usage="read-only" class="com.alice.hibernate02.vo.Order"/>

    <!-- 配置类缓存区中,缓存哪个集合

    collection: 完整类名.集合属性名

    -->

    <collection-cache usage="read-only" collection="com.alice.hibernate02.vo.Customer.orders"/>

//演示:类缓存

	@Test

	public void test01(){

		Session session = HibernateUtil.openSession();

		Transaction tran = session.beginTransaction();

		Customer cus1 = (Customer) session.get(Customer.class, 6);

		//清空一级缓存中的内容

		session.clear();

		Customer cus2 = (Customer) session.get(Customer.class, 6);

		//二级缓存在缓存数据时,并不是以对象的形式缓存. 缓存的是对象数据的散列. 每次从二级缓存拿 会在一级缓存中组装成对象.

		System.out.println(cus1 == cus2);//true

		tran.commit();

		session.close();

	}

package com.alice.hibernate02.second;

import java.util.List;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.Transaction;

import org.junit.Test;

import com.alice.hibernate02.util.HibernateUtil;

import com.alice.hibernate02.vo.Customer;

public class Demo02 {

    @Test

    public void test01(){

        Session session = HibernateUtil.openSession();

        Transaction tran = session.beginTransaction();

        //使用二级(查询)缓存

         // 查询时,会先从二级缓存中取结果.

         // 取不到就执行语句,将结果放入二级查询缓存中

        Query query1 = session.createQuery("from Customer");

        query1.setCacheable(true);

        List<Customer> list1 = query1.list();

        session.clear();

        Query query2 = session.createQuery("select c from Customer c");

        query2.setCacheable(true);

        List<Customer> list2 = query2.list();

        for(Customer c:list2){

            System.out.println(c);

        }

        tran.commit();

        session.close();

    }

}

//演示:时间戳

public class Demo03 {

	@Test

	public void test01() {

		Session session = HibernateUtil.openSession();

		Transaction tran = session.beginTransaction();

		Customer cus1 = (Customer) session.get(Customer.class, 6);

		session.createQuery("update Customer set name=:name where id = :id")

				.setString("name", "roese").setInteger("id", 6).executeUpdate();

		session.clear();

		Customer cus2 = (Customer) session.get(Customer.class, 6);

		tran.commit();

		session.close();

	}

}