(A) 配置hibernate日誌

 1、 為防止衝突，先將slf4j-nop的jar包（它也是slf的一個例項）去除

 2、 加入log4j的jar包 commons-logging-1.1.1.jar,log4j-1.2.14.jar。

 4、 src下新增log4j.properties 配置檔案

 5、 在hibernate4開始,已經繼承了註解的方式,如果是hibernate3以前的版本,就需要加入annotation的jar

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=debugg

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace
 

(B) hibernate 配置表結構

 1.一對一(包括聯合主建的生成)

package com.one.to.one.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.OneToOne;

@Entity
public class Person {
	private int id;
	private String name;
	private IdCard idCard;

	@Id
	@GeneratedValue
	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;
	}
/**
 *    
 
[email protected] 寫入引入外來鍵欄位在資料庫中的名稱,一般來說會預設給,所以寫入的時候一定要注意;
 *    3.只要是涉及了外來鍵的引入,就要配置JoinColumn;
 *    2.referencedColumnName 引用的另外一張表的列名,防止不是主建關聯的情況,還有就是聯合主建;
 */
	@OneToOne
	@JoinColumns( { 
		@JoinColumn(name = "num_id", referencedColumnName = "num"),
			@JoinColumn(name="age_id",referencedColumnName="age") })
	public IdCard getIdCard() {
		return idCard;
	}

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

}
 

package com.one.to.one.bean;


import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.OneToOne;


@Entity
@IdClass(IdCardPk.class)
public class IdCard {
private int num;
private int age;
private Person person;
@Id
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
@Id
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/**
 * 在雙向關聯中肯定有一處是寫入了mappedBy,一般是在沒有引用外來鍵即被引用的物件中寫入;
 */
@OneToOne(mappedBy="idCard")
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}


}

package com.one.to.one.bean;


import java.io.Serializable;


public class IdCardPk implements Serializable{
private int num;
private int age;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

package com.one.to.one.bean;


import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;


@Entity
public class Husband {
private int id;
private String name;
private int age;
private Wife wife;


@Id
@GeneratedValue
public int getId() {
return id;
}


public void setId(int id) {
this.id = id;
}


@Column(name = "husband_Name")
public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


@OneToOne(mappedBy = "husband", cascade = { CascadeType.ALL }, fetch = FetchType.EAGER)
public Wife getWife() {
return wife;
}


public void setWife(Wife wife) {
this.wife = wife;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


}

package com.one.to.one.bean;


import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Transient;


@Entity
public class Wife {
private int id;
private int num;
private String name;
private Husband husband;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
his.name = name;
}
@OneToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
@JoinColumn(name="husband_Id",referencedColumnName="id")
public Husband getHusband() {
return husband;
}
public void setHusband(Husband husband) {
this.husband = husband;
}
@Transient
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}


}

 2.多對一

package com.many.to.one.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;

import org.hibernate.annotations.BatchSize;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
@Entity
@BatchSize(size = 5)
@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public class Ogroup {
private int id;
private String name;
private Set<Owner> owners;
@Id
@GeneratedValue
@Column(updatable=true)
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;
}
@OneToMany(cascade={CascadeType.ALL},mappedBy="ogroup",fetch=FetchType.LAZY)
public Set<Owner> getOwners() {
	return owners;
}
public void setOwners(Set<Owner> owners) {
	this.owners = owners;
}
}

package com.many.to.one.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

import org.hibernate.annotations.BatchSize;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

/**
 * @Cache   快取的配置針對於的是load itertor get 等這些方法
 *          對於query.list()方法,要獨立的想它 ,它跟別的是不一樣的;
 */
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Owner {
private int id;
private String name;
private String despotion;
private Ogroup ogroup;
@Id
@GeneratedValue
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;
}
@Column(updatable=false)
public String getDespotion() {
    return despotion;
}
public void setDespotion(String despotion) {
    this.despotion = despotion;
}
/**
 * 1.fetch=FetchType.EAGER 立即取得關聯物件的資料庫值;
 * 2.如果是預設值,要取關聯物件的資訊,呼叫getGroup()的時候,會重新發送一條資料庫語句,前提是session沒有關閉;
 * 3.如果session關閉,想要獲取到關聯物件的值,就要寫fetch配置;
 */
@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
@JoinColumn(name="group_id")
public Ogroup getOgroup() {
    return ogroup;
}
public void setOgroup(Ogroup ogroup) {
    this.ogroup = ogroup;
}
}

package com.many.to.one.bean;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Car {
private int id;
private String name;
private Type type;
@Id
@GeneratedValue
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;
}
@ManyToOne(cascade={CascadeType.ALL})
@JoinColumn(name="car_type_Id",referencedColumnName="id")
public Type getType() {
    return type;
}
public void setType(Type type) {
    this.type = type;
}
}

package com.many.to.one.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Type {
private int id;
private String name;
private Set<Car> cars;
@Id
@GeneratedValue
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;
}
@OneToMany(mappedBy="type",cascade={CascadeType.ALL},fetch=FetchType.EAGER)
public Set<Car> getCars() {
    return cars;
}
public void setCars(Set<Car> cars) {
    this.cars = cars;
}
}

 3.多對多

package com.many.to.many.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;

@Entity
public class Man {
	private int id;
	private String name;
private Set<Women> womens;
	@Id
	@GeneratedValue
	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;
	}
	/**
	 * 1.如果兩者之間有關聯的時候,對於A B 兩個 如果預設,那麼就是兩者都要儲存一次,設定了cascade.ALL所有的dml都會設定了級連線;
	 * 2.CascadeType.ALL 任何dml;CascadeType.PERSIST 任何儲存;CascadeType.REMOVE 任何刪除時候,執行關聯;
	 * 3.cascade在Man中設定了,只對Man有用,當儲存womens的時候,相關聯的Man不會存入;
	 * [email protected] 配置中間表的資訊,name是中間表的名稱,前後分別是兩個欄位的名稱
	 * 5.women類中必須要寫(mappedBy="womens"),如果這個註解要分開寫,不能寫在配置中間表的類中.
	 */
@ManyToMany(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
@JoinTable(name="center_table",joinColumns={
			@JoinColumn(name="man_id",referencedColumnName="id")
	},inverseJoinColumns={@JoinColumn(name="women_id",referencedColumnName="id")
})
	public Set<Women> getWomens() {
		return womens;
	}

	public void setWomens(Set<Women> womens) {
		this.womens = womens;
	}
}

package com.many.to.many.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Women {
private int id;
private String name;
private Set<Man> mans;
@Id
@GeneratedValue
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;
}
@ManyToMany(mappedBy="womens"
    ,cascade={CascadeType.ALL},fetch=FetchType.EAGER)
public Set<Man> getMans() {
    return mans;
}
public void setMans(Set<Man> mans) {
    this.mans = mans;
}
}

(C) hiberneate.cfg.xml 配置二級快取

 1.如果用ehcache這個快取類,在src下加入ehcache.xml檔案

 2.快取的具體詳解在各個class中

<?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">

	<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>
<session-factory>
	<property name="dialect">
		org.hibernate.dialect.Oracle9Dialect
	</property>
	<property name="connection.url">
		jdbc:oracle:thin:@127.0.0.1:1521:orcl
	</property>
	<property name="connection.username">new</property>
	<property name="connection.password">sa</property>
	<property name="connection.driver_class">
		oracle.jdbc.OracleDriver
	</property>
	<property name="myeclipse.connection.profile">orcl</property>
	<property name="hibernate.show_sql">true</property>
	<property name="hibernate.format_sql">true</property>
	<property name="hbm2ddl.auto">update</property>
	<!--
		<property name="hbm2ddl.auto">create</property> <mapping
		class="com.one.to.one.bean.Person"/> <mapping
		class="com.one.to.one.bean.IdCard"/> <mapping
		class="com.many.to.one.bean.Ogroup"/> <mapping
		class="com.many.to.one.bean.Owner"/> <mapping
		class="com.many.to.many.bean.Man" /> <mapping
		class="com.many.to.many.bean.Women" /> 
		<mapping class="com.one.to.one.bean.Husband" />
		<mapping class="com.one.to.one.bean.Wife" />
		<mapping class="com.many.to.one.bean.Car" />
		<mapping class="com.many.to.one.bean.Type" />
		<mapping class="com.many.to.one.bean.Ogroup" />
	    <mapping class="com.many.to.one.bean.Owner" />
	-->
	<property name="cache.provider_class">
		org.hibernate.cache.EhCacheProvider
	</property><!-- 指定cache實現類 -->
	<property name="cache.use_second_level_cache">true</property><!-- 啟用二級快取 -->
	<property name="cache.use_query_cache">true</property><!-- 啟用查詢快取 --><!-- 指定ehcache配置檔案 -->
	<property name="current_session_context_class">thread</property>
	
	<mapping class="com.many.to.one.bean.Ogroup" />
	    <mapping class="com.many.to.one.bean.Owner" />
	<mapping resource="com/one/to/one/bean/Husband.hbm.xml" />
	<mapping resource="com/one/to/one/bean/Wife.hbm.xml" />

</session-factory>

</hibernate-configuration>

(D) DAO

 1.CacheDao

package dao;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cache.EhCacheProvider;
import org.hibernate.cache.HashtableCacheProvider;
import org.hibernate.cfg.AnnotationConfiguration;

import com.many.to.one.bean.Ogroup;
import com.many.to.one.bean.Owner;
/**
 * session快取為一級快取,不同的session會重新發送hql語句;
 * SessionFactory 二級快取,跨越session存在;
 * load get itroter 等方法預設二級快取;但是也要配置;
 * query查詢方法專門開啟查詢快取,同一個q.list()兩次,並q.setCachale(true)不會重發sql;
 */
public class CacheDao {
	public void getUserTest1(Session session,Session session2){
		 session.createQuery("from Ogroup").list();
		 session2.createQuery("from Ogroup").list();
		
		 session.clear();
		 session.close();
	}
	public void getUserTest2(Session session,Session session2){
		Ogroup group = (Ogroup) session.load(Ogroup.class, 2);
		Ogroup group2 = (Ogroup) session2.load(Ogroup.class, 2);
		
		System.out.println(group.getName());
		//System.out.println(group.getOwners().size());
		System.out.println(group2.getName());
		//System.out.println(group2.getOwners().size());
	}
	public void getUserTest3(SessionFactory sf) {
		Session session = sf.openSession();
		Session session2 = sf.openSession();
		session.get(Ogroup.class, 2);
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		session2.get(Ogroup.class, 2);
	sf.close();
	}
	public void getUserTest4(SessionFactory sf){
		Session session = sf.openSession();
		Session session2 = sf.openSession();
		Query q = session.createQuery("from Ogroup");
		Query q2 = session2.createQuery("from Ogroup");
//		q.setCacheable(true);
		q.list();
		q2.list();
		
	    sf.close();
	}
	public void getUserTest5(SessionFactory sf){
		Session session = sf.openSession();
		Query q = session.createQuery("from Owner");
		q.setCacheable(true);
		q.list();
		q.list();
	    sf.close();
	}
	public static void main(String[] args) {
		AnnotationConfiguration cfg = new AnnotationConfiguration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		Session session2 = sf.openSession();
//		new CacheDao().getUserTest2(session,session2);
		new CacheDao().getUserTest5(sf);
//		new CacheDao().getUserTest1(session,session2);
	}
}

 2.Car_Type_Dao

package dao;

import java.math.BigDecimal;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.persistence.FetchType;
import javax.persistence.Query;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

import com.many.to.one.bean.Car;
import com.many.to.one.bean.Type;
import com.one.to.one.bean.Husband;
import com.one.to.one.bean.Wife;

public class Car_Type_Dao {
	public void save(Session session) {
		Car car = new Car();
		car.setName("car01");
		Car car2 = new Car();
		car2.setName("car02");
		Type type = new Type();
		type.setName("賓士007");
		car.setType(type);
		car2.setType(type);
		session.beginTransaction();
		session.save(car);	
		session.save(car2);	
//		session.save(type);
		session.getTransaction().commit();
	}

	public void getCar(Session session) {
		Type type = (Type)session.load(Type.class, 2);
		System.out.println(type.getName());
		session.close();
		System.out.println(type.getCars().size());
	}
	public void deleteCar(Session session){
		Car car = (Car)session.load(Car.class, 4);
		session.beginTransaction();
		session.delete(car);
		session.getTransaction().commit();
	}
	/**
	 * 1.session.load 資料庫檢查級聯關係,當刪除car的id是1時,關聯的type就會被刪掉,
	 * 反過來type所關聯的car又會被全部刪掉;
	 * 2.session.load 資料庫檢查級聯關係,當刪除type的時候,car也刪掉了;
	 * 2.不使用session.load的時候,就不會有級聯的關係了,直接設定了id是1,但是刪除type的時候就會報錯,
	 *    原因是沒有檢查級聯關係,就會產生異常,有外來鍵的引用關係;
	 * 3.解決的辦法是,將其中的user.setType(null)斷開級聯關係;
	 * 4.也可用hql語句來解決,hql語句是不檢查級聯關係的;
	 * 5.鐵律:hql跟sql一樣,絕不涉及級聯關係,而只要使用session的方法除delete特殊外,就會涉及級聯關係;
	 */
	public void deleteType(Session session){
		Type type = (Type)session.load(Type.class, 4);
		session.beginTransaction();
		session.delete(type);
		session.getTransaction().commit();
	}
	/**
	 * 1.hql語句的查詢,跟級聯是沒有關係的,只跟fetch=FetchType.EAGER有關係;
	 */
	public void getAllCar(Session session){
		org.hibernate.Query q = session.createQuery("from Type");
		List<Type> al =q.list();
		session.clear();
		session.close();
		for (int i = 0; i < al.size(); i++) {
			Type type = al.get(i);
			System.out.println(type.getCars().size());
		}
	}
	public static void main(String[] args) {
		AnnotationConfiguration cfg = new AnnotationConfiguration()
				.configure("hibernate.cfg.xml");
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
//		new Car_Type_Dao().save(session);
//		new Car_Type_Dao().getCar(session);
//		new Car_Type_Dao().deleteCar(session);
		new Car_Type_Dao().getAllCar(session);
		//session.close();
		sf.close();
	}
}

 3.GroupDao

package dao;

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

import javax.persistence.CascadeType;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

import com.many.to.one.bean.Ogroup;
import com.many.to.one.bean.Owner;

public class GroupDao {
	/** 沒有cascade={CascadeType.ALL},手動存如兩個物件 */
public void save(Session session){
	Ogroup ogroup = new Ogroup();
	ogroup.setName("湖北省水利廳");
	Owner user = new Owner();
	user.setName("jack");
	user.setOgroup(ogroup);
	session.beginTransaction();
	session.save(user);
	session.save(ogroup);
	session.getTransaction().commit();
}
/** 1.加入了cascade={CascadeType.ALL} 後,只存去一個物件,另外的一個物件也存入
 *  2.以存入user為主導 */
public void save2(Session session){
	Ogroup ogroup = new Ogroup();
	ogroup.setName("湖北省水利廳");
	Owner user = new Owner();
	user.setName("Jack");
	user.setOgroup(ogroup);
	
	Owner user2 = new Owner();
	user2.setName("Marry");
	user2.setOgroup(ogroup);
	session.beginTransaction();
	session.save(user);
	session.save(user2);
	//session.save(ogroup);
	session.getTransaction().commit();
}
/**
 * 1.以存入group為主導
 */
public void saveGroup(Session session){
	Ogroup ogroup = new Ogroup();
	ogroup.setName("地市州");
	Owner user = new Owner();
	user.setName("Jack2");
	user.setOgroup(ogroup);
	Owner user2 = new Owner();
	user2.setName("Marry2");
	user2.setOgroup(ogroup);
	session.beginTransaction();
	Set<Owner> st = new HashSet<Owner>();
	st.add(user);st.add(user2);
	session.save(ogroup);
	session.getTransaction().commit();
}

public void updateGroup(Session session){
	//Ogroup group = (Ogroup) session.load(Ogroup.class, 2);
	Ogroup group = new Ogroup();
	session.beginTransaction();
	group.setId(2);
	group.setName("長江委2");
	session.update(group);
	session.getTransaction().commit();
	session.close();
}
/**
 *    1.沒有load,沒有實現了級聯關係的對映,如果更新欄位,其餘的欄位會變為垃圾資料;
 *    2.load後,實現了級聯關係,關聯相關表資訊會更新;
 */
public void updateUser(Session session){
	//Owner user = (Owner)session.load(Owner.class,1);
	Owner user = new Owner();
	user.setId(1);
	user.setName("Jack2");
	session.beginTransaction();
	session.update(user);
	session.getTransaction().commit();
	session.close();
}
public void getUserTest(Session session){
	Ogroup group = (Ogroup) session.load(Ogroup.class, 2);
	Owner user = (Owner) session.get(Owner.class,3);
	System.out.println(group.getName());
	System.out.println(group.getOwners().size());
	System.out.println(user.getName());
	System.out.println(user.getOgroup().getName());
	session.clear();
	session.close();
}
/**
 * 1+N:1.session.createCriteria沒有這個問題,本身就有left join on;
 *     2.session.createQuery,查詢user時候,由於它的fetchType預設是eager,那麼在查詢user的時候;
 *       將group都取出來了,本來是一條語句,變成了N條;
 * 解決辦法:1.fetchType設為LAZY;
 *          [email protected]()在對應的N條資料庫表的類上加,(size=5),一次性去除5條;
 */
public void getUserTest2(Session session){
	List<Owner> a = session.createQuery("from Owner").list();
	session.clear();
	session.close();
}
public void getUserTest3(Session session){
	session.createCriteria(Owner.class).list();
	
	session.clear();
	session.close();
}
public static void main(String[] args) {
	AnnotationConfiguration cfg = new AnnotationConfiguration().configure();
	SessionFactory sf = cfg.buildSessionFactory();
	Session session = sf.openSession();
	new GroupDao().getUserTest3(session);
	
}
}

 4. Husband_Wife_Dao

package dao;

import javax.persistence.CascadeType;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

import com.one.to.one.bean.Husband;
import com.one.to.one.bean.Wife;

public class Husband_Wife_Dao {
	public void saveOrUpdate(Session session){
		Wife wife = new Wife();
		wife.setName("Marry_saveUpdate");
		session.beginTransaction();
		session.saveOrUpdate(wife);
		session.getTransaction().commit();
		
	}
public void save(Session session){
	Wife wife = new Wife();
	wife.setName("Marry");
	Wife wife2 = new Wife();
	wife2.setName("Marry2");
	Husband husband = new Husband();
	husband.setName("Jack");
	
	/**
	 * #如果用這兩行:1.husband.setWife(husband);
	 *              2.session.save(husband);
	 *              # 外來鍵的引用是存不進去的;
	 * #要根據資料庫表的存入順序:1.wife.setHusband(husband);
	 *                          2.session.save(wife);
	 */
	wife2.setHusband(husband);
	wife.setHusband(husband);
	session.beginTransaction();
	session.save(wife);
	session.save(wife2);
	session.getTransaction().commit();
	
}
public void getHusband(Session session){
	Husband husband=(Husband)session.get(Husband.class, 2);
	System.out.println(husband.getName());
	System.out.println(husband.getWife().getName());
}
/**
 *  (1)update更新欄位: 1.在xml配置中property 的update屬性;
 *                     2.註解方式中@cumlun(update=true);
 *            以上兩種解釋為從不更新,不靈活,不方便;
 *                 3.xml配置中 在clsss標籤中寫dynamic—update='true',表示沒有更改的記錄就不會更新;
 *                 4.在自身的試驗中,發現3.0的hibernate註解中預設就是第三種情況.不用自己去設定;
 *  (2)update級聯更新: 1.CascadeType.ALL任何操作級聯都更新;
 *                    2.CascadeType.merig的時候,使用session.merig方法才會更新級聯;
 *                    3.更新和delete一樣,如果不使用session.load實現級聯查詢,變不會更新級聯;
 */
public void updateHusband(Session session){
	Husband husband=(Husband)session.get(Husband.class, 2);
	husband.setAge(4);
	husband.getWife().setName("Marry");
	session.beginTransaction();
	session.update(husband);
	session.getTransaction().commit();
	
}
public void deleteWife(Session session){
	Wife wife = new Wife();
	wife.setId(21);
	session.beginTransaction();
	session.delete(wife);
	session.getTransaction().commit();
}
public static void main(String[] args) {
	AnnotationConfiguration cfg = new AnnotationConfiguration().configure("hibernate.cfg.xml");
	SessionFactory sf = cfg.buildSessionFactory();
	Session session = sf.openSession();
//	new Husband_Wife_Dao().save(session);
//	new Husband_Wife_Dao().getHusband(session);
//	new Husband_Wife_Dao().updateHusband(session);
	new Husband_Wife_Dao().deleteWife(session);
	session.close();
	sf.close();
}
}

 5.ManDao

package dao;

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

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import com.many.to.many.bean.Man;
import com.many.to.many.bean.Women;

public class ManDao {
	/**
	 * save2 方法在cascade預設不寫的情況下,手動存入兩個變數;
	 * @param session
	 */
	public void save2(Session session) {
		Women womens = new Women();
		womens.setName("Marry");
		Women womens2 = new Women();
//		womens2.setId(2);
		womens2.setName("Marry2");
		Man man = new Man();
		man.setName("Jack");
		Set<Women> st = new HashSet<Women>();
		st.add(womens);
		st.add(womens2);
		man.setWomens(st);
		Transaction tc = session.beginTransaction();
		session.save(man);
		session.save(womens);
		session.save(womens2);
		session.getTransaction().commit();
		session.close();
	}
	
	
	public void save(Session session) {
		Women womens = new Women();
		womens.setName("Marry");
		Women womens2 = new Women();
		womens2.setName("Marry2");
		Man man = new Man();
		man.setName("Jack");
		Set<Women> st = new HashSet<Women>();
		st.add(womens);
		st.add(womens2);
		man.setWomens(st);
		Transaction tc = session.beginTransaction();
//		session.save(womens);
//		session.save(womens2);
		session.save(man);
		session.getTransaction().commit();
	}
	public void getWomens(Session session) {
		Women women = (Women)session.load(Women.class, 8);
		session.clear();
		System.out.println(women.getName());
		System.out.println(women.getMans().size());
		
	}
	public static void main(String[] args) {
		AnnotationConfiguration cfg = new AnnotationConfiguration().configure();
		SessionFactory sf = cfg.buildSessionFactory();
		Session session = sf.openSession();
		new ManDao().getWomens(session);
	}
}

小技巧:通過hibernate來進行插入操作的時候，不管是一對多、一對一還是多對多，都只需要記住一點，在哪個實體類聲明瞭外來鍵，就由哪個類來維護關係，在儲存資料時，總是先儲存的是沒有維護關聯關係的那一方的資料，後儲存維護了關聯關係的那一方的資料，如：

Person p = new Person();
p.setName("xiaoluo");
session.save(p);
            
IDCard card = new IDCard();
card.setNo("1111111111");
card.setPerson(p);
session.save(card);