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.ConsoleAppenderlog4j.appender.stdout.Target=System.outlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.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;@Entitypublic class Person {private int id;private String name;private IdCard idCard;@Id@GeneratedValuepublic 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;@Idpublic int getNum() {return num;}public void setNum(int num) {this.num = num;}@Idpublic 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;@Entitypublic class Husband {private int id;private String name;private int age;private Wife wife;@Id@GeneratedValuepublic 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;@Entitypublic class Wife {private int id;private int num;private String name;private Husband husband;@Id@GeneratedValuepublic 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;}@Transientpublic 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@GeneratedValuepublic 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;@Entitypublic class Car {private int id;private String name;private Type type;@Id@GeneratedValuepublic 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;@Entitypublic class Type {private int id;private String name;private Set<Car> cars;@Id@GeneratedValuepublic 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;@Entitypublic class Man {private int id;private String name;private Set<Women> womens;@Id@GeneratedValuepublic 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;@Entitypublic class Women {private int id;private String name;private Set<Man> mans;@Id@GeneratedValuepublic 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> <mappingclass="com.one.to.one.bean.Person"/> <mappingclass="com.one.to.one.bean.IdCard"/> <mappingclass="com.many.to.one.bean.Ogroup"/> <mappingclass="com.many.to.one.bean.Owner"/> <mappingclass="com.many.to.many.bean.Man" /> <mappingclass="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 blocke.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);