(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.jar4、 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);