摘要：查詢照樣寫就行，如下參考問題七中關(guān)于多表連接查詢和返回值集合中對象問題錯誤的查詢語句釋放分析原來是查詢出來的字段并不能自動轉(zhuǎn)換為對象。參考問題八原因原生的語句中返回值為，而語句中的返回值位型的，網(wǎng)上說的主要是兼容而做的。

首先奉上
Hibernate3.2 API地址：http://docs.jboss.org/hiberna...
Hibernate4.3 API地址：http://docs.jboss.org/hiberna...
Hibernate 4.3文檔：http://hibernate.org/orm/docu...

情景0：請設(shè)置OpenSessionInViewFilter

情景1：在service外使用了dao.getSession()從而導(dǎo)致問題。

解決思路：
其實我的Service層是加了@Transactional注解的，但是由于某些原因，在service外使用了dao.getSession()從而導(dǎo)致該問題。
問題代碼如下：(這段代碼沒有放在被@Transactional注解的Serivce層，從而導(dǎo)致問題)

Criteria c=storeDao.getSession().createCriteria(Store.class).add(Restrictions.or(Restrictions.isNull("mainImgJson"),Restrictions.isNull("introImgJson")));
c.createAlias("terrace", "terrace").add(Restrictions.eq("terrace.keyId", "1"));
c.addOrder(Order.desc("updateTime"));
Page page=storeManager.findPage(c, 1, 100);

解決方法就是在這段代碼調(diào)用方法上加上@Transactional注解。
參考：http://stackoverflow.com/ques...
當然此處更好的辦法是采用DetachedCriteria

情景2：Service[抽象]父類數(shù)據(jù)庫方法沒有加@Transactional
假設(shè)有以下類：

@Transactional
public class SubClass extends SuperClass {

    public void loadDb(){
//數(shù)據(jù)庫操作
    }

}
public class SuperClass {

    public void savedb() {
//數(shù)據(jù)庫操作
    }
}

savedb是父類的方法，loadDb是子類的方法。如果有以下調(diào)用：

@Test
public void test(){
    SubClass o = new SubClass();
    o.savedb();//將會報沒有Session的錯誤
    o.loadDb();//正常
}

解決方法：在父類中標注@Transactional（父類是抽象類也可以）：

@Transactional
public class SuperClass {

    public void savedb() {

    }
}

參考：http://www.cnblogs.com/xiefei...

情景3：其他場景終極解決方案：

有可能是在非請求線程(請求線程有openssessioninviewfilter把控)某些查詢延遲加載導(dǎo)致的.
對于這種情形，
第一：你可以設(shè)置lazy=false,不過很多情況下不現(xiàn)實;
第二：對于需要后續(xù)的數(shù)據(jù)，查詢出來之后立即get()，或者size()，這樣就能觸發(fā)查詢。還可以使用Hibernate.initialize方法

在使用hibernate進行持久化時，有時需要動態(tài)的改變對象的加載，比如在編輯頁面里面lazy=true,而在瀏覽頁面lazy＝false,這樣可以在需要lazy的地方才進行控制。而配置文件中Lazy屬性是全局控制的，如何處理呢？
　　當元素或者元素的lazy屬性為true時，load() or get() or
find()加載這些對象時，Hibernate不會馬上產(chǎn)生任何select語句，只是產(chǎn)生一個Obj代理類實例，只有在session沒有關(guān)閉的情況下運行Obj.getXxx()時才會執(zhí)行select語句從數(shù)據(jù)庫加載對象，如果沒有運行任何Obj.getXxx()方法，而session已經(jīng)關(guān)閉，Obj已成游離狀態(tài)，此時再運行Obj.getXxx()方法，Hibernate就會拋出"Could
not initialize proxy - the owning Session was
closeed"的異常，是說Obj代理類實例無法被初始化。然而想在Session關(guān)閉之前不調(diào)用Obj.getXxx()方法而關(guān)閉Session之后又要用，此時只要在Session關(guān)閉之前調(diào)用Hibernate.initialize(Obj)或者Hibernate.initialize(Obj.getXxx())即可，net.sf.hibernate.Hibernate類的initialize()靜態(tài)方法用于在Session范圍內(nèi)顯示初始化代理類實例。
　　在配置文件里面可以用lazy=true，在程序里面可以用強制加載的方法Hibernate.initialize(Object
proxy) 方法強制加載這樣就相當于動態(tài)改變?yōu)閘azy=false。 
　　但在使用時需要注意的一點是：其中的proxy是持久對象的關(guān)聯(lián)對象屬性，比如A實體，你要把A的關(guān)聯(lián)實體B也檢出，則要寫Hibernate.initialize(a.b)。

Hibernate 4.2之后，你還可以配置hibernate.enable_lazy_load_no_trans：
hibernate.xml:
true

Sinche Hibernate 4.2 you can use
.setProperty("hibernate.enable_lazy_load_no_trans", "true"); this
option solves the dreaded org.hibernate.LazyInitializationException:
could not initialize proxy - no Session which took so many hours of
life to programmers away.

具體可以看https://docs.jboss.org/hibern...

對于使用HQL的童鞋，可以顯式join fetch

Query query = session.createQuery(
    "from Model m " +
    "join fetch m.modelType " +
    "where modelGroup.id = :modelGroupId"
);

第三：查詢時動態(tài)設(shè)置立即join，比如

crit.setFetchMode("pays", FetchMode.JOIN);
crit.setFetchMode("ville", FetchMode.JOIN);
crit.setFetchMode("distination", FetchMode.JOIN);

第三部分總結(jié)：

0、在場景為Request請求線程時，配置Open Session in View 具體原理，請看https://vladmihalcea.com/2016...
1、使用HQL時可以join fetch (推薦);或者你也可以用uniqueResult()方法，該方法會立即查出關(guān)聯(lián)對象。
2、使用criteria時可以FetchMode.JOIN
3、顯式調(diào)用Hibernate.initialize(obj),Hibernate.initialize(obj.getXXX())
4、配置hibernate.enable_lazy_load_no_trans：(使用時請注意開銷)

hibernate.xml:
true
 persistence.xml:

解釋請參考：https://vladmihalcea.com/2016...
但是，使用hibernate.enable_lazy_load_no_trans配置時，你需要注意下面這一點：

Behind the scenes, a temporary Session is opened just for initializing
every post association. Every temporary Session implies acquiring a
new database connection, as well as a new database transaction.
The more association being loaded lazily, the more additional
connections are going to be requested which puts pressure on the
underlying connection pool. Each association being loaded in a new
transaction, the transaction log is forced to flush after each
association initialization

翻譯一下就是：這種情形下，每次初始化一個實體的關(guān)聯(lián)就會創(chuàng)建一個臨時的session來加載，每個臨時的session都會獲取一個臨時的數(shù)據(jù)庫連接，開啟一個新的事物。這就導(dǎo)致對底層連接池壓力很大，而且事物日志也會被每次flush.
設(shè)想一下：假如我們查詢了一個分頁list每次查出1000條，這個實體有三個lazy關(guān)聯(lián)對象,那么，恭喜你，你至少需要創(chuàng)建3000個臨時session+connection+transaction.

5、使用 DTO projection (推薦):解釋請參考https://vladmihalcea.com/2016...
其實就是定義一個多帶帶的DTO來保存查詢結(jié)果。

public class PostCommentDTO {
    private final Long id;
 
    private final String review;
 
    private final String title;
 
    public PostCommentDTO(
        Long id, String review, String title) {
        this.id = id;
        this.review = review;
        this.title = title;
    }
 
    public Long getId() {
        return id;
    }
 
    public String getReview() {
        return review;
    }
 
    public String getTitle() {
        return title;
    }
}

List comments = doInJPA(entityManager -> {
    return entityManager.createQuery(
        "select new " +
        "   com.vladmihalcea.book.hpjp.hibernate.fetching.PostCommentDTO(" +
        "       pc.id, pc.review, p.title" +
        "   ) " +
        "from PostComment pc " +
        "join pc.post p " +
        "where pc.review = :review", PostCommentDTO.class)
    .setParameter("review", review)
    .getResultList();
});
 
for(PostCommentDTO comment : comments) {
    LOGGER.info("The post title is "{}"", comment.getTitle());
}

參考：http://stackoverflow.com/ques...

第四：如果由于某些要求，你不能按以上操作進行：那么請看終極解決方案：

/**
 * 由于在http請求線程之外,openssessioninviewfilter不起作用，導(dǎo)致線程沒有綁定session，這個類就是為了解決此問題。
 * 自己管理Hibernate Session的Runnable。
 * @author taojw
 */
public abstract class TxSessionRunnable implements Runnable {
    @Override
    public final void run(){
        SessionFactory sessionFactory = (SessionFactory)SpringContextHolder.getApplicationContext().getBean("sessionFactory");  
        boolean participate = bindHibernateSessionToThread(sessionFactory); 
        try{
            execute();
        }finally{
            closeHibernateSessionFromThread(participate, sessionFactory);
        }
    }
    public void execute(){
        
    }
    public static boolean bindHibernateSessionToThread(SessionFactory sessionFactory) {  
        if (TransactionSynchronizationManager.hasResource(sessionFactory)) {  
            // Do not modify the Session: just set the participate flag.  
            return true;  
        } else {  
            Session session = sessionFactory.openSession();  
            session.setFlushMode(FlushMode.MANUAL);  
            SessionHolder sessionHolder = new SessionHolder(session);  
            TransactionSynchronizationManager.bindResource(sessionFactory, sessionHolder);  
        }  
        return false;  
    }  
    public static void closeHibernateSessionFromThread(boolean participate, Object sessionFactory) {  
        if (!participate) {  
            SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.unbindResource(sessionFactory);  
            SessionFactoryUtils.closeSession(sessionHolder.getSession());  
        }  
    }

}

參考
http://stackoverflow.com/ques...
http://blog.csdn.net/zhengwei...
http://stackoverflow.com/ques...

可以不可以先獲取一個延遲加載的對象，不立即調(diào)用Hibernate.initialize,而關(guān)閉session，然后在需要的時候，打開另外一個session，調(diào)用Hibernate.initialize來初始化延遲的對象呢？
答案是否定的。不可以！
參考：https://stackoverflow.com/que...
Entity objects are pretty much "bound" to original session where they were fetched and queries like this cannot be performed in this way. One solution is to bound entity to new session calling session.update(entity) and than this new session knows about entity. Basically new query is issued to populate entity fields again.
So avoid this if not necessary and try to fetch all needed data in original session
或者你也可以通過獲取主鍵去再次主動查詢關(guān)聯(lián)對象

產(chǎn)生此問題的原因:
有兩張表,table1和table2.產(chǎn)生此問題的原因就是table1里做了關(guān)聯(lián)或者(特殊的多對一映射,實際就是一對一)來關(guān)聯(lián)table2.當hibernate查找的時候,table2里的數(shù)據(jù)沒有與table1相匹配的,這樣就會報No row with the given identifier exists這個錯.
注解配置解決方法：
使用hibernate 注解配置實體類的關(guān)聯(lián)關(guān)系，在many-to-one,one-to-one關(guān)聯(lián)中，一邊引用自另一邊的屬性，如果屬性值為某某的數(shù)據(jù)在數(shù)據(jù)庫不存在了，hibernate默認會拋出異常。解決此問題，加上如下注解就可以了：
@NotFound(action=NotFoundAction.IGNORE)，意思是找不到引用的外鍵數(shù)據(jù)時忽略，NotFound默認是exception

@ManyToOne(fetch = FetchType.LAZY)    
    @JoinColumn(name = "ICT_BASE_ID", referencedColumnName = "ID", unique = false, nullable = false, insertable = false, updatable = false)    
    @NotFound(action=NotFoundAction.IGNORE)    
    public IctBase getIctBase() {    
        return ictBase;    
    }

參考：http://blog.csdn.net/h3960710...
http://www.cnblogs.com/rixian...

Hibernate4.3之后，我們可以直接使用JPA注解："@CreationTimestamp" and "@UpdateTimestamp"

protected Date insertTime;
    protected Date updateTime;
    
    @Temporal(TemporalType.TIMESTAMP)
    @Column(updatable = false)  
    @CreationTimestamp
    public Date getInsertTime() {
        return insertTime;
    }
    public void setInsertTime(Date insertTime) {
        this.insertTime = insertTime;
    }
    @UpdateTimestamp
    @Temporal(TemporalType.TIMESTAMP)
    public Date getUpdateTime() {
        return updateTime;
    }
    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

如果使用之前版本，那么你可以給dao封裝一個save方法，并規(guī)定inserttime,updatetime字段名。統(tǒng)一處理即可。

參考：http://stackoverflow.com/ques...
http://stackoverflow.com/ques...

hibernate的速度性能并不差，當然了這和應(yīng)用的數(shù)據(jù)庫有關(guān)，在Oracle上,hibernate支持 hibernate.jdbc.fetch_size和 hibernate.jdbc.batch_size，而MySQL卻不支持，而我原來的項目絕大多數(shù)都是使用MySQL的，所以覺得速度慢，其實在企業(yè)級應(yīng)用，尤其是金融系統(tǒng)大型應(yīng)用上，使用Oracle比較多，相對來說，hibernate會提升系統(tǒng)很多性能的。
hibernate.jdbc.fetch_size 50 //讀
hibernate.jdbc.batch_size 30 //寫
hiberante.cfg.xml(Oracle ,sql server 支持，mysql不支持）

50
30

這兩個選項非常非常非常重要?。?！將嚴重影響Hibernate的CRUD性能!
Fetch Size 是設(shè)定JDBC的Statement讀取數(shù)據(jù)的時候每次從數(shù)據(jù)庫中取出的記錄條數(shù)。
例如一次查詢1萬條記錄，對于Oracle的JDBC驅(qū)動來說，是不會1次性把1萬條取出來的，而只會取出Fetch Size條數(shù)，當紀錄集遍歷完了這些記錄以后，再去數(shù)據(jù)庫取Fetch Size條數(shù)據(jù)。
因此大大節(jié)省了無謂的內(nèi)存消耗。當然Fetch Size設(shè)的越大，讀數(shù)據(jù)庫的次數(shù)越少，速度越快；Fetch Size越小，讀數(shù)據(jù)庫的次數(shù)越多，速度越慢。 但內(nèi)存消耗正好相反
建議使用Oracle的一定要將Fetch Size設(shè)到50。
不過并不是所有的數(shù)據(jù)庫都支持Fetch Size特性，例如MySQL就不支持。

Batch Size是設(shè)定對數(shù)據(jù)庫進行批量刪除，批量更新和批量插入的時候的批次大小，有點相當于設(shè)置Buffer緩沖區(qū)大小的意思。
Batch Size越大，批量操作的向數(shù)據(jù)庫發(fā)送sql的次數(shù)越少，速度就越快。！

參考：http://blog.csdn.net/rick_123...

比如

@Table(
   name = "product_serial_group_mask", 
   uniqueConstraints = {@UniqueConstraint(columnNames = {"mask", "group"})}
)

And

@Column(unique = true)
@ManyToOne(optional = false, fetch = FetchType.EAGER)
private ProductSerialMask mask;

@Column(unique = true)
@ManyToOne(optional = false, fetch = FetchType.EAGER)
private Group group;

區(qū)別在哪里？

前者是聯(lián)合約束、后者分別是獨立約束。

參考：http://stackoverflow.com/ques...

比如多對多時，Book有個Set類型屬性，Author有個Set的屬性。其實你不用管authors是Set類型。查詢照樣寫就行，如下：

select a.firstName, a.lastName from Book b join b.authors a where b.id = :id

參考：http://stackoverflow.com/ques...
http://www.cnblogs.com/kingxi...

錯誤的查詢語句：

String sql = "select a.* from tb_doc_catalog a where a.cat_code like ""+catCode+"%"";
Session session = this.getSession();
try {
List catNameList = session.createSQLQuery(sql).list();
return catNameList ;
} finally {
releaseSession(session); //釋放session
}

分析：原來是查詢出來的字段并不能自動轉(zhuǎn)換為bean對象。

解決思路一（采用hql查詢）：

String sql = "select a from DocCatalogInfo a where a.catCode like ""+catCode+"%"";
List catNameList =getHibernateTemplate().find(sql);
return catNameList ;

ok，測試一下沒問題。

解決思路二（采用原生sql查詢）：

String sql = "select a.* from tb_doc_catalog a where a.cat_code like ""+catCode+"%"";
Session session = this.getSession();
try {
List catNameList = session.createSQLQuery(sql).addEntity(DocCatalogInfo.class).list();
return catNameList ;
} finally {
releaseSession(session); //釋放session
}

ok。

hibernate 中createQuery與createSQLQuery兩者區(qū)別是：
前者用的hql語句進行查詢，后者可以用sql語句查詢
前者以hibernate生成的Bean為對象裝入list返回 ，后者則是以對象數(shù)組進行存儲

其實，createSQLQuery有一個addEntity方法可以直接轉(zhuǎn)換對象

Query query = session.createSQLQuery(sql).addEntity(XXXXXXX.class);

對于連接了多個表的查詢，可能在多個表中出現(xiàn)同樣名字的字段。下面的方法就可以避免字段名重復(fù)的問題:

List cats = sess.createSQLQuery( " select {cat.*} from cats cat " ).addEntity( " cat " , Cat. class ).list(); 

addEntity()方法將SQL表的別名和實體類聯(lián)系起來，并且確定查詢結(jié)果集的形態(tài)。
addJoin()方法可以被用于載入其他的實體和集合的關(guān)聯(lián).

List cats = sess.createSQLQuery(
" select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id " )
.addEntity( " cat " , Cat. class )
.addJoin( " kitten " , " cat.kittens " )
.list(); 

原生的SQL查詢可能返回一個簡單的標量值或者一個標量和實體的結(jié)合體。

Double max = (Double) sess.createSQLQuery( " select max(cat.weight) as maxWeight from cats cat " )
.addScalar( " maxWeight " , Hibernate.DOUBLE);
.uniqueResult(); 

命名SQL查詢
@NamedQuery("persons")

List people = sess.getNamedQuery( "persons" ).setString( " namePattern " , namePattern)
.setMaxResults( 50 )
.list(); 

返回一個Map對象，代碼如下

Query query = session.createSQLQuery("select id,name from Tree t where pid in (select id from Tree) ").setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP); //返回一個map,KEY:為DB中名稱一致（大小寫一致）遍歷list時就可以
Map map = (Map)list.get[i];

map.get("id");map.get("name");來取值。按你的SQL語句select后的字段名來作為map的Key，但這個key必須與數(shù)據(jù)庫中的字段名一模一樣。

參考：http://blog.csdn.net/stonejon...

Query query1 = session.createSQLQuery("select count(*) from user u where u.name like ? ").setParameter(0, "%lis%") ;

Query query2 = session.createQuery("select count(*) from User ") ;

Sysstem.out.println((Long) query1.list().get(0)) ; //wrong
Sysstem.out.println((Long) query2.list().get(0)) ; //right

原因：原生的SQL語句中count()返回值為BigInteger，而HQL語句中的count()返回值位Long型的，網(wǎng)上說的主要是兼容JPA而做的。
當使用createSQLQuery時，其返回值為BigInteger類型；
當使用createQuery時，其返回值位Long型的。
解決：

public long getMusicCount(long id){
        String sql="select count(1) from music_singer_music where mid=?";
        Object obj=dao.getSession().createSQLQuery(sql).setParameter(0, id).uniqueResult();
        if(obj instanceof Long){
            return (Long)obj;
        }else if(obj instanceof BigInteger){
            return ((BigInteger)obj).longValue();
        }
        return 0;
    }

參考：http://blog.csdn.net/u0137625...

清空緩存

當調(diào)用session.evict(customer); 或者session.clear(); 或者session.close()方法時，Session的緩存被清空。

清理緩存

Session具有一個緩存，位于緩存中的對象處于持久化狀態(tài)，它和數(shù)據(jù)庫中的相關(guān)記錄對應(yīng)，Session能夠在某些時間點，按照緩存中持久化對象的屬性變化來同步更新數(shù)據(jù)庫，這一過程被稱為清理緩存。

在默認情況下，Session會在下面的時間點清理緩存。

當應(yīng)用程序調(diào)用org.hibernate.Transaction的commit()方法的時候，commit()方法先清理緩存，然后在向數(shù)據(jù)庫提交事務(wù)；

當應(yīng)用程序調(diào)用Session的list()或者iterate()時（【注】get()和load()方法不行），如果緩存中持久化對象的屬性發(fā)生了變化，就會先清理緩存，以保證查詢結(jié)果能能反映持久化對象的最新狀態(tài)；

當應(yīng)用程序顯式調(diào)用Session的flush()方法的時候。

上面第二點解釋了為什么在list()查詢是有個時候會出現(xiàn)update語句。

http://blog.csdn.net/xwz0528/...

1 getCurrentSession創(chuàng)建的session會和綁定到當前線程,而openSession每次創(chuàng)建新的session。
2 getCurrentSession創(chuàng)建的線程會在事務(wù)回滾或事物提交后自動關(guān)閉,而openSession必須手動關(guān)閉
在一個應(yīng)用程序中，如果DAO 層使用Spring 的hibernate 模板，通過Spring 來控制session 的生命周期，則首選getCurrentSession()。
在 SessionFactory 啟動的時候， Hibernate 會根據(jù)配置創(chuàng)建相應(yīng)的 CurrentSessionContext ，在 getCurrentSession() 被調(diào)用的時候，實際被執(zhí)行的方法是 CurrentSessionContext.currentSession() 。

Hibernate4之后與Spring結(jié)合需配置為

org.springframework.orm.hibernate4.SpringSessionContext

在 getCurrentSession() 被調(diào)用的時候，實際被執(zhí)行的方法是 SpringSessionContext.currentSession()

讓我設(shè)想以下情景：

Session s1=sessionFactory.openSession();
s1.beginTransaction();
Object a=s1.get(Item.class,new Long(123));
Object b=s1.get(Item.class,new Long(123));

// a==b為true，a、b指向相同的內(nèi)存地址。

s1.getTransaction.commit();
s1.close();

Session s2=sessionFactory.openSession();
s2.beginTransaction();
Object c=s2.get(Item.class,new Long(123));

//a==c返回false，a,c指向不同的內(nèi)存地址

s2.getTransaction.commit();
s2.close();

/*現(xiàn)在a,b,c都處于脫管狀態(tài)/
Set set=new HashSet();
set.add(a);
set.add(b);
set.add(c);

/*輸出什么呢？1?,2?,3?/
System.out.println(set.size())
我們知道set是通過調(diào)用集合元素的equals方法來確保元素唯一性的。而Object的equals方法默認就是通過obj1==obj2來通過內(nèi)存地址判斷同一性。
那我們現(xiàn)在知道了把。上述會輸出2。但是我們知道這兩個元素都是代表數(shù)據(jù)褲中的同一行。所以這個時候我們就需要覆蓋equals與hashCode方法了。建議我們對所有的實體類都覆蓋這兩個方法，因為我們無法保證這種情況不會發(fā)生。

覆蓋實體類的equals方法可以選擇兩種方式：

1、通過判斷業(yè)務(wù)鍵而非數(shù)據(jù)庫主鍵的相等性。如果業(yè)務(wù)鍵是唯一的話，推薦此方式。

2、通過判斷對象的所有屬性的相等性。