Hibernate CURD的封裝和HQL的多表查詢:

時間 2019-12-23

標籤 hibernate curd 封裝 hql 查詢欄目 Hibernate 简体版

原文原文鏈接

本身寫的一個Hibernate CURD的封裝

本身在dome一個小項目的時候,突發奇想,利用單例和工廠加上泛型的知識封裝Po的CURD操做,直接上代碼,文筆很差,呵呵，還請你們指教

接口規範，定義CURD操做

Java代碼 [img]http://www.javaeye.com/images/icon_copy.gif[/img]

package edu.sasu.DAO;

import java.util.List;

/**

* 全部實體類遵循的接口

* @author Administrator

* @param <T>

* @param <ID>

public interface BaseDao<T> {

/**

* 保存實體

* @param entity 實體類

public boolean save(T entity);

/**

* 刪除實體

* @param entity 實體類

public boolean delete(T entity);

/**

* 根據實體ID刪除實體

* @param entity 實體類

public boolean deleteById(T entity);

/**

* 跟新實體

* @param entity 實體類

//public boolean update(T entity);

public boolean update(T entity, Object OID);

/**

* 根據實體d,查詢單個實體

* @param entity 實體類

* @return

//public T findById(T entity);

public T findById(T entity, Object entityID);

/**

* 累出全部實體集合

* @param entityClass 實體類

* @return 實體類List

public List<T> findAll(String hql);

public List<T> findAll(T entity);

/**

* 保存和跟新方法

public boolean saveOrUpdate(T entity);

}

package edu.sasu.DAO;

import java.util.List;

/**

* 全部實體類遵循的接口

* @author Administrator

* @param <T>

* @param <ID>

public interface BaseDao<T> {

/**

* 保存實體

* @param entity 實體類

public boolean save(T entity);

/**

* 刪除實體

* @param entity 實體類

public boolean delete(T entity);

/**

* 根據實體ID刪除實體

* @param entity 實體類

public boolean deleteById(T entity);

/**

* 跟新實體

* @param entity 實體類

//public boolean update(T entity);

public boolean update(T entity, Object OID);

/**

* 根據實體d,查詢單個實體

* @param entity 實體類

* @return

//public T findById(T entity);

public T findById(T entity, Object entityID);

/**

* 累出全部實體集合

* @param entityClass 實體類

* @return 實體類List

public List<T> findAll(String hql);

public List<T> findAll(T entity);

/**

* 保存和跟新方法

public boolean saveOrUpdate(T entity);

}

實現BaseDao接口,實現其中的方法

Java代碼 [img]http://www.javaeye.com/images/icon_copy.gif[/img]

package edu.sasu.DAOImpl;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.Transaction;

import edu.sasu.DAO.BaseDao;

import edu.sasu.Util.DBUtil;

/**

* 封裝的基類操做

* @author Administrator

* @param <T>

public class BaseDAOImpl<T> implements BaseDao<T>{

public synchronized boolean delete(T entity) {

// TODO Auto-generated method stub

return false;

}

/**

* 刪除某條數據

public synchronized boolean deleteById(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

session.delete(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

return false;

}

return true;

}

public synchronized List<T> findAll(T entity) {

// TODO Auto-generated method stub

return null;

}

/**

* 查找單個數據

public synchronized T findById(T entity, Object entityID) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

T temp;

try {

tx = session.beginTransaction();

temp = (T) session.get(entity.getClass(),(Serializable) entityID);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

throw e;

}finally{

}

return temp;

}

/**

* 保存數據

public synchronized boolean save(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

//session.persist(entity);

session.save(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

/**

* 跟新數據

public synchronized boolean update(T entity, Object OID) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

T temp = (T) session.get(entity.getClass(), (Serializable) OID);

session.merge(entity); //若是update要拋異常

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

/**

* 查找符合hql的全部數據

public synchronized List<T> findAll(String hql) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

List<T> list = new ArrayList<T>();

try {

tx = session.beginTransaction();

list = session.createQuery(hql).list();

session.flush();

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

e.printStackTrace();

}

return list;

}

/**

* 保存和跟新方法

public synchronized boolean saveOrUpdate(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

session.saveOrUpdate(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

package edu.sasu.DAOImpl;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.Transaction;

import edu.sasu.DAO.BaseDao;

import edu.sasu.Util.DBUtil;

/**

* 封裝的基類操做

* @author Administrator

* @param <T>

public class BaseDAOImpl<T> implements BaseDao<T>{

public synchronized boolean delete(T entity) {

// TODO Auto-generated method stub

return false;

}

/**

* 刪除某條數據

public synchronized boolean deleteById(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

session.delete(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

return false;

}

return true;

}

public synchronized List<T> findAll(T entity) {

// TODO Auto-generated method stub

return null;

}

/**

* 查找單個數據

public synchronized T findById(T entity, Object entityID) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

T temp;

try {

tx = session.beginTransaction();

temp = (T) session.get(entity.getClass(),(Serializable) entityID);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

throw e;

}finally{

}

return temp;

}

/**

* 保存數據

public synchronized boolean save(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

//session.persist(entity);

session.save(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

/**

* 跟新數據

public synchronized boolean update(T entity, Object OID) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

T temp = (T) session.get(entity.getClass(), (Serializable) OID);

session.merge(entity); //若是update要拋異常

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

/**

* 查找符合hql的全部數據

public synchronized List<T> findAll(String hql) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

List<T> list = new ArrayList<T>();

try {

tx = session.beginTransaction();

list = session.createQuery(hql).list();

session.flush();

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

e.printStackTrace();

}

return list;

}

/**

* 保存和跟新方法

public synchronized boolean saveOrUpdate(T entity) {

Session session = DBUtil.getDBUtil().getSession();

Transaction tx = null;

try {

tx = session.beginTransaction();

session.saveOrUpdate(entity);

tx.commit();

} catch (HibernateException e) {

if(tx != null){

tx.rollback();

}

//return false;

e.printStackTrace();

}

return true;

}

基礎工廠採用單例實現獲取實例操做對象

Java代碼 [img]http://www.javaeye.com/images/icon_copy.gif[/img]

package edu.sasu.factory;

import edu.sasu.DAO.BaseDao;

import edu.sasu.DAOImpl.BaseDAOImpl;

/**

* 基礎工廠

* @author Administrator

* @param <T>

public class BaseFactory<T> {

private static BaseFactory baseFactory; //單一實例

private BaseDao<T> Instance;

private BaseFactory(){

Instance = new BaseDAOImpl<T>();

}

public BaseDao<T> getInstance(){ //不要把factory的new放在構造函數裏面,否則會出現遞歸錯誤

return Instance;

}

public static BaseFactory getFactory(){

if(baseFactory == null){

baseFactory = new BaseFactory();

}

return baseFactory;

}

package edu.sasu.factory;

import edu.sasu.DAO.BaseDao;

import edu.sasu.DAOImpl.BaseDAOImpl;

/**

* 基礎工廠

* @author Administrator

* @param <T>

public class BaseFactory<T> {

private static BaseFactory baseFactory; //單一實例

private BaseDao<T> Instance;

private BaseFactory(){

Instance = new BaseDAOImpl<T>();

}

public BaseDao<T> getInstance(){ //不要把factory的new放在構造函數裏面,否則會出現遞歸錯誤

return Instance;

}

public static BaseFactory getFactory(){

if(baseFactory == null){

baseFactory = new BaseFactory();

}

return baseFactory;

}

以上定義baseDAO接口,baeDAOIMpl是接口的實現,baseFactory是工廠,對baseDAOimp實例化,

在類中調用爲: User(一個PoJo類)

User entity= new User();

BaseFactory<User> factory = BaseFactory.getFactory();

執行保存操做: factory.getInstance().save(entity); entity User的實例對象

執行保存操做,請你們評點下此種寫法有什麼很差的地方,本人能力有限,以爲還能夠,請大牛指教

humour 發表於 2011-3-24 15:59

0 0 請登陸後投票

superobin 等級: 初級會員

[img]http://www.javaeye.com/images/user-logo.gif?1299226978[/img]

性別: [img]http://www.javaeye.com/images/icon_minigender_1.gif[/img]

/根據主鍵查詢

public Object findRel(Class desClass, int creatorId) {

Session session = null;

Object obj = null;

try {

session = HibernateUtil.getSession();

obj = session.get(desClass, new Integer(creatorId));

} catch (HibernateException e) {

e.printStackTrace();

} finally {

HibernateUtil.closeSession(session);

}

return obj;

}

Hibernate條件查詢(Criteria Query)

一、建立一個Criteria實例

net.sf.hibernate.Criteria這個接口表明對一個特定的持久化類的查詢。Session是用來製造Criteria實例的工廠。

Criteria crit = sess.createCriteria(Cat.class);//建立實力類能夠爲OBJECT.CLASS

crit.setMaxResults(50);

List cats = crit.list();

返回最多50條記錄的結果集。

二、縮小結果集範圍

一個查詢條件(Criterion)是net.sf.hibernate.expression.Criterion接口的一個實例。類net.sf.hibernate.expression.Expression定義了得到一些內置的Criterion類型。

import org.hibernate.criterion.Projections;//兩個查詢條件類

import org.hibernate.criterion.Expression;

List cats = sess.createCriteria(Cat.class)

.add( Expression.like("name", "Fritz%") )

.add( Expression.between("weight", minWeight, maxWeight) )

.list();

表達式（Expressions）能夠按照邏輯分組.

List cats = sess.createCriteria(Cat.class)

.add( Expression.like("name", "Fritz%") )

.add( Expression.or(

Expression.eq( "age", new Integer(0) ),

Expression.isNull("age")

) )

.list();

返回（name like "Fritz%" and age 等於0 或者 age 爲空）的結果集

List cats = sess.createCriteria(Cat.class)

.add( Expression.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )

.add( Expression.disjunction()

.add( Expression.isNull("age") )

.add( Expression.eq("age", new Integer(0) ) )

.add( Expression.eq("age", new Integer(1) ) )

.add( Expression.eq("age", new Integer(2) ) )

) )

.list();

Expression.disjunction()----意思是能夠按照邏輯分組

有不少預製的條件類型（Expression的子類）。有一個特別有用，可讓你直接嵌入SQL。

List cats = sess.createCriteria(Cat.class)

.add( Expression.sql("lower($alias.name) like lower(?)", "Fritz%", Hibernate.STRING) )

.list();

其中的{alias}是一個佔位符，它將會被所查詢實體的行別名所替代。(原文:The {alias} placeholder with be replaced by the row alias of the queried entity.)

三、對結果排序

可使用net.sf.hibernate.expression.Order對結果集排序.

List cats = sess.createCriteria(Cat.class)

.add( Expression.like("name", "F%")

.addOrder( Order.asc("name") )

.addOrder( Order.desc("age") )

.setMaxResults(50)

.list();

四、關聯（Associations）

你能夠在關聯之間使用createCriteria()，很容易地在存在關係的實體之間指定約束。

List cats = sess.createCriteria(Cat.class)

.add( Expression.like("name", "F%")

.createCriteria("kittens")

.add( Expression.like("name", "F%")

.list();

注意，第二個createCriteria()返回一個Criteria的新實例，指向kittens集合類的元素。

下面的替代形式在特定狀況下有用。

List cats = sess.createCriteria(Cat.class)

.createAlias("kittens", "kt")

.createAlias("mate", "mt")

.add( Expression.eqProperty("kt.name", "mt.name") )

.list();

（createAlias()）並不會建立一個Criteria的新實例。）

請注意，前面兩個查詢中Cat實例所持有的kittens集合類並無經過criteria預先過濾！若是你但願只返回知足條件的kittens,你必須使用returnMaps()。

List cats = sess.createCriteria(Cat.class)

.createCriteria("kittens", "kt")

.add( Expression.eq("name", "F%") )

.returnMaps()

.list();

Iterator iter = cats.iterator();

while ( iter.hasNext() ) {

Map map = (Map) iter.next();

Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);

Cat kitten = (Cat) map.get("kt");

}

五、動態關聯對象獲取（Dynamic association fetching）

能夠在運行時經過setFetchMode()來改變關聯對象自動獲取的策略。

List cats = sess.createCriteria(Cat.class)

.add( Expression.like("name", "Fritz%") )

.setFetchMode("mate", FetchMode.EAGER)

.list();

這個查詢會經過外鏈接(outer join)同時得到 mate和kittens。

六、根據示例查詢（Example queries）

net.sf.hibernate.expression.Example類容許你從指定的實例創造查詢條件。

Cat cat = new Cat();

cat.setSex('F');

cat.setColor(Color.BLACK);

List results = session.createCriteria(Cat.class)

.add( Example.create(cat) )

.list();

版本屬性，表示符屬性和關聯都會被忽略。默認狀況下，null值的屬性也被排除在外。

You can adjust how the Example is applied. 你能夠調整示例(Example)如何應用。

Example example = Example.create(cat)

.excludeZeroes() //exclude zero valued properties

.excludeProperty("color") //exclude the property named "color"

.ignoreCase() //perform case insensitive string comparisons

.enableLike(); //use like for string comparisons

List results = session.createCriteria(Cat.class)

.add(example)

.list();

你甚至能夠用示例對關聯對象創建criteria。

List results = session.createCriteria(Cat.class)

.add( Example.create(cat) )

.createCriteria("mate")

.add( Example.create( cat.getMate() ) )

.list();

HQL的多表查詢:

對象之間老是有各類各樣的關係，關聯關係是類之間最多見的關係。多表查詢是HQL中的強大功能之一，

包括內鏈接、左鏈接和右鏈接等。多表查詢的設置及運行都比較麻煩，在運行本節中的示例時，

務必保證每一步都沒有錯誤。

一:表之間的關聯關係:

在數據庫joblog中用到了3個表：student（學生表）、course（課程表）和sc（選課表）。在現實模型中，

一個學生能夠選擇多門課程，一個課程能夠被多個學生選擇，student和course是多對多的關聯關係。

爲了便於演示HQL的多表查詢，本節中假設student和course之間是單向關聯關係。

在多對多的關聯關係中，通常來講有個中間表，這個表描述了多對多關係，這就是選課表sc，

sc每一行數據表明一個學生的選課和成績。

各個表的主鍵、外鍵設置以下。

student表的主鍵是id字段。

course表的主鍵是id字段。

sc表的主鍵是id字段。

sc表中的Sno字段是student表id字段的外鍵。

sc表中的Cno字段是course表id字段的外鍵。

在MySQL Query Browser中設置好上述關係。若是此處設置不正確，可能會影響多表鏈接查詢.

其中sc表的建表信息以下（其中包含了外鍵關係）。

CREATE TABLE 'joblog'. 'sc' (

'id' int(10) unsigned NOT NULL auto_increment COMMENT 'id',

'Sno' int(10) unsigned NOT NULL default '0' COMMENT '學號',

'Cno' int(10) unsigned NOT NULL default '0' COMMENT '課程號',

'Grade' int(10) unsigned default NULL COMMENT '成績',

PRIMARY KEY ('id'),

KEY 'FK_sc_1' ('Sno'),

KEY 'FK_sc_2' ('Cno'),

CONSTRAINT 'FK_sc_1' FOREIGN KEY ('Sno') REFERENCES 'student' ('id'), /* 外鍵信息 */

CONSTRAINT 'FK_sc_2' FOREIGN KEY ('Cno') REFERENCES 'course' ('id') /* 外鍵信息 */

) ENGINE=InnoDB DEFAULT CHARSET=gb2312;

二:表中的數據:

這一節中用到了3個表的數據

三:修改持久化類:

Student對象和Course對象之間是多對多的關係。此處使用的是單向關聯，僅僅創建從Student到Course的單向關聯。

僅有Student到Course的單向關聯。

爲了創建Student到Course的單向關聯關係，在Student.java中新加一個屬性course。course屬性是Set型的，

能夠在這個屬性中加入多個Course對象，創建起關聯關係。下面是加入course屬性後的源代碼，粗體部分爲加入的代碼。

package hibernate.ch06;

import java.util.HashSet;

import java.util.Set;

public class Student implements java.io.Serializable {

private Integer id; //ID

private Integer sno; //學號

private String sname; //姓名

private String ssex; //性別

private String sdept; //系部

private Integer sage; //年齡

private String saddress; //住址

private Set course=new HashSet(); //所選課程

public Student() {

}

//此處省略其餘的構造方法

//此處省略getter/setter訪問器

//course屬性的get訪問器

public Set getCourse() {

return course;

}

//course屬性的set訪問器

public void setCourse(Set course) {

this.course = course;

}

持久化類Course.java和SC.java無需修改

在映射文件中加入關聯信息:

在Student.hbm.xml映射配置文件中，加入Student到Course的映射信息。具體代碼以下。

<many-to-many class="hibernate.ch06.Course" column="cno" />

</set>

說明以下。

<set>元素是和<class>元素平行的元素。<set>元素代表將要映射的字段對應着一個集合。<set>元素包含多個屬性，

其中：name屬性用於設置映射的持久化類的屬性名稱，在本例中爲Student表的course屬性；table屬性表示

多對多關聯關係的中間表名稱，此處爲sc表；cascade表示當保存或者更新Student實例時，是否保存或更新Course對象。

<set>元素的子元素<key column="sno" />設定與student表關聯的中間表sc的外鍵sno。

<set>元素的子元素<many-to-many>用於設定多對多關係。在該元素中，class屬性用於設定多對多關係中，

與Student類關聯的類Course類；column屬性設定中間表與course錶鏈接的外鍵cno。

完整的配置文件Student.hbm.xml以下所示。

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

</id>

</property>

</property>

</property>

</property>

</property>

</property>

<many-to-many class="hibernate.ch06.Course" column="cno" />

</set>

</class>

</hibernate-mapping>

五:左外鏈接:

左外鏈接(Left Outer Join)查詢出左表對應的複合條件的全部記錄，如查詢張三同窗的選課信息。

下面是類HQLLeftOuterJoinQuery的源代碼。

package hibernate.ch06;

import hibernate.HibernateSessionFactory;

import java.util.Iterator;

import java.util.List;

import org.hibernate.Query;

import org.hibernate.Session;

public class HQLLeftOuterJoinQuery {

public static void main(String[] args) {

Session session=HibernateSessionFactory.currentSession();

//HQL查詢語句

String hql="from Student s left join s.course c where s.sname='張三'";

Query query=session.createQuery(hql); //建立查詢

List list=query.list(); //執行查詢

Iterator it=list.iterator();

while(it.hasNext()){

Object[] obj=(Object[])it.next();

Student stu=(Student)obj[0];

Course course=(Course)obj[1];

System.out.println("*********學生信息及其選課信息******************");

if(course!=null){

System.out.println(stu.getSno() "\t" stu.getSname() "\t"

"課程:" course.getCname());

}else{

System.out.println(stu.getSno() "\t" stu.getSname() "\t");

};

}

若是隻用單表查詢，只能從student表中查詢出張三的我的信息，而沒法知道她的選課信息，由於選課信息存儲在中間表sc中。

HQL語句from Student s left join s.course c where s.sname='張山'檢索出了長三的選課信息。

在HQL中使用left outer join關鍵字進行左外鏈接，outer關鍵字能夠省略。

s.course是Student對象中的一個屬性，用來存儲Student對象的選課信息。在執行查詢時，將根據Student.hbm.xml中的

配置生成SQL語句，並檢索信息。

查詢的結果返回一個Object[]數組，數組的第0個元素是Student對象，第1個元素是與Object[0]中對應的學生所選課的Course對象。

HQLLeftOuterJoinQuery類在執行過程當中生成的左外鏈接的SQL語句以下。

Hibernate:

select

student0_.id as id1_0_,

course2_.id as id4_1_,

student0_.Sno as Sno1_0_,

student0_.Sname as Sname1_0_,

student0_.Sdept as Sdept1_0_,

student0_.Sage as Sage1_0_,

student0_.Ssex as Ssex1_0_,

student0_.Saddress as Saddress1_0_,

course2_.Cno as Cno4_1_,

course2_.Cname as Cname4_1_,

course2_.Ccredit as Ccredit4_1_

from

joblog.student student0_

left outer join

sc course1_

on student0_.id=course1_.sno

left outer join

joblog.course course2_

on course1_.cno=course2_.id

where

student0_.Sname='張三'

Hibernate:

select

course0_.sno as sno1_,

course0_.cno as cno1_,

course1_.id as id4_0_,

course1_.Cno as Cno4_0_,

course1_.Cname as Cname4_0_,

course1_.Ccredit as Ccredit4_0_

from

sc course0_

left outer join

joblog.course course1_

on course0_.cno=course1_.id

where

course0_.sno=?

使用以下語句將只返回Student對象。

select s from Student s left join s.course c where s.sname='張三'

以下是隻返回Student對象的部分代碼。

Session session=HibernateSessionFactory.currentSession();

//HQL查詢語句

String hql="select s from Student s left join s.course c where s.sname='張三'";

Query query=session.createQuery(hql); //建立查詢

List list=query.list(); //執行查詢

Iterator it=list.iterator();

while(it.hasNext()){

Student stu=(Student)it.next();

System.out.println("*********學生信息及其選課信息******************");

System.out.println(stu.getSno() "\t" stu.getSname() "\t");

}

六:左外抓取鏈接:

左外抓取鏈接指定在Hibernate檢索數據時，採用抓取的方式，直接將數據加載到與Student對象關聯的course屬性中。

下面是左外抓取鏈接的程序。

//HQL查詢語句

String hql="select s from Student s left join fetch s.course c where s.sname='張三'";

Query query=session.createQuery(hql); //建立查詢

List list=query.list(); //執行查詢

Iterator it=list.iterator();

while(it.hasNext()){

Student stu=(Student)it.next();

System.out.println("*********學生信息及其選課信息******************");

System.out.println(stu.getSno() "\t" stu.getSname() "\t");

}

左外抓取鏈接使用left join fetch關鍵字。

與左外鏈接不一樣的是：左外抓取鏈接query.list()返回的集合中存放Student對象的引用，

與之相關聯的選課信息存放在course屬性中。

七:右外鏈接:

HQL中使用關鍵字right outer join右外鏈接，outer關鍵字能夠省略。右外鏈接與左外鏈接相似，再也不贅述。

八:內鏈接:

內鏈接（Inner Join）是指兩個表中指定的關鍵字相等的值纔會出如今結果集中的一種查詢方式。

HQL中使用關鍵字inner join進行內鏈接，下面是使用內鏈接的程序。

Session session=HibernateSessionFactory.currentSession() //建立Session

String hql="from Student s inner join s.course c"; //HQL查詢語句

Query query=session.createQuery(hql); //建立查詢

List list=query.list(); //執行查詢

Iterator it=list.iterator();

while(it.hasNext()){

Object[] obj=(Object[])it.next();

Student stu=(Student)obj[0];

Course course=(Course)obj[1];

System.out.println("*********學生信息及其選課信息******************");

System.out.println(stu.getSno() "\t" stu.getSname() "\t" "課程:" course. getCname());

}

HQL中使用inner join進行內鏈接，內鏈接只關聯並檢索那些選了課的學生信息及其選課信息，沒有選課的學生不在檢索結果中。

可使用select s from Student s inner join s.course c只返回Student對象。

九: 抓取內鏈接:

抓取內鏈接與內鏈接不一樣之處在於其對象的內存狀態不同。HQL中使用inner join fetch進行抓取內鏈接，以下程序所示。

Session session=HibernateSessionFactory.currentSession(); //建立Session

String hql="select s from Student s inner join fetch s.course c"; //HQL語句

Query query=session.createQuery(hql); //建立查詢

List list=query.list(); //執行查詢

Iterator it=list.iterator();

while(it.hasNext()){

Student stu=(Student)it.next();

System.out.println("*********學生信息及其選課信息******************");

System.out.println(stu.getSno() "\t" stu.getSname() "\t");

}

內抓取鏈接使用inner join fech關鍵字。

它與內鏈接的區別是返回檢索的list中存放的是Student對象的引用，與之相關聯的選課信息存放在course屬性中

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。