hibernatesqllike_各位大俠們hibernate怎麼完成動態生成sql語句的啊

Ⅰ hibernate 中用sql語句查詢，為什麼只能查詢一條記錄

看這代碼好像沒啥問題
資料庫中兩條記錄 content是不是裡面都是空字元串？還是其中一個為 null?
如果連空字元串都沒有，那就應該屬於null
要驗證你的SQL有沒問題
試著在資料庫中兩條數據中的content都賦上值例如一條賦 AAAAAA，另一條賦 BABABABA
然後方法中傳進的參數是A，這會應該不會只查到1條了

Ⅱ hibernate SQL 傳值問題

傳值的方式有很多種，可以換一種啊

用HQL和Criteria都可以很容易的滿足這種需求，看你上面寫的，也沒什麼特別的必要用sql-query這種形式啊

Ⅲ Hibernate 的HQL和sql有什麼區別

HQL：Hibernate Qusery Language，如果你已經熟悉它，就會發現它跟SQL非常相像。不過你不要被表面的假象迷惑，HQL是面向對象的（OO，用生命的眼光看待每一個對象，他們是如此鮮活）。如果你對JAVA和SQL語句有一定了解的話，那麼HQL對你簡直易如反掌，你完全可以利用在公車上的時間掌握它。以下從幾個方面進行慢慢深入： 1。大小些敏感
大家知道Query是對大小寫不敏感的，但是在HQL（前面提到它是OO的）中那麼對象類的名稱和屬性確實大小寫敏感的（符合java編程語法）。
如：sElect cat.name from Cat as cat和select cat.name from Cat as cat是一樣的
但是：
sElect cat.name from CAT as cat和select cat.name from Cat as cat確實不一樣的。 2。from語句
最簡單的：
from eg.Cat
它只是簡單的返回所有eg.Cat的實例
通常我們此時會為eg.Cat其個別名，因為在query的其餘部分可能會用到(參看上邊關於大小寫
敏感時的例子情形)，如：
from eg.Cat as cat 這里as可以省略。
上邊只是單表查詢，多表的情況如下寫法：
from eg.Cat,eg.Dog
from eg.Cat as cat,eg.Dog as dog 3。join相關
(inner) join
left (outer) join
right (outer) join
full join
HQL同樣對SQL中的這些特性支持
下面插播一個小話題，關於上邊的那些特性，我一直都沒怎麼用，今天既然說到這里，就想
把上邊的幾個特性的用法說一下，也算對自己的一個補充：
假設有兩個表：部門、員工，下面列舉一些數據：
員工(Employee)：
ID Name DepNo
001 Jplateau 01
002 Jony 01
003 Camel 02
部門(Department)：
ID Name
01 研發部
02 營銷部在Hibernate中我們操縱的都是對象，所以我們操縱的是部門類和員工類
1).(inner) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee join Department as department on employee.DepNo=
department.ID (注意到條件語句我用on 沒有用where)
那麼執行結果是什麼呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研發部
002 Jony 01 研發部 2).left (outer) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee left join Department as department on employee.DepNo=
department.ID
那麼執行結果又該是什麼呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研發部
002 Jony 01 研發部
003 Camel null null
{就是說此時我要已第一個表的記錄多少為准，第二個表中沒有相應紀錄的時候填充null}
3). right (outer) join
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee right join Department as department on employee.DepNo=
department.ID
那麼執行結果又該是什麼呢？
id1 name1 id2 name2
++++++++++++++++++++++++++++++++++++++
001 Jplateau 01 研發部
002 Jony 01 研發部
null null 02 營銷部
{就是說此時我要已第二個表的記錄多少為准，第一個表中沒有相應紀錄的時候填充null} 4。select語句
就是要確定你要從查詢中返回哪些對象或者哪些對象的屬性。寫幾個例子吧：
select employee form Employee as employee
select employee form Employee as employee where employee.Name like 'J%'
select employee.Name form Employee as employee where employee.Name like 'J%'
select employee.ID as id1,employee.Name as name1,department.ID as id2,department.Name
as name2 from Employee as employee right join Department as department on employee.DepNo=
department.ID select elements(employee.Name) from Employee as employee
（不明白elements到底是做什麼用的？望給於說明）
等等
5。數學函數
JDO目前好像還不支持此類特性。
avg(...), sum(...), min(...), max(...) count(*) count(...), count(distinct ...), count(all...) 其用法和SQL基本相同 select distinct employee.name from Employee as employee
select count(distinct employee.name),count(employee) from Employee as employee 6。polymorphism (暫時不知道如何解釋？)
from com.test.Animal as animal
不光得到所有Animal得實例，而且可以得到所有Animal的子類（如果我們定義了一個子類Cat）
一個比較極端的例子
from java.lang.Object as o
可以得到所有持久類的實例 7。where語句
定義查詢語句的條件，舉幾個例子吧：
from Employee as employee where employee.Name='Jplateau'
from Employee as employee where employee.Name like 'J%'
from Employee as employee where employee.Name like '%u'
在where語句中「=」不光可以比較對象的屬性，也可以比較對象，如：
select animal from com.test.Animal as animal where animal.name=dog 8。表達式在SQL語句中大部分的表達式在HQL中都可以使用：
mathematical operators +, -, *, / binary comparison operators =, >=, <=, <>, !=, like logical operations and, or, not string concatenation || SQL scalar functions like upper() and lower() Parentheses ( ) indicate grouping in, between, is null JDBC IN parameters ? named parameters :name, :start_date, :x1 （這種應該是另一種"?"的變通解決方法） SQL literals 'foo', 69, '1970-01-01 10:00:01.0' Java public static final constants eg.Color.TABBY 其他不必解釋了，在這里我只想對查詢中的參數問題說明一下：
大家知道在SQL中進行傳遞參數進行查詢的時候，我們通常用PreparedStatement，在語句中寫一大堆的「？」，
在hql中也可以用這種方法，如：
List mates = sess.find(
"select employee.name from Employee as employee " +
"where employee.Name=? ",
name,
Hibernate.STRING
);
(說明：上面利用Session里的find方法，在hibernate的api Session中重載了很多find方法，它可以滿足你多種形式的查詢)
上邊是一個參數的情形，這種情況下緊接著引入參數和定義參數的類型，當為多個參數，調用另一個find方法，它的後兩個
參數都是數組的形式。還有另外一種方法來解決上邊的問題，JDO也有這樣的方法，不過和hibernate的表現形式上有差別，但他們兩個骨子裡卻是
一樣的，如：
Query q = sess.createQuery("select employee.name from Employee as employee where employee.Name=:name");
q.setString("name", "Jplateau");
//當有多個參數的時候在此逐一定義
Iterator employees = q.iterate(); 9。order 語句
和sql語句沒什麼差別，如：
select employee.name from Employee as employee where employee.Name like 'J%' order by employee.ID desc (或者asc) 10。group by 語句
同樣和sql語句沒什麼差別，如： select employee.name,employee.DepNo from Employee as employee group by employee.DepNo select foo.id, avg( elements(foo.names) ), max( indices(foo.names) ) from eg.Foo foo group by foo.id
{Note: You may use the elements and indices constructs inside a select clause, even on databases with no subselects.}
誰幫我解釋一下上邊兩句，謝過！ 11。子查詢
hibernate同樣支持子查詢，寫幾個例子： from eg.Cat as fatcat where fatcat.weight > ( select avg(cat.weight) from eg.DomesticCat cat )

Ⅳ hibernate 中原生sql like 怎麼寫

hibernate本來就支持原sql 調用執行sql的方法就行了調用方法的時候注意看所需的參數
@Autowired
private SessionFactory sessionFactory;

sessionFactory.getCurrentSession().createSQLQuery(sql);

這樣就可以了

Ⅳ hibernate中sql原生查詢中大括弧是什麼作用

select MAX(CAST(x.serial as SIGNED))+1 as number from (select SUBSTRING(GOODS_ID,LOCATE('005001007',GOODS_ID)+LENGTH('005001007')) as serial from BUS_GOODS where ID like '%005001007%') x where x.serial <> ''

你確定這句話在mysql里能跑？裡面有兩個where啊，而且第二個where前面還有個x是要鬧哪樣？

Ⅵ hibernate中criteria查詢是用什麼設計模式實現的

要對資料庫管理系統進行操作，最基本的就是使用SQL（Standard Query Language）語句，大部份的資料庫都支援標準的SQL語句，然而也有一些特定於資料庫的SQL語句，應用程式配合SQL語句進行資料庫查詢時，若使用到特定於資料庫的SQL語句，程式本身會有相依於特定資料庫的問題。
使用Hibernate時，即使您不了解SQL的使用與撰寫，也可以使用它所提供的API來進行SQL語句查詢，org.hibernate.Criteria對SQL進行封裝，您可以從Java物件的觀點來組合各種查詢條件，由Hibernate自動為您產生SQL語句，而不用特別管理SQL與資料庫相依的問題。
以最基本的查詢來說，如果您想要查詢某個物件所對應的資料表中所有的內容，您可以如下進行查詢：
Criteria criteria = session.createCriteria(User.class);List users = criteria.list();
for(Iterator it = users.iterator(); it.hasNext(); ) {User user = (User) it.next();System.out.println(user.getId() +" \t " + user.getName() +"/" + user.getAge());}
Criteria建立後，若不給予任何的條件，預設是查詢物件所對應表格之所有資料，如果您執行以上的程式片段，並於設定檔中設定了了Hibernate的」show_sql」屬性，則可以在主控下看到以下的SQL語句之產生：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_
Criteria基本查詢條件設定
org.hibernate.Criteria實際上是個條件附加的容器，如果想要設定查詢條件，則要使用org.hibernate.criterion.Restrictions的各種靜態方法傳回org.hibernate.criterion.Criteria實例，傳回的每個org.hibernate.criterion.Criteria實例代表著一個條件，您要使用org.hibernate.Criteria的add()方法加入這些條件實例，例如查詢」age」大於20且小於40的資料：
Criteria criteria = session.createCriteria(User.class);criteria.add(Restrictions.gt("age", new Integer(20)));criteria.add(Restrictions.lt("age", new Integer(40)));List users = criteria.list();
for(Iterator it = users.iterator(); it.hasNext(); ) {User user = (User) it.next();System.out.println(user.getId() +" \t " + user.getName() +"/" + user.getAge());}
Restrictions的gt()方法表示大於（great than）的條件，而lt表示小於（less than）的條件，執行以上程式片段，觀察所產生的SQL語句，將使用where與and子句產來完成SQL的條件查詢：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.age>? and this_.age
使用add()方法加入條件時，預設是使用and來組合條件，如果要用or的方式來組合條件，則可以使用Restrictions.or()方法，例如結合age等於（eq）20或（or）age為空（isNull）的條件：
Criteria criteria = session.createCriteria(User.class);criteria.add(Restrictions.or(Restrictions.eq("age", new Integer(20)),Restrictions.isNull("age")));List users = criteria.list();
觀察所產生的SQL語句，將使用where與or子句完成SQL的條件查詢：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=? or this_.age is null)
您也可以使用Restrictions.like()方法來進行SQL中like子句的功能，例如查詢」name」中名稱為」just」開頭的資料：
Criteria criteria = session.createCriteria(User.class);criteria.add(Restrictions.like("name", "just%"));List users = criteria.list();
觀察所產生的SQL語句如下：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where this_.name like ?
Restrictions的幾個常用限定查詢方法如下表所示：
方法說明Restrictions.eq 等於Restrictions.allEq 使用Map，使用key/value進行多個等於的比對Restrictions.gt 大於 >Restrictions.ge 大於等於 >=Restrictions.lt 小於 <Restrictions.le 小於等於 <=Restrictions.between 對應SQL的BETWEEN子句Restrictions.like 對應SQL的LIKE子句Restrictions.in 對應SQL的in子句Restrictions.and and關系Restrictions.or or關系
Criteria進階查詢條件設定
使用Criteria進行查詢時，不僅僅能組合出SQL中where子句的功能，還可以組合出如排序、統計、分組等的查詢功能。
排序
您可以使用Criteria進行查詢，並使用org.hibernate.criterion.Order對結果進行排序，例如使用Oder.asc()，指定根據」age」由小到大排序（反之則使用desc()）：
Criteria criteria = session.createCriteria(User.class);criteria.addOrder(Order.asc("age"));List users = criteria.list();
注意在加入Order條件時，使用的是addOrder()方法，而不是add()方法，在產生SQL語句時，會使用order by與asc（desc）來進行排序指定：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ order by this_.age asc
限定查詢筆數
Criteria的setMaxResults()方法可以限定查詢回來的筆數，如果配合setFirstResult()設定傳回查詢結果第一筆資料的位置，就可以實現簡單的分頁，例如傳回第51筆之後的50筆資料（如果有的話）：
Criteria criteria = session.createCriteria(User.class);criteria.setFirstResult(51);criteria.setMaxResults(50);List users = criteria.list();
根據您所指定得資料庫，Hibernate將自動產生與資料庫相依的限定筆數查詢子句，例如在MySQL中，將使用limit產生以下的SQL語句：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ limit ?, ?
統計動作
您可以對查詢結果進行統計動作，使用org.hibernate.criterion.Projections的avg()、rowCount()、count()、max()、min()、 countDistinct()等方法，再搭配Criteria的setProjection()方法加入條件設定，例如對查詢結果的"age"作平均：
Criteria criteria = session.createCriteria(User.class);criteria.setProjection(Projections.avg("age"));List users = criteria.list();
上面的程式將由Hibernate自動產生SQL的avg函數進行平均計算：
Hibernate: select avg(this_.age) as y0_ from T_USER this_
分組
還可以配合Projections的groupProperty()來對結果進行分組，例如以"age"進行分組，也就是如果資料中"age"如果有 20、20、25、30，則以下會顯示20、25、30：
Criteria criteria = session.createCriteria(User.class);criteria.setProjection(Projections.groupProperty("age"));List users = criteria.list();
上面的程式將由Hibernate自動產生SQL的group by子句進行分組計算：
Hibernate: select this_.age as y0_ from T_USER this_ group by this_.age
如果想同時結合統計與分組功能，則可以使用org.hibernate.criterion.ProjectionList，例如下面的程式會計算每個年齡各有多少個人：
ProjectionList projectionList = Projections.projectionList();projectionList.add(Projections.groupProperty("age"));projectionList.add(Projections.rowCount());
Criteria criteria = session.createCriteria(User.class);criteria.setProjection(projectionList);List users = criteria.list();
觀察所產生的SQL語句，將使用group by先進行分組，再針對每個分組進行count函數的計數
Hibernate: select this_.age as y0_, count(*) as y1_ from T_USER this_ group by this_.age
根據已知物件進行查詢
設定查詢條件並非一定要使用Restrictions，如果屬性條件很多，使用Restrictions也不方便，如果有一個已知的物件，則可以根據這個物件作為查詢的依據，看看是否有屬性與之類似的物件，例如：
User user = new User();user.setAge(new Integer(30));
Criteria criteria = session.createCriteria(User.class);criteria.add(Example.create(user));
List users = criteria.list();
您可以透過org.hibernate.criterion.Example的create()方法來建立Example實例，Example實作了Criteria介面，因此可以使用add()方法加入至Criteria條件設定之中，Hibernate將自動過濾掉空屬性，根據已知物件上已設定的屬性，判定是否產生於where子句之中：
Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=?)

Ⅶ 各位大俠們，hibernate怎麼完成動態生成sql語句的啊

Hibernate3支持DetachedCriteria，這是一個非常有意義的特性！我們知道，在常規的Web編程中，有大量的動態條件查詢，即用戶在網頁上面自由選擇某些條件，程序根據用戶的選擇條件，動態生成SQL語句，進行查詢。針對這種需求，對於分層應用程序來說，Web層需要傳遞一個查詢的條件列表給業務層對象，業務層對象獲得這個條件列表之後，然後依次取出條件，構造查詢語句。這里的一個難點是條件列表用什麼來構造？傳統上使用Map，但是這種方式缺陷很大，Map可以傳遞的信息非常有限，只能傳遞name和value，無法傳遞究竟要做怎樣的條件運算，究竟是大於，小於，like，還是其它的什麼，業務層對象必須確切掌握每條entry的隱含條件。因此一旦隱含條件改變，業務層對象的查詢構造演算法必須相應修改，但是這種查詢條件的改變是隱式約定的，而不是程序代碼約束的，因此非常容易出錯。DetachedCriteria可以解決這個問題，即在web層，程序員使用DetachedCriteria來構造查詢條件，然後將這個DetachedCriteria作為方法調用參數傳遞給業務層對象。而業務層對象獲得DetachedCriteria之後，可以在session范圍內直接構造Criteria，進行查詢。就此，查詢語句的構造完全被搬離到web層實現，而業務層則只負責完成持久化和查詢的封裝即可，與查詢條件構造完全解耦，非常完美！這恐怕也是以前很多企圖在web層代碼中構造HQL語句的人想實現的夢想吧！示例代碼片段如下：web層程序構造查詢條件：java代碼:DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.add(Restrictions.eq("name", "department")).createAlias("employees", "e").add(Restrictions.gt(("e.age"), new Integer(20)));Department和Employee是一對多關聯，查詢條件為：名稱是「department」開發部門；
部門裡面的雇員年齡大於20歲；業務層對象使用該條件執行查詢：java代碼:detachedCriteria.getExecutableCriteria(session).list();最大的意義在於，業務層代碼是固定不變的，所有查詢條件的構造都在web層完成，業務層只負責在session內執行之。這樣代碼就可放之四海而皆準，都無須修改了。然而Spring和Hibernate3的DetachedCriteria有不兼容的問題，因此在Spring環境下面使用Hibernate3需要注意：Spring的HibernateTemplate提供了Hibernate的完美封裝，即通過匿名類實現回調，來保證Session的自動資源管理和事務的管理。其中核心方法是：java代碼:HibernateTemplate.execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
....
}
}回調方法提供了session作為參數，有了session，就可以自由的使用Hibernate API編程了。使用了spring的之後，代碼修改如下：web層代碼：java代碼:DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.createAlias("employees", "e").add(Restrictions.eq("name", "department")).add(Restrictions.gt(("e.age"), new Integer(20)));
departmentManager.findByCriteria(detachedCriteria);構造detachedCriteria，作為參數傳遞給departmentManager業務層代碼使用spring，DepartmentManager的findByCriteria如下：java代碼:public List findByCriteria(final DetachedCriteria detachedCriteria) {
return (List) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list();
}
});
}實際上也就是：java代碼:Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list(); 而已但是該程序代碼執行，會拋出強制類型轉換異常！我跟蹤了一下spring和Hibernate源代碼，原因如下：spring的HibernateTemplate的execute方法提供的回調介面具有Session作為參數，但是實際上，默認情況下，HibernateTemplate傳遞給回調介面的session並不是org.hibernate.impl.SessionImpl類，而是SessionImpl類的一個Proxy類。之所以替換成為一個Proxy類，HibernateTemplate的注釋說明，Proxy提供了一些額外的功能，包括自動設置Cachable，Transaction的超時時間，Session資源的更積極的關閉等等。java代碼:private boolean exposeNativeSession = false;
... execute方法內部：Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));但是遺憾的是，Hibernate的DetachedCriteria的setExecutableCriteria方法卻要求將session參數強制轉為SessionImpl，但是spring傳過來的卻是一個Proxy類，因此就報錯了。java代碼:public Criteria getExecutableCriteria(Session session) {
impl.setSession( (SessionImpl) session ); // 要求SessionImpl，Spring傳遞的是Proxy
return impl;
}解決方法，禁止Spring的HibernateTemplate傳遞Proxy類，強制要求它傳遞真實的SessionImpl類，即給exexute方法增加一個參數，提供參數為true，如下：java代碼:public List findByCriteria(final DetachedCriteria detachedCriteria) {
return (List) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException {
Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list();
}
}, true);
}

Ⅷ Hibernate有幾種查詢方法

轉錄：
從點到面，講講hibernate查詢的6種方法。分別是HQL查詢
，對象化查詢Criteria方法，動態查詢DetachedCriteria，例子查詢，sql查詢，命名查詢。
如果單純的使用hibernate查詢資料庫只需要懂其中的一項就可以完成想要實現的一般功能，但是
從一個點，讓我們掌握6中方法，則提供了更多選擇。每一種方法都有其適用的情況與前提。
HQL查詢
HQL是hibernate自己的一套查詢語言，於SQL語法不同，具有跨資料庫的優點。示例代碼：

static void query(String name){
Session s=null;
try{
s=HibernateUtil.getSession();

//from後面是對象，不是表名
String hql="from Admin as admin where admin.aname=:name";//使用命名參數，推薦使用，易讀。
Query query=s.createQuery(hql);
query.setString("name", name);

List<Admin> list=query.list();

for(Admin admin:list){
System.out.println(admin.getAname());
}
}finally{
if(s!=null)
s.close();
}
}

適用情況：常用方法，比較傳統，類似jdbc。缺點：新的查詢語言，適用面有限，僅適用於Hibernate框架。
對象化查詢Criteria方法：

static void cri(String name,String password){
Session s=null;
try{
s=HibernateUtil.getSession();

Criteria c=s.createCriteria(Admin.class);
c.add(Restrictions.eq("aname",name));//eq是等於，gt是大於，lt是小於,or是或
c.add(Restrictions.eq("apassword", password));

List<Admin> list=c.list();
for(Admin admin:list){
System.out.println(admin.getAname());
}
}finally{
if(s!=null)
s.close();
}
}

適用情況：面向對象操作，革新了以前的資料庫操作方式，易讀。缺點：適用面較HQL有限。
動態分離查詢DetachedCriteria

static List dc(DetachedCriteria dc) {

Session s = HibernateUtil.getSession();
Criteria c = dc.getExecutableCriteria(s);
List rs = c.list();
s.close();
return rs;
}

DetachedCriteria dc = DetachedCriteria.forClass(User.class);
int id = 1;
if (id != 0)
dc.add(Restrictions.eq("id", id));
Date age = new Date();
if (age != null)
dc.add(Restrictions.le("birthday", age));
List users = dc(dc);
System.out.println("離線查詢返回結果：" + users);

適用情況：面向對象操作，分離業務與底層，不需要欄位屬性攝入到Dao實現層。缺點：適用面較HQL有限。
例子查詢

static List example(User user) {
Session s = HibernateUtil.getSession();
List<User> users = s.createCriteria(User.class).add(
Example.create(user)).list();
// List<User>
// users2=s.createCriteria(User.class).add((Example.create(user)).ignoreCase())
// .createCriteria("child").add((Example.create(user))).list();
return users;
}

適用情況：面向對象操作。缺點：適用面較HQL有限，不推薦。

sql查詢

static List sql() {

Session s = HibernateUtil.getSession();
Query q = s.createSQLQuery("select * from user").addEntity(User.class);
List<User> rs = q.list();
s.close();
return rs;
}

適用情況：不熟悉HQL的朋友，又不打算轉資料庫平台的朋友，萬能方法缺點：破壞跨平台，不易維護，不面向對象。
命名查詢

static List namedQuery(int id) {
Session s = HibernateUtil.getSession();
Query q = s.getNamedQuery("getUserById");
q.setInteger("id", id);
return q.list();
}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="com.sy.vo.User" table="user" catalog="news">

</class>

<query name="getUserById">
<![CDATA[from User where id=:id]]>
</query>

</hibernate-mapping>

適用情況：萬能方法，有點像ibatis輕量級框架的操作，方便維護。缺點：不面向對象。基於hql和sql，有一定缺陷。

hibernatesqllike

與hibernatesqllike相關的內容