hibernate注解方式

(A) 配置hibernate日志

 1、 为防止冲突，先将slf4j-nop的jar包（它也是slf的一个实例）去除

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

 3、 加入转换包 slf4j-log4j12-1.5.10.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;
	}
/**
 *    1.@JoinColumn 写入引入外键字段在数据库中的名称,一般来说会默认给,所以写入的时候一定要注意;
 *    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不会存入;
	 * 4.@JoinTable 配置中间表的信息,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;
 *          2.@BatchSize()在对应的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);