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.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; } /** *
[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);
相關推薦
hibernate 註解方式講解映射關系
在外 entity 方便 log 建設 中間 建表 遺憾 存在 註解方式講解映射關系 1 One-To-One Unidirectional with Foreign Key 單向關聯外鍵方式。 1.1 關系如下
Spring 整合 Hibernate 註解方式
在上一篇文章中,我們建立一個簡單的Maven專案結構,並展示如何使用 Spring 和 Hibernate 框架在 MySQL資料庫進行資料處理工作(插入,選擇,更新和刪除)。在本文章中,還是學習如何使用 Spring 和 Hibernate 做同樣的事情,這一次我們使用註解
hibernate註解方式(類級別和屬性級別)
使用註解方式就是為了簡化繁瑣的ORM對映檔案的(*.hbm)檔案的配置 JPA和Hibernate的關係:JPA是標準介面,Hibernate是實現,但是其功能是JPA的超集 hibernate通過h
Hibernate註解方式對映
JPA:Java persistence APIJPA註解是JavaEE的標準和規範JPA是標準介面,Hibernate是實現,優先使用JPA註解。一:類級別註解1:@Entity對映實體類name屬性對應資料庫中的表(一般不寫通過@Table寫)注意:使用@Entity時必
hibernate 註解方式配置實體的對映
Hibernate註解1。@Entity(name="EntityName")必須,name為可選,對應資料庫中一的個表2、@Table(name="",catalog="",schema="")可選,通常和@Entity配合使用,只能標註在實體的class定義處,表示實體
hibernate註解方式
(A) 配置hibernate日誌 1、 為防止衝突,先將slf4j-nop的jar包(它也是slf的一個例項)去除 2、 加入log4j的jar包 commons-logging-1.1.1.jar,log4j-1.2.14.jar。 3、 加入轉換包 slf4j
【Hibernate學習】 —— 抓取策略(註解方式)
屬性的方法 ould per hql 項目 操作記錄 新建 應用程序 span 當應用程序須要在關聯關系間進行導航的時候。hibernate怎樣獲取關聯對象的策略。 抓取策略的方式: FetchType.LAZY:懶載入。載入一個實體時。定
2.2、Hibernate用註解方式實現一對多、多對多關系
tab 技術部 employee join incr 無法運行 hset strategy urn 一、一對多關系 1、在上一篇日誌中用.xml配置文件項目基礎上,再往lib目錄先添加一個包-hibernate-jpa-2.0-api-1.0.0.Final.jar
Hibernate 註解的方式進行查詢
Student 類 @Entity @NamedQueries(value={ **@NamedQuery**(name="first",query="from Student"), **@NamedQuery**(name
Hibernate該使用註解方式還是xml方式?
XML配置方式: 優:容易編輯,配置比較集中,方便修改,在大業務量的系統裡面,通過xml配置會方便後人理解整個系統的架構,修改之後直接重啟應用即可 缺:比較繁瑣,配置形態醜陋, 配置檔案過多的時候難以管理 註解方式: 優:方便,簡潔,配置資訊和 Java 程式碼放在一
Hibernate註解對映聯合主鍵的三種主要方式
聯合主鍵用Hibernate註解對映方式主要有三種: 第一、將聯合主鍵的欄位單獨放在一個類中,該類需要實現java.io.Serializable介面並重寫equals和hascode,再將該類註解為@Embeddable,最後在主類中(該類不包含聯合主鍵類中的欄位)儲存
Hibernate 和 JPA 註解方式自定義ID生成器
/** * Test.java * 實體類定義和配置 */ package com.saving.ecm.resource.entity; import javax.persistence.Column; import javax.persistence.Enti
Hibernate學習筆記(一)之——根據配置檔案自動建立表的兩種方式(註解方式和配置檔案方式)
環境準備:jdk eclipse hibernate、mysql jar包 專案截圖: Student是根據配置檔案建立表,Teacher是根據註解建立表 Student.java package com.java1234.model; publi
Hibernate一對一主鍵關聯(基於annotation註解方式)
hibernate中一對一的關聯有兩種方式:一種是採用外來鍵關聯,另外一種是採用主鍵關聯。 最近專案中用到一對一主鍵雙向關聯,並且是基於註解的方式。期間遇到一些問題,現在貼出來探討探討。 一個丈夫(husband)對應一個妻子(wife),主要目標是在儲存丈夫或者妻子
Hibernate的手動建表的方法【包含註解方式的手動見表】(二)
//載入配置資訊 Configuration cfg = new Configuration().configure(); //例項化SchemaExport物件 SchemaExport export = new SchemaExport(cfg);
spring boot + hibernate 多資料來源(註解方式)
一)spring boot + hibernate 多資料來源(XML) import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.En
Hibernate學習4 二級快取強化和事務管理 註解方式實現
如何證明二級快取和一級快取的物件是不一樣的? //第一次查詢 Country country = session.get(Country.class, 2);
利用hibernate反向生成entity,註解方式
hibernate整合:(如何逆向生成entity),利用Myeclipse配置框架 1:建立資料庫連線,在myeclipse中:windo->open perspec
Hibernate 多對多 中間表含有其他欄位 註解方式實現
需求: 兩個實體類:Teacher.class Student.class 中間表包含了一個額外欄位:score Teacher.calss id name 1 Mr.zhang 2 Mr.wang Student.class id name 1 Xiaoming 2 X
Hibernate基於註解方式的各種對映全面總結
1. 使用HibernateAnnotation來做物件關係對映 1) 新增必須包: hibernate-jpa-2.0-api-1.0.0.Final.jar 2)在實體類中新增JPA的標準註解來進行物件關係對映.註解可以新增在屬性上,也可以新增在getXxx