2005年8月24日

          提高網絡新聞競爭力七個基本原則

            在舊的“以傳播者為中心”的模式逐步被“以受眾為中心”的新模式所代替的今天,網絡媒體給受眾提供了更多的選擇信息的自由和方便,這也為網絡編輯工作提出了挑戰。因此,對網絡新聞編輯而言提供信息并不是最重要的,對信息做出有效的處理,提高信息的服務質量才是競爭最有力的武器。

            互聯網的不斷普及,網民開始更多地關注一些深層次的新聞。在網絡新聞大戰中,競爭的焦點正在悄然地發生轉移,“眼球信息”的初步階段開始演繹到“頭腦信息”的深層次較量。提高網絡新聞競爭力的主要部分體現在日常新聞質量、突發轟動事件以及網站新聞搜索,這是一個潛移默化的綜合因素作用的結果。

          規范編輯工作流程(每天都要排專人發帖)

            制定編輯工作守則和編輯操作手冊,讓編輯以及相關員工有規可依、有法可循。手冊應該適應不斷變化的競爭環境,應該對稿件采集的來源,新聞稿件編輯的具體事項,一天的工作流程以及交接班時注意的事項等等做出相應的規范。應該包括新聞處理的最基本和最新要求,對于各種情形的處理辦法固定,各類基本規范和通報等等。

            建立對新聞事實核準制度,在各個欄目建立起對各自領域內對合作媒體群的評估體系,確定新聞價值的判斷原則以及實現方法。還要不斷查找發現自己的短處并且及時對癥下藥,進行有針對性的指導和培訓,增強網絡新聞的整體競爭力。

            建立突發事件預案(平常老出事的公司和人物都要盯緊點兒!,比如百度和DELL)

            長期以來,突發性新聞事件以其蘊含的巨大新聞價值而成為新聞報道中的一大重點。新聞網站在短時間內提升人氣或者改善品牌的最好機會,當在重大突發事件的報道。

            在突發事件報道過程中,需要在短時間內調動大量人力,需要培養一支專門應急的“特種兵”小分隊。網絡新聞媒體應該建立突發事件預案,建立高效率的快速反應機制。利用新聞傳播速度、方式、廣泛程度等方面的優勢一展身手。

            建立突發事件預案,配置足夠的資源支持。按照緊急處理流程,電話通知值班總編,并迅速發布快訊;應制定固定專題模版,在短時間內迅速做出專題報道。為受眾全面深入了解突發性新聞事件提供了一個開放性和多樣性的途徑。

          搶抓新聞制高點(什么倒閉啊虧損啊風投啊模式啊熱門詞都用上)

            網絡新聞表現出來的娛樂化、平民化、媚俗化為現階段消費時代的自然表現。“媚俗美學成為后傳播時代的審美風尚,即美學已滲透到了經濟、政治、文化以及日常生活中,因而喪失了其自主性和特殊性”。

            鑒于受眾在網絡新聞內容選擇上對于媚俗與娛樂元素的偏好,追求瀏覽率的網站,需要一定比例的“軟新聞”。實際上,對于成熟的品牌網站來說,沒有必要一味迎合受眾的這種“求軟”心理。“硬新聞”永遠是主流媒體的標志性核心產品,應該以“硬”為主,“軟”只是一種佐料,只是氣氛上的調劑。

            網絡新聞編輯在“把關”過程中要防止新聞煽情化。心理學家研究成果表明,受眾的本我是趨向“享樂”與“刺激”的,他們喜好“新奇”“娛樂”的傳播內容。網絡傳媒為了在眾多的媒體中脫穎而出,就必需要注意受眾的這一內在需求,通過滿足網民的閱讀喜好,來獲得支持。

          技術創新(找程序員做幾個機器人,智能回帖,頂,狂頂)

            好的發布系統可以形成更快的發布速度、更豐富的表現形式,更快捷的專題組織以及更多的內容關聯,而這些都是提升網站訪問量的關鍵因素。同時,利用好搜索引擎也是重要的一部分。

            新聞網站吸引受眾,提高網絡新聞的點擊率,一是要依靠口碑等人際關系的傳播,二是要依靠網站搜索的鏈接來實現。與搜索引擎相結合后,每一條新聞都可以看成是網站、頻道的品牌營銷通路。因為網友通過一個主題詞的搜索,都可能進入網站的一條新聞、一個專題、一個欄目、一個頻道。從這個意義上講,網絡新聞的生產過程本身就是構成自身品牌的營銷過程。

          加大專稿寫作力度(該造謠的時候下手一定要狠)

            在眾多的新聞網站中,真正吸引受眾,有長足的發展,做出特色新聞是新聞網站很重要的一個問題。

            網絡新聞媒體具有兩個突出的特點:原創性與整合性。原創性的獨家新聞報道是網絡新聞的特色。在現有資源情況下,要提升新聞網站的知名度,原創的新聞是必不可少的。典型報道在我國一直是主流媒媒體的優勢和強項。作為新聞的重要組成部分,典型宣傳在唱響主旋律、引領積極健康的主流輿論方面發揮著重要的作用。要深入學習理解,使先進典型宣傳主題緊扣黨的路線方針政策。更要精心細致采訪,尋覓獨家視角,使典型宣傳主題增強個性特色。

            同時,還應做一些解釋性報道、客觀性報道等深度報道。保持新聞特點的同時注意受眾的現實情況,行文多考慮時新性、趣味性、可讀性、思想性、人情味。這樣網絡才能有新的生命力和活力。

          研究受眾需求增強互動性(要讓別人發點小廣告,灌些MM圖)

            互聯網帶來的不僅是一種新的傳播方式,同時也對大眾的生活習慣、工作方式、價值觀念以及思維方式產生了重大影響。從傳播學的發展歷史來看,受眾與傳播者的角色經歷了多次的轉變。

            作好網絡新聞,要分析受眾的微觀和宏觀需求,;理解網絡新聞的受眾,滿足受眾的心理要求。在宏觀上,以傳播者為中心,編輯考慮的是戰略目的——提高新聞點擊率等,網絡編輯有新聞的選擇權,傳播者是主動的。在微觀上,網絡新聞的選擇是以受眾為中心,需要了解受眾需要的信息和傳播的方式。

            根據受眾心理特征,網絡編輯需要處理好網絡新聞“軟”與“硬”,“新”與“舊”,“真”與“假”,“深”與“淺”,“長”與“短”的關系。

            由于網絡的開放性和跨空間性,使得受眾群體有一定的發言權。新聞事件發生之后,現場目擊者、當事人可以通過論壇發布信息。廣泛的信息來源使得受眾在全面了解信息之后就能發表自己的看法、就不同觀點進行爭論。交互功能可以通過嘉賓聊天、新聞留言、網上新聞調查、主題論壇等方式來實現。

          頁面、欄目設計(一定要方便匿名發帖!!這最最重要了,)

            根據網絡受眾對新聞內容閱讀的跳躍性以及檢索性,建立合理的鏈接系統、方便受眾搜索。應該遵循視覺接觸中心的原則,注重版面“和諧、平衡、活潑、富有表現力”的色彩進行設計。

            網絡新聞媒體的版面語言主要體現在新聞在網頁的“空間位置“上。一般說來,處于網頁左方和上方的信息強勢較大,因為這部分信息往往最先爭得讀者的“眼球”。這樣,受眾能從閱讀的順序中體會到稿件重要與否。標題的字體大小、排列方式、色彩等手段也在網絡新聞的表現中得到應用。

            在舊的“以傳播者為中心”的模式逐步被“以受眾為中心”的新模式所代替的今天,網絡媒體給受眾提供了更多的選擇信息的自由和方便,這也為網絡編輯工作提出了挑戰。因此,對網絡新聞編輯而言提供信息并不是最重要的,對信息做出有效的處理,提高信息的服務質量才是競爭最有力的武器。

          posted @ 2006-08-10 11:46 我的JAVA 閱讀(272) | 評論 (0)編輯 收藏

          這次有這樣的機會,希望自己好好把握,希望是做最后一個網站。風險投資項目:www.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cnwww.cnmb.cn

          posted @ 2006-06-21 23:32 我的JAVA 閱讀(199) | 評論 (0)編輯 收藏

          嘿嘿,偶來介紹下Webwork2結合Spring, Hibernate,Default認為對Spring,Hibernate有一定了解。
          從User說起,包括創建/修改/刪除User,以及對User的列表,先看Webwork2的Action代碼
          為簡單說明問題,不考慮什么Interceptor, Duplicated Submit, Validation,等問題

          創建/修改/刪除User:UserAction.java相關代碼

          java代碼: 

          UserManager userManager;

          public void setUserManager(UserManager) {
              this.userManager = userManager;
          }

          public String create() {
              userManager.create(getUser());
          }

          public String modify() {
              userManager.modify(modifyUser())
              return "success";
          }

          public String remove() {
              userManager.remove(getUser())
              return "success";
          }



          xwork.xml相關代碼
          java代碼: 

          <action name="user" class="com.caryo.user.actions.UserAction">
              <external-ref name="userManager">userManager</external-ref>
              <result name="success" type="dispatcher">user.jsp</result>
          </action>



          webwork action會自動接受頁面上傳過來的信息,而且還支持JavaBean的BeanInfo(BeanInfo沒用過,偶
          都是直接在action中完成獲取屬性,以及類型轉換與校驗的工作的)
          Webwork2很方便的支持了Command模式,允許一個Action擁有多個Command,對應的url調用
          user!create.action, user!modify.action, user!remove.action,會對應的調用UserAction中的方法,
          然后根據方法返回值去尋找對應的View,return "sucess" 就會forward到user.jsp。
          其中的userManager是Spring中applicationContext中定義的bean

          java代碼: 

          <bean id="userManager" class="com.caryo.user.DefaultUserManager">
              <property name="userDAO"><ref local="userDAO"/></property>
          </bean>



          對User的列表:ListUserAction.java相關片斷

          java代碼: 

          UserManager userManager;

          public void setUserManager(UserManager) {
              this.userManager = userManager;
          }
          // userManager的獲取可放在一個User的根類聲明,如AbstractUserAction,這里重復為了看得清楚些

          public List getAllUsers() {
              userManager.getAllUsers();
          }

          public List getOnlineUsers() {
              userManager.getOnlineUsers();
          }



          xwork.xml相關代碼
          java代碼: 

          <action name="listuser" class="com.caryo.user.actions.ListUserAction">
              <external-ref name="userManager">userManager</external-ref>
              <result name="success" type="dispatcher">listuser.jsp</result>
          </action>



          這樣對應的url就是listuser.action,無command模式下會自動執行public String execute()這一方法,
          Default是一個返回"success"的空方法,當然你也可以重寫此方法,例如做校驗等等。

          listuser.jsp中使用webwork taglib打出User列表的片斷
          java代碼: 

          <ww:iteraor value="allUsers">
          userId: <ww:property value="id" />
          userName: <ww:property value="name" />
          </ww:iterator>

          <ww:iteraor value="onlineUsers">
          userId: <ww:property value="id" />
          userName: <ww:property value="name" />
          </ww:iterator>



          webwork taglib功能比較強大,其中還可使用帶參數的方法調用,而且在邏輯控制等方面都考慮的比較完善
          詳細參見 http://wiki.opensymphony.com/pages/viewpage.action?pageId=1876
          只要設計合理,基本上使用其taglib就可以控制整個view,包括復雜的頁面。盡管也支持Velocity, Freemarker等
          不過考慮到性能,推薦還是使用jsp view。
          大型網站的UI層應該盡可能的薄,JSP不易維護,我覺得taglib是可接受的厚度的上限了。

          Spring+hibernate的部分跟dhj1版主的相近,http://forum.javaeye.com/viewtopic.php?t=7925
          偶就不重復了。只說一些不同的地方
          1. web.xml 可以使用listener來初始化基本信息而不是用servlet
          2. 在Session in DAO中,用iterator返回數據應該是不行的,那么要獲取count,不是iterator.next()
          也不是獲取整個list,然后list.size(),而應是一個list.get(0);
          3. 可將HQL放到對應的hbm.xml中
          java代碼: 

          public class HibernateVehicleDAO extends CaryoHibernateObjectDAO implements VehicleDAO {
             
                  Class vehicleClass;

                  public Class getPersistentClass() {
                          return vehicleClass != null ? vehicleClass : (vehicleClass = Vehicle.class);
                  }
                 
                  public Vehicle getById(final long id) {
                  return (Vehicle) getByClassId(id);
                  }

                  public List findAllGlobalVehicles() {
                          return findNamedQuery("caryo.vehicle_findAllGlobalVehicles");
                  }
          }



          vehicle.hbm.xml相關代碼
          java代碼: 

          <query name="caryo.vehicle_findAllGlobalVehicles"><![CDATA[
              from Vehicle vehicle
          ]]></query>

          posted @ 2005-08-29 11:03 我的JAVA 閱讀(1027) | 評論 (2)編輯 收藏

          本文是開發基于spring的web應用的入門文章,前端采用Struts MVC框架,中間層采用spring,后臺采用Hibernate。

            本文包含以下內容:

             ·配置Hibernate和事務

             ·裝載Spring的applicationContext.xml文件

             ·建立業務層和DAO之間的依賴關系

             ·將Spring應用到Struts中

            簡介

            這個例子是建立一個簡單的web應用,叫MyUsers,完成用戶管理操作,包含簡單的數據庫增,刪,查,該即CRUD(新建,訪問,更新,刪除)操作。這是一個三層的web應用,通過Action(Struts)訪問業務層,業務層訪問DAO。圖一簡要說明了該應用的總體結構。圖上的數字說明了流程順序-從web(UserAction)到中間層(UserManager),再到數據訪問層(UserDAO),然后將結果返回。

            Spring層的真正強大在于它的聲明型事務處理,幫定和對持久層支持(例如Hiberate和iBATIS)

            以下下是完成這個例子的步驟:

            1. 安裝Eclipse插件

            2. 數據庫建表

            3. 配置Hibernate和Spring

            4. 建立Hibernate DAO接口的實現類

            5. 運行測試類,測試DAO的CRUD操作

            6. 創建一個處理類,聲明事務

            7. 創建web層的Action和model

            8. 運行Action的測試類測試CRUD操作

            9. 創建jsp文件通過瀏覽器進行CRUD操作

            10. 通過瀏覽器校驗jsp

            安裝eclipse插件

            1. Hibernate插件http://www.binamics.com/hibernatesync

            2. Spring插件http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/

            3. MyEclipse插件(破解版)

            4. Tomcat插件. tanghan

            5. 其他插件包括xml,jsp,

            數據庫建表


          create table app_user(id number not null primary,firstname vchar(32),lastname vchar(32));

            新建項目

            新建一個web project,新建后的目錄結構同時包含了新建文件夾page用于放jsp文件,和源文件夾test用于放junit測試文件。同時將用到的包,包括struts,hibernate,spring都導入到lib目錄下。

            創建持久層O/R mapping

            1. 在src/com.jandar.model下用hibernate插件從數據庫導出app_user的.hbm.xml文件改名為User.hbm.xml

          <?xml version="1.0"?>
          <!DOCTYPE hibernate-mapping PUBLIC
             "-//Hibernate/Hibernate Mapping DTD//EN"
             "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
          <hibernate-mapping package="com.jandar.model">
          <class name="User" table="APP_USER">
           <id
            column="ID"
            name="id"
            type="integer"
           >

            <generator class="assigned" />

           </id>

           <property
             column="LASTNAME"
             length="10"
             name="lastname"
             not-null="false"
             type="string"
           />

           <property
             column="FIRSTNAME"
             length="10"
             name="firstname"
             not-null="true"
             type="string"
           />

          </class>
          </hibernate-mapping>

            2. 通過hibernate synchronizer->synchronizer file生成User.java文件,User對象對應于數據庫中的app_user表

            注:在eclipse下自動生成的對象文件不完全相同,相同的是每個對象文件必須實現Serializable接口,必需又toString和hashCode方法;

          import java.io.Serializable;
          import org.apache.commons.lang.builder.EqualsBuilder;
          import org.apache.commons.lang.builder.HashCodeBuilder;
          import org.apache.commons.lang.builder.ToStringBuilder;
          import org.apache.commons.lang.builder.ToStringStyle;

          public class BaseObject implements Serializable {
           public String toString() {
            return ToStringBuilder.reflectionToString(this,
            ToStringStyle.MULTI_LINE_STYLE);
           }

           public boolean equals(Object o) {
            return EqualsBuilder.reflectionEquals(this, o);
           }

           public int hashCode() {
            return HashCodeBuilder.reflectionHashCode(this);
           }
          }

          public class User extends BaseObject {
           private Long id;
           private String firstName;
           private String lastName;

           /**
           * @return Returns the id.
           */

           public Long getId() {
            return id;
           }

           /**
            * @param id The id to set.
           */

           public void setId(Long id) {
            this.id = id;
           }

           /**
           * @return Returns the firstName.
           */

           public String getFirstName() {
            return firstName;
           }

           /**
            * @param firstName The firstName to set.
           */

           public void setFirstName(String firstName) {
            this.firstName = firstName;
           }

           /**
           * @return Returns the lastName.
           */

           public String getLastName() {
            return lastName;
           }

           /**
           * @param lastName The lastName to set.
           */

           public void setLastName(String lastName) {
            this.lastName = lastName;
           }
          }
          創建DAO訪問對象

            1. 在src/com.jandar.service.dao新建IDAO.java接口,所有的DAO都繼承該接口

          package com.jandar.services.dao;

          public interface IDAO {

          }

            2. 在src/com.jandar.service.dao下新建IUserDAO.java接口

          public interface IUserDAO extends DAO {
           List getUsers();
           User getUser(Integer userid);
           void saveUser(User user);
           void removeUser(Integer id);
          }

            該接口提供了訪問對象的方法,

            3. 在src/com.jandar.service.dao.hibernate下新建UserDAOHiberante.java

          import java.util.List;
          import org.apache.commons.logging.Log;
          import org.apache.commons.logging.LogFactory;
          import org.springframework.orm.hibernate.support.HibernateDaoSupport;
          import com.jandar.model.User;
          import com.jandar.service.dao.IUserDAO;

          public class UserDaoHibernate extends HibernateDaoSupport implements IUserDAO {

           private Log log=LogFactory.getLog(UserDaoHibernate.class);
           /* (非 Javadoc)
           * @see com.jandar.dao.IUserDAO#getUsers()
           */

           public List getUsers() {
            return getHibernateTemplate().find("from User");
           }

           /* (非 Javadoc)
           * @see com.jandar.dao.IUserDAO#getUser(java.lang.Long)
           */

           public User getUser(Integer id) {
            // TODO 自動生成方法存根
            return (User) getHibernateTemplate().get(User.class,id);
           }

           /* (非 Javadoc)
           * @see com.jandar.dao.IUserDAO#saveUser(com.jandar.model.User)
           */

           public void saveUser(User user) {
            log.debug("xxxxxxx");
            System.out.println("yyyy");
            getHibernateTemplate().saveOrUpdate(user);
            if(log.isDebugEnabled())
            {
             log.debug("userId set to "+user.getId());
            }
           }

           /* (非 Javadoc)
           * @see com.jandar.dao.IUserDAO#removeUser(java.lang.Long)
           */

           public void removeUser(Integer id) {
            Object user=getHibernateTemplate().load(User.class,id);
            getHibernateTemplate().delete(user);
            if(log.isDebugEnabled()){
             log.debug("del user "+id);
            }
           }
          }

            在這個類中實現了IUserDAO接口的方法,并且繼承了HibernateDAOSupport類。這個類的作用是通過hibernate訪問、操作對象,進而實現對數據庫的操作。

          posted @ 2005-08-26 15:58 我的JAVA 閱讀(700) | 評論 (1)編輯 收藏

          spring+hibernate開發網站

          http://www.xyzp.net 校園招聘一網打盡

          spring,一個輕量級的j2ee框架,輕量級的,這幾個字就深深的把我吸引住了。抱著《spring in action》啃了一個星期,小了解之后,把自己所學的東西幾乎通通用在了xyzp.net這個網站上,下面介紹一下:

          校園招聘一網打盡 提供專業的校園招聘信息。系統自動采集全國各大高校BBS和就業中心的招聘信息,按照地區、學校進行組織分類。

          http://www.xyzp.net網站分為兩個部分:后臺數據采集與前臺展示。
          1.后臺數據采集,利用htmlparser分析網頁,抽取我們所需的數據,以rss的結構進行存儲。
          2.前臺展示,利用spring+hibernate開發。hibernate處理數據庫邏輯,邏輯層使用spring,表示層應用spring本身的mvc。應用spring開發確實很方便,速度快,效率高;),整個網站2周就搞完了。而且,我不得不說,spring太美了。

          hibernate處理數據庫邏輯真是沒的說,整個網站一共就4張表,大量一對多和多對多的邏輯,hibernate處理的很好,主要是編程方面要處理的邏輯簡單了很多,但是效率方面有一點欠缺;(

          spring本身提供一套完整的mvc,應用起來很方便,功能也很強大,幾乎用的到的頁面邏輯它都想到了。推薦使用。

          應用了xmlhttprequest技術,因為首頁調用數據庫的次數太多,所以每個欄目都用一個遠程調用來解決的,速度很快,不過有的ie顯示還有一些問題;(

          雖然xmlhttprequest提升速度比較明顯,但對數據庫操作的次數并沒有減少,引入緩存機制才能從根本上解決,oscache是opensymphony的出品,它的頁面級緩存把整個網頁緩存下來,速度提升自然很明顯。

          整個網站沒有使用table,全部使用css搞定,大家可以看一下。

          整個網站全部采用開源軟件構建,包括spring,hibernate,oscache,tomcat,mysql,eclipse,java commons.lucene等等。

          在開發中碰到不少問題,字符集、鏈接池,spring與hibernate集成等等,對此有興趣可以和我聯系,QQ:21231398

          如果大家覺得這個網站還不錯,請推薦一下,謝謝;)

          posted @ 2005-08-25 01:28 我的JAVA 閱讀(986) | 評論 (3)編輯 收藏

          其實Hibernate本身是個獨立的框架,它不需要任何web server或application server的支持。然而,大多數的Hibernate入門介紹都加入了很多非Hibernate的東西,比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。這容易讓人產生Hibernate復雜難懂的誤解,特別是打擊了初學者的積極性。

          在這篇文章將不涉及Eclipse, log4j, Struts, Tomcat, XDoclet,和JBoss。本文的目的是演示一下Hibernate的安裝過程以及最基本的功能,從而給初學者一個低得不能再低的入門門檻。


          下載文件

          你需要Java SDK、 Hibernate包、Ant包、和JDBC Driver。

          1、Hibernate包下載地址:
          http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

          2、Ant包下載地址:
          http://apache.130th.net/ant/binaries/apache-ant-1.6.1-bin.zip

          3、JDBC Driver要根據你用的database來定,一般database官方網站上都會有。Hibernate支持常用的database,比如 MySQL, Oracle, PostgreSQL, 和MS-SQL Server。這些數據庫都有JDBC Driver:

          Oracle JDBC Driver下載地址(下載前必須同意Oracle協議書)
          http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

          MySQL JDBC Driver下載地址
          http://dev.mysql.com/downloads/connector/j/3.0.html

          PostgreSQL JDBC Driver下載地址
          http://jdbc.postgresql.org/download.html

          MS-SQL Server JDBC Driver下載地址
          http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en

          4、將Hibernate包和Ant包分別解壓至c:\dev\下(此目錄不重要,你可以換其它任何目錄)。


          配置環境

          1、你需要添加一個新的環境變量: ANT_HOME,讓它指向c:\dev\<你的ANT包所在目錄>。并在PATH環境變量里添加%ANT_HOME%\bin。

          2、你需要添加一個新的環境變量: JAVA_HOME,讓它指向你的j2sdk根目錄。并在PATH環境變量里添加%JAVA_HOME%\bin。

          3、創建一個項目目錄,比如c:\workspace\My1stHibernate。

          在項目目錄下,另外創建三個目錄: src, classes, lib。

          在lib目錄下,創建兩個目錄: hibernate和db。

          這樣你有了如下的文件結構:

          c:\workspace\My1stHibernate\
          c:\workspace\My1stHibernate\src
          c:\workspace\My1stHibernate\classes
          c:\workspace\My1stHibernate\lib
          c:\workspace\My1stHibernate\lib\hibernate
          c:\workspace\My1stHibernate\lib\db

          4、將c:\dev\<你的Hibernate包所在目錄>\hibernate2.jar文件copy到c:\workspace\My1stHibernate\lib\hibernate下。

          將c:\dev\<你的Hibernate包所在目錄>\lib\下的所有文件同樣copy到c:\workspace\My1stHibernate\lib\hibernate下。

          將你的JDBC Driver文件(一般是一個jar文件)copy到c:\workspace\My1stHibernate\lib\db下。


          創建數據庫

          1、用你最喜愛的database軟件,創建一個hibernate_test的數據庫。

          2、在此數據庫下,新建一個table名為CUSTOMER

          CREATE TABLE CUSTOMER
          (
              CID INTEGER NOT NULL PRIMARY KEY,
              USERNAME VARCHAR(12) NOT NULL,
              PASSWORD VARCHAR(12)
          );


          編寫Java文件

          public class Customer {
             
              private int id;
              private String username;
              private String password;


              public int getId() {
                  return id;
              }

              public String getPassword() {
                  return password;
              }

              public String getUsername() {
                  return username;
              }

              public void setId(int id) {
                  this.id = id;
              }

              public void setPassword(String password) {
                  this.password = password;
              }

              public void setUsername(String username) {
                  this.username = username;
              }

          }

          將此類存為c:\workspace\My1stHibernate\src\Customer.java文件。

          編寫Test類

          import net.sf.hibernate.*;
          import net.sf.hibernate.cfg.*;

          public class Test {

              public static void main(String[] args) {

                  try {
                      SessionFactory sf =
                          new Configuration().configure().buildSessionFactory();
                      Session session = sf.openSession();
                      Transaction tx = session.beginTransaction();

                      for (int i = 0; i < 200; i++) {
                          Customer customer = new Customer();
                          customer.setUsername("customer" + i);
                          customer.setPassword("customer");
                          session.save(customer);
                      }

                      tx.commit();
                      session.close();

                  } catch (HibernateException e) {
                      e.printStackTrace();
                  }
              }
          }

          將此類存為c:\workspace\My1stHibernate\src\Test.java文件。


          創建Hibernate映射文件

          因為這里只有一個Class --- Customer 和一個Table --- CUSTOMER,你只需要建立一個映射文件--- Customer.hbm.xml,來對應Customer類和CUSTOMER表之間的關系。

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

          <hibernate-mapping>
              <class name="Customer" table="CUSTOMER">
                  <id name="id" column="CID">
                      <generator class="increment" />
                  </id>
                  <property name="username" column="USERNAME" />
                  <property name="password" column="PASSWORD" />
              </class>
          </hibernate-mapping>

          把此文件存為c:\workspace\My1stHibernate\src\Customer.hbm.xml,和Customer.java放在同一目錄下。


          編寫Ant build.xml文件


          你不一定要知道這個build.xml的細節,其實Ant也不是Hibernate所必須的。這里用Ant是為了簡化一些任務,比如: 編譯、copy、運行,等。

          <?xml version="1.0" ?>

          <project name="My1stHibernate" default="build" basedir=".">

              <property name="base.dir" value="." />
              <property name="src.dir" value="src" />
              <property name="lib.dir" value="lib" />
              <property name="build.dir" value="classes" />

              <path id="myclasspath">
                  <fileset dir="${lib.dir}">
                      <include name="**/*.jar" />
                  </fileset>
                  <pathelement location="${build.dir}" />
              </path>

              <target name="init">
                  <mkdir dir="${build.dir}" />
              </target>
             
              <target name="build" depends="init" description="compile the source files">
                  <javac classpathref="myclasspath" srcdir="${src.dir}" destdir="${build.dir}" />
                  <copy todir="${build.dir}" >
                      <fileset dir="${src.dir}" >
                          <exclude name="**/*.java"/>
                      </fileset>
                  </copy>
              </target>

              <target name="run" depends="build">
                  <java classpathref="myclasspath" classname="Test" fork="true" />
              </target>

              <target name="clean">
                  <delete includeEmptyDirs="true">
                      <fileset dir="${build.dir}" />
                  </delete>
              </target>

          </project>


          配置Hibernate描述文件

          Hibernate描述文件可以是一個properties或xml 文件,其中最重要的是定義數據庫的連接。我這里列出的是一個XML格式的hibernate.cfg.xml描述文件。

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

          <hibernate-configuration>
             
              <session-factory name="java:/hibernate/HibernateFactory">
                 
                  <property name="show_sql">true</property>
                  <property name="connection.driver_class">
                      oracle.jdbc.driver.OracleDriver <!-- 這里是Oracle 9i的JDBC driver class名 -->
                  </property>
                  <property name="connection.url">
                      jdbc:oracle:oci8:@hibernate_test <!-- 這里是Oracle的hibernate_test數據庫URL -->
                  </property>
                  <property name="connection.username">
                      你的數據庫用戶名
                  </property>
                  <property name="connection.password">
                      你的數據庫密碼
                  </property>
                  <property name="dialect">
                      net.sf.hibernate.dialect.Oracle9Dialect <!-- 這里是Oracle 9i的Dialect -->
                  </property>
                 
                  <mapping resource="Customer.hbm.xml" /> <!-- 指定Customer的映射文件 -->
                 
              </session-factory>
             
          </hibernate-configuration>

          如果你用的不是Oracle 9i,可到C:\dev\<你的Hibernate包所在目錄>\src\hibernate.properties文件里找到你的數據庫,然后替換以上相對應的值。


          開始運行

          到c:\workspace\My1stHibernate下,運行ant run。如果你嚴格依照以上步驟,應該看到

          run:
                  [java] log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
                  [java] log4j:WARN Please initialize the log4j system properly.
                  [java] Hibernate: insert into CUSTOMER (USERNAME, PASSWORD, CID) values (?, ?, ?)
          BUILD SUCCESSFUL

          到你的hibernate_test數據庫看一下,在CUSTMOR表里新添了200條記錄,但你沒有寫任何JDBC code。
          以后如果你要更換數據庫,只需要改變hibernate.cfg.xml描述文件里相應的值即可。


          結論

          此文是一篇門檻極低的入門介紹。我給一個完全不懂Hibernate的朋友看,他用了不到30分鐘就運行了他的第一個Hibernate程序,從此引起了 他對Hibernate的興趣。但讀者必須認識到這只是一個開始,此文實乃窺Hibernate冰山一角上的一顆小冰晶。千里之行始于足下,你可以把此文 當作邁向Hibernate大道的一個起點。

          posted @ 2005-08-24 01:58 我的JAVA 閱讀(666) | 評論 (0)編輯 收藏

          對象、關系的映射(ORM)是一種耗時的工作,在Java環境下,有幾種框架來表示持久數據,如實體Bean、OJB、JDO、Hibernate等。Hibernate是一種新的ORM映射工具,它不僅提供了從Java類到數據表的映射,也提供了數據查詢和恢復等機制。本文介紹怎么在Web應用開發中配置Hibernate的環境,并且使用Hibernate來開發一個具體的實例。

            介紹

            面向對象的開發方法是當今的主流,但是同時我們不得不使用關系型數據庫,所以在企業級應用開發的環境中,對象、關系的映射(ORM)是一種耗時的工作。圍繞對象關系的映射和持久數據的訪問,在Java領域中發展起來了一些API和框架,下面分別簡單介紹。

            JDBC可以說是訪問持久數據層最原始、最直接的方法。在企業級應用開發中,我們可能使用DAO(Data Access Object)模式來把數據訪問封裝起來,然后在其它的層中同一調用。這種方式的優點是運行效率最高,缺點是把DAO對象和SQL語言緊密耦合在一起使得在大項目中難以維護。但是不管怎么說,使用JDBC來直接訪問持久數據層是當今企業級應用開發中使用最廣泛的。

            實體Bean是J2EE平臺中用來表示和訪問持久數據的方式。雖然實體Bean是一種方便快捷的方法,但是在運行時我們需要額外購買EJB容器(當然,如今也有免費的EJB容器,如JBOSS),并且使用不同的應用服務器,需要重新書寫不同的部署描述,使得在不同應用服務器下移植企業級應用會帶來一些困難。

            另外,在Java領域中,還有一些表示持久數據的框架,比如JDO和OJB,在這里就不詳細介紹了。

            Hibernate是一種新的ORM映射工具,它不僅提供了從Java類到數據表之間的映射,也提供了數據查詢和恢復機制。相對于使用JDBC和SQL來手工操作數據庫,使用Hibernate,可以大大減少操作數據庫的工作量。

            Hibernate可以和多種Web服務器或者應用服務器良好集成,如今已經支持幾乎所有的流行的數據庫服務器(達16種)。

            下面我們來介紹怎么結合Hibernate2.0和Apache Tomcat5.0在Web應用中使用Hibernate。

            配置

            1、下載安裝Tomcat,并且下載Hibernate的運行環境(主要包含一些JAR包)。
            2、把要使用的數據庫的JDBC驅動程序拷貝到%TOMCAT_HOME%\common\lib目錄下。筆者使用的是MYSQL,對應的驅動程序的JAR包為mm.mysql-2.0.4-bin.jar。
            3、在Tomcat的Webapps目錄下新建一個Web應用,名字為hibernate。
            4、把Hibernate提供的hibernate2.jar和一些第三方的運行庫拷貝到hibernate\WEB\INF\lib目錄下。(這些第三方的運行庫包含在下載的Hibernate lib目錄下)
            5、在%TOMCAT_HOME%\conf\server.xml中Web應用和數據源。在server.xml中加入以下的配置描述。

            例程1 配置web應用

           <Context path="/hibernate" docBase="hibernate" debug="0"   reloadable="true" crossContext="true">
            <Resource name="jdbc/hibernate" auth="Container" type="javax.sql.DataSource"/>  
               <ResourceParams name="jdbc/hibernate"> 
                <parameter>  
                    <name>factory</name>  
                 <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>  
                </parameter>
                <parameter>  
                   <name>driverClassName</name>  
                      <value>org.gjt.mm.mysql.Driver</value>  
                 </parameter> 
                  <parameter> 
                        <name>url</name>  
                        <value>jdbc:mysql:///test</value>  
                   </parameter>  
                 <parameter> 
                      <name>username</name> 
                     <value>root</value> 
                 </parameter>  
                <parameter> 
                   <name>password</name>  
                   <value></value> 
                    </parameter>  
                <parameter> 
                <name>maxActive</name> 
                <value>20</value> 
              </parameter>
                   <parameter>  
                  <name>maxIdle</name>  
                     <value>10</value>
              </parameter> 
              <parameter> 
                    <name>maxWait</name> 
                <value>-1</value> 
              </parameter>  
            </ResourceParams>  
           </Context>

            在這里,配置了一個名為hibernate的Web應用,并且配置了一個數據源,數據源的JNDI名稱為jdbc/hibernate。您需要根據情況修改數據源的鏈接屬性。

            6、下一步就是書寫Hibernate的配置描述符。可以使用XML的配置描述,也可以使用基于屬性的配置描述。在這里使用基于XML的配置描述。在hibernate\WEB-INF\classes目錄下新建一個hibernate.cfg.xml文件。然后加入例程2所示的內容。

          <!DOCTYPE hibernate-configuration
              PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
              "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

          <hibernate-configuration>
              <session-factory>
                  <property name="connection.datasource">java:comp/env/jdbc/hibernate</property>
                  <property name="show_sql">false</property>
                  <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
                  <!-- Mapping files -->
              </session-factory>
          </hibernate-configuration>

            注意connection.datasource屬性必須和server.xml中配置的數據源的屬性一樣。如果不是使用MYSQL,那么需要更改dialect屬性。

            到現在,配置基本完成,下面我們來開發一個最簡單的應用。

            開發持久對象、編寫映射描述

            我們使用hibernate來封裝一個簡單的數據表。這個表的名字為Courses,它有兩個字段,一個是ID,它是Courses表的主鍵;另一個是name,表示Courses的名字。在數據庫中使用以下的腳本來創建這個表:

            create table Courses(CourseId varchar(32) not null, name varchar(32), constraint pk_Courses primary key (CourseId) );

            接下來的任務就是為Courses表書寫持久對象,如例程3所示。

            例程3 Courses的持久對象(Courses.java)

          package com.hellking.study.hibernate;

          import java.util.Set;

          /**
           *在hibernate中代表了Course表的類。
           */
          public class Course
          {
             /**每個屬性和表的一個字段對應**/
             private String id;
             private String name;
            
             /**students表示course中的學生,在后面才會用到,暫時不管**/
             private Set students;
              
              /**屬性的訪問方法**/
           public void setId(String string) {
            id = string;
           }
           
           public String getId() {
            return id;
           }
           
           public void setName(String name)
           {
            this.name=name;
           }
           public String getName()
           {
            return this.name;
           }
           public void setStudents(Set stud)
           {
            this.students=stud;
           }
           public Set getStudents()
           {
            return this.students;
           }
          }

            可以看出,在Course類中也包含了兩個屬性,id和name,它的屬性和表Courses的字段是一一對應的,并且類型一致。

            書寫好了持久對象,接下來的任務就是書寫對象、關系映射描述。在hibernate\WEB-INF\classes目錄下新建一個Course.hbm.xml描述文件,內容如例程4所示。

            例程4 Course.hbm.xml

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

          <hibernate-mapping>
              <class
                  name="com.hellking.study.hibernate.Course"
                  table="Courses"
                  dynamic-update="false"
              >

                  <id
                      name="id"
                      column="CourseId"
                      type="string"
                      unsaved-value="any"
                  >
                      <generator class="assigned"/>
                  </id>

                  <property
                      name="name"
                      type="string"
                      update="true"
                      insert="true"
                      column="Name"
                  />     
              </class>
          </hibernate-mapping>

            在Course.hbm.xml映射文件中,指定了要映射的類和映射的表,并且指定了表的各個字段和Java對象中各個字段的映射關系,比如Course對象中的id屬性對應了Courses表的courseId字段。

            接下來的任務就是在hibernate.cfg.xml中指定這個映射關系。如下所示:

          <session-factory>

          <!-- Mapping files --> 
           <mapping resource="Course.hbm.xml"/>
          </session-factory>

            編寫業務邏輯

            到此,我們已經封裝了一個名為Courses的表,并且配置完成。接下來的任務就是在Web應用開發中使用它們,為了演示在Hibernate中對數據庫的不同類型的操作,我們開發的Web應用有以下的功能:
            增加一個Course;
            刪除一個Course;
            按照Course的名字進行模糊搜索;
            查看系統中所有的Course。

            雖然我們可以直接在JSP中使用hibernate,但是往往我們不這樣,而是把這些業務邏輯封裝在JavaBean中,然后在JSP中通過調用JavaBean以訪問Hibernate封裝的對象。

            由于訪問通過使用hibernate有一些共性的操作,在這里我們把這些共性的操作封裝在一個專門的類中,這樣其它的類可以繼承它,如例程5所示。

            例程5 HibernateBase.java

          package com.hellking.study.hibernate;

          import net.sf.hibernate.*;
          import net.sf.hibernate.cfg.*;
          import java.util.*;
          import java.io.IOException;
          import java.io.PrintWriter;

          public abstract class HibernateBase
          {
           protected SessionFactory sessionFactory;//會話工廠,用于創建會話
              protected Session session;//hibernate會話
              protected Transaction transaction; //hiberante事務
             
              public HibernateBase()throws HibernateException
              {
               this.initHibernate();
              }
              // 幫助方法
              protected void initHibernate()
                  throws HibernateException {

                  // 裝載配置,構造SessionFactory對象
                  sessionFactory = new Configuration().configure().buildSessionFactory();
              }
             
              /**
               *開始一個hibernate事務
               */
              protected void beginTransaction()
                  throws HibernateException {

                  session = sessionFactory.openSession();
                  transaction = session.beginTransaction();
              }
             
              /**
               *結束一個hibernate事務。
               */
              protected void endTransaction(boolean commit)
                  throws HibernateException {

                  if (commit) {
                      transaction.commit();
                  } else {
                     //如果是只讀的操作,不需要commit這個事務。
                      transaction.rollback();
                  }
                   session.close();
              }
          }

            下面編寫業務邏輯類,新建一個名為CourseBean的JavaBean,并且CourseBean繼承HibernateBase類,代碼如例程6所示。

            例程6 CourseBean.java

          package com.hellking.study.hibernate;

          import net.sf.hibernate.*;
          import net.sf.hibernate.cfg.*;
          import java.util.*;

          /**
           *和course相關的業務邏輯
           */
          public class CourseBean extends HibernateBase
          {
           public CourseBean()throws HibernateException
           {
            super();
           }
           /**
            *增加一個Course
            */
           public void addCourse(Course st)throws HibernateException
           {
            beginTransaction();
                   session.save(st);        
                   endTransaction(true);
              }
             
              /**
               *查詢系統中所有的Course,返回的是包含有Course持久對象的Iterator。
               */
              public Iterator getAllCourses()throws HibernateException
              {
                String queryString = "select courses from Course as courses";
                  beginTransaction();
                  Query query = session.createQuery(queryString);
                  Iterator it= query.iterate();
                  return it;
              }
             
              /**
               *刪除給定ID的course
               */
              public void deleteCourse(String id)throws HibernateException
              {
                beginTransaction();     
                Course course=(Course)session.load(Course.class,id);     
                session.delete(course);
                endTransaction(true);
               }
             
              /**
               *按course的名字進行模糊查找,返回的是包含有Course持久對象的Iterator。
               */
              public Iterator getSomeCourse(String name)throws HibernateException
              {
                 String queryString = "select c from Course as c where c.name like :name" ;
                   beginTransaction();
                   Query query = session.createQuery(queryString);
                   query.setString("name", "%"+name+"%");
                  Iterator it= query.iterate();
                  return it;
              }     
          }

            在CourseBean封裝了4個業務方法,你可以根據情況增加其它的業務方法。在CourseBean中,通過Hibernate來操作潛在的數據庫資源。

            要保存Course數據到數據庫,可以通過:

            session.save(Course);

            方法來保存,它相當于使用在JDBC中執行以下語句:

            Connection con=…
            Statement stmt=con.createStatement();
            stmt.executeUpdate("insert into courses values('"+course.getId(),+"','"+course.getName()+"')");
            con.close();

            可以看出,通過使用Hibernate,可以大大減少數據訪問的復雜度。

            在JSP中調用業務邏輯

            添加數據

            CourseBean這個業務對象封裝了和Hibernate的交互關系,從而使JSP和Hibernate關系的解藕。我們來看測試主頁面的部分代碼,如例程7所示。

            例程7 測試Hibernate開發的應用(course.jsp)

          <%@ page import="java.sql.*,java.util.*" errorPage="error.jsp"%>
          <jsp:useBean id="course" class="com.hellking.study.hibernate.Course" scope="page">
          <jsp:setProperty name="course" property="*"/>
          </jsp:useBean>
          <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>
          <html><body><center>
          <% 
            try
            {
            if(course.getId().equals(null)||course.getId().equals(""));
            else courseBusiness.addCourse(course);
           
            %>
          成功添加了Course:<br>
          name:<%=course.getName()%>
          Id:<%=course.getId()%>
          <%
          }
            catch(Exception e)
            {
            } 
          %>

          <hr>
          <br>::增加一個course::<br>
          <form action="course.jsp" method="get" name="add">
          id:<input type=text name="id"><br>
          name:<input type=text name="name"><br>
          <input type=submit value="submit"><br>
          </form>
          <hr>
          ::按名字模糊查找::<br>
          <form action="queryCourse.jsp" method="get" name="queryByName">
          name:<input type=text name="name"><br>
          <input type=submit value="query"><br>
          </form>
          <hr>
          ::刪除一個Course::<br>
          <form action="deleteCourse.jsp" method="get" name="queryByName">
          id:<input type=text name="id"><br>
          <input type=submit value="delete"><br>
          </form>
          <hr>
          <a href=viewAll.jsp>::查看所有Course::<a>
          </body>
          </html>

            首先通過一個值對象Course(這個類正好是Hibernate使用的持久對象,這里作為值對象來傳遞數據)接收獲得的參數,然后CourseBean的addCourse(Course)方法把數據保存到數據庫。可以看出,通過使用Hibernate,把數據從表單中添加到數據庫非常簡單。

            查詢

            下面來看模糊查找的JSP代碼,如例程8所示。

            例程8 按名字模糊查找Course

          <%@ page import="java.sql.*,java.util.*,com.hellking.study.hibernate.Course" errorPage="error.jsp"%>
          <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>

          <% try
          {
             Iterator it=courseBusiness.getSomeCourse((String)request.getParameter("name"));
             while(it.hasNext())
             {
               Course temp=(Course)it.next();
               out.println("<tr><td>"+temp.getId()+"</td>");
               out.println("<td>"+temp.getName()+"</td></tr>");
             }
            }
            catch(Exception e)
            {
              out.println(e.getMessage());
             }
          %>
          ….

            它實際上調用的是CourseBean的Iterator getSomeCourse(String name)方法。我們來回顧一下這個方法中的代碼:

            /**
               *按course的名字進行模糊查找
               */
              public Iterator getSomeCourse(String name)throws HibernateException
              {
                 String queryString = "select c from Course as c where c.name like :name" ;
                  beginTransaction();
                  Query query = session.createQuery(queryString);
                   query.setString("name", "%"+name+"%");
                  Iterator it= query.iterate();
                  return it;
              }

            在查詢前,首先調用beginTransaction方法啟動新的Hibernate事務,然后創建一個Query對象,在創建這個對象時,同時指定查詢的語句。

            注意,在查詢語句:

            select c from Course as c where c.name like :name"

            中,它雖然和普通的SQL語句相似,但是不同,在數據庫中,使用的表的名字是Courses,而在這個查詢語句中使用的是Course,它和持久對象的名字一致,也就是說,這個查詢的概念是查詢持久對象,而不是數據庫的記錄。

            創建了查詢對象Query后,需要設置查詢的參數,它和在JDBC中PreparedStatement對象中設置參數的方法相似。通過"Iterator it= query.iterate()"語句來執行查詢,并且返回一個Iterator對象。在這里使用了Hibernate提供的查詢機制,一般的JDBC查詢返回的是ResultSet對象,而這里返回的是包含了CourseBean對象的Iterator。

            要查詢系統中所有的Course,也同樣非常簡單,可以通過例程9所示的代碼實現。

            例程9 查詢數據庫中所有的Course


          <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>

          <% try
          {
             Iterator it=courseBusiness.getAllCourses();
             while(it.hasNext())
             {
               Course temp=(Course)it.next();
               out.println("<tr><td>"+temp.getId()+"</td>");
               out.println("<td>"+temp.getName()+"</td></tr>");
             }
            }
            catch(Exception e)
            {
              out.println(e.getMessage());
             }
          %>

            實際上調用的是CourseBean的getAllCourses方法,它和getSomeCourse方法機制一樣,就不再介紹了。

            刪除數據

            在JSP中,使用以下的代碼來執行刪除操作。

            例程10 刪除數據庫中Courses表的記錄

          <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" scope="page"/>

          刪除id為:<%=request.getParameter("id")%>的course::::<br>

          <% try
          {
           courseBusiness.deleteCourse(request.getParameter("id"));
           out.println("刪除成功");
          }
            catch(Exception e)
            {
              out.println("不存在這個記錄");
             }
          %>

            我們來看CourseBean中執行刪除操作的具體代碼:

            /**
               *刪除給定ID的course
               */
              public void deleteCourse(String id)throws HibernateException
              {
               beginTransaction();     
               Course course=(Course)session.load(Course.class,id);     
               session.delete(course);
               endTransaction(true);
               }

            在這個方法中,首先開始一個事務,然后通過session.load(Course.class,id)方法來裝載指定ID的持久對象,接下來通過"session.delete(course)"來刪除已經裝載的course,并且結束Hibernate事務。

            總結

            下面總結一下使用Hibernate的開發過程:

            1、配置Hibernate(一次即可);
            2、確定數據表;
            3、創建持久對象;
            4、編寫對象和數據表的映射描述;
            5、編寫和業務邏輯。

            實際上,上面的過程和使用EJB沒有什么區別:在使用EJB時,首先當然也是配置環境,初始化數據表;然后創建實體Bean(對象于Hibernate的持久對象);接下來編寫部署描述符(ejb-jar.xml,廠商專有的部署描述),在這些部署描述符里,指定了EJB和數據表的映射關系,如果多個實體Bean存在關聯關系,需要描述它們之間的關系,這些描述對應于Hibernate中持久對象的描述,如Course.hbm.xml;往往我們并不在應用程序中直接操作實體Bean,而是通過業務對象(如會話Bean)來操作,這里的會話Bean可以簡單的和Hibernate中執行業務邏輯的JavaBean對應。這里只是簡單的類比,不是絕對的,比如我們同樣可以在會話Bean中訪問Hibernate持久對象,也就是說使用Hibernate,同樣可以把業務邏輯放在會話Bean中。

            通過本文的學習,相信讀者對Hibernate已經有了初步的認識,并且能夠使用Hibernate開發簡單的應用。在下一篇中,我們將學習怎么使用Hibernate來為復雜的數據表進行映射,并且維護它們之間的關系。

          posted @ 2005-08-24 01:56 我的JAVA 閱讀(1079) | 評論 (0)編輯 收藏


          posts - 10, comments - 9, trackbacks - 0, articles - 0

          Copyright © 我的JAVA

          主站蜘蛛池模板: 盐城市| 青川县| 平乐县| 乐平市| 犍为县| 福州市| 湟中县| 甘肃省| 化州市| 东山县| 四川省| 汉阴县| 亚东县| 盘山县| 麟游县| 汪清县| 南安市| 绥芬河市| 昭觉县| 西宁市| 武鸣县| 会同县| 靖安县| 阳泉市| 中宁县| 康马县| 台州市| 津南区| 大足县| 多伦县| 奎屯市| 唐河县| 香港 | 伊金霍洛旗| 泾源县| 甘孜县| 嫩江县| 略阳县| 兰西县| 广丰县| 浪卡子县|