2006年8月10日

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


          2006年6月21日

          這次有這樣的機會,希望自己好好把握,希望是做最后一個網站。風險投資項目: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)編輯 收藏


          2005年8月29日

          嘿嘿,偶來介紹下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)編輯 收藏


          2005年8月26日

          本文是開發基于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)編輯 收藏


          2005年8月25日

          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)編輯 收藏


          2005年8月24日

          其實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)編輯 收藏


          2005年8月18日

           

          在配置jsp開發環境的過程中會碰到不少問題,感謝網上的許多前輩的經驗總結,作者cl41的JSP連接Mysql數據庫攻略和作者Saulzy的MySQL學習筆記等文章對我來說簡直是雪中送碳,為了幫助象我一樣的初學者在此總結了不少作者的經驗,非常感謝他們的無私奉獻精神,也希望更多的人把這種精神發揚光大,呵呵,再次對所參考文章的作者表示最崇高的敬意!
          以下軟件下載連接地址無法顯示的話,請直接到官方網站下載即可!
           
          軟件下載
          Mysql
          下載版本:mysql-4.1.13-win32.zip(Windows downloads)
          http://dev.mysql.com/downloads/mysql/4.1.html

          JDBC驅動
          下載版本:mysql-connector-java-3.1.10.zip
          http://dev.mysql.com/downloads/connector/j/3.1.html

          下載j2sdk
          下載版本:jdk-1_5_0_04-windows-i586-p.exe
          http://java.sun.com/j2se/1.5.0/download.jsp

          下載tomcat
          下載版本: jakarta-tomcat-5.5.9.exe
          http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi

          安裝,配置j2sdk:

          執行j2sdk安裝程序,按默認設置進行安裝,也可自定義路徑,但需修改下面的配置

          配置j2sdk:

          配置環境變量:

          我的電腦->屬性->高級->環境變量->系統變量中添加以下環境變量:
          JAVA_HOME=C:\Program Files\Java\jdk1.5.0_04
          CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
          path=%JAVA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

          寫一個簡單的java程序來測試J2SDK是否已安裝成功:
          public class hello
          {
           public static void main(String args[])
           {
           System.out.println("Hello");
           }
          }

          將程序保存為文件名為hello.java的文件。

          打開命令提示符窗口,進入到hello.java所在目錄,鍵入下面的命令
          javac hello.java
          java hello
          此時若打印出來hello則安裝成功,若沒有打印出這句話,仔細檢查以上配置是否正確。
          注意系統文件夾選項中應確定“隱藏已知文件類型的擴展名”不勾選(我的電腦—工具—查看)

          安裝,配置tomcat
          執行tomcat安裝程序,按默認設置進行安裝,也可自定義路徑,但需修改下面的配置

          我的電腦->屬性->高級->環境變量->系統變量中添加以下環境變量
          CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat 5.5
          CATALINA_BASE=C:\Program Files\Apache Software Foundation\Tomcat 5.5

          修改環境變量中的classpath,把tomat安裝目錄下的common\lib下的servlet-api.jar添加到classpath中去,
          修改后的classpath如下:
          classpath=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat 5.5\common\lib\servlet-api.jar;

          啟動tomcat,在IE中訪問http://localhost:8080,若看到tomcat的歡迎頁面的話說明安裝成功。

          安裝mysql
          解壓縮mysql-4.1.13-win32.zip,運行setup.exe
          首先出現的是安裝向導歡迎界面,直接點擊“Next”
          繼續,選擇安裝類型,選擇“自定義”custom安裝,然后點“Next”下一步,出現自定義安裝界面
          選擇安裝路徑:C:\MySQL Server 4.1(可自定義)
          點“OK”返回到自定義安裝界面,路徑已改為設置的路徑
          點“Next”,準備開始安裝
          點“Install”開始安裝
          完成后出現創建MySQL.com帳號的界面
          如果是首次使用MySQL,選“Create anew free MySQL.com accout”
          點“Next”,輸入你的Email地址和自己設定的用于登錄MySQL.com的密碼
          填完后點“Next”進入第二步
          填寫姓名等相關信息,填完點“Next”,進入第三步
          填完電話號碼、公司名稱等信息后,點“Next”,
          然后出現預覽你剛才填的信息的界面,點“Next”出現安裝完成界面
          注意,這里有個配置向導的選項(Configure the MySQL Server now),
          建議勾選立即配置你的MySQL。許多說安裝完MySQL后無法啟動,原因就在于沒有配置MySQL。
          點擊“Finish”完成安裝,并開始配置MySQL
          點“Next”,進入配置類型選擇頁面。選“Detailed configuration”(詳細配置)
          點“Next”,進入服務類型選擇頁面。選“Developer Machine”(開發者機器),這樣占用系統的資源不會很多
          點“Next”后,進入數據庫用法選擇頁面。選擇“Multifunctional Database”
          點“Next”,進入選擇InnoDB數據存放位置頁面
          不用更改設置,直接放在Installation Path安裝目錄里即可,然后點“Next”,選擇MySQL的同時聯接數
          選擇“Manual Setting”,設置為100(根據自己需要,酌情設置)
          點“Next”,配置MySQL在TCP/IP通訊環境中的端口選擇默認的3306端口即可。
          點“Next”,選擇MySQL中的字符設置
          注意,這里的選擇將會影響你是否能在MySQL中使用中文。選擇gb2312字符集以便支持簡體中文
          點“Next”,設置Windows服務選項
          注意,這里的選擇很關鍵。
          “Install As Windows Service”一定要勾選,這是將MySQL作為Windows的服務運行。
          “Service Name”就用默認的“MySQL”
          下面的“Launch the MySQL Server automatically”一定要勾選,這樣Windows啟動時,MySQL就會自動啟動服務,要不然就要手工啟動MySQL。
          許多人說安裝MySQL后無法啟動、無法連接、出現10061錯誤,原因就在這里。
          點“Next”,設置根帳號root的登錄密碼
          “Modify Security Settings”是設置根帳號的密碼,輸入你設定的密碼即可。
          “Create An Anonymous Account”是創建一個匿名帳號,這樣會導致未經授權的用戶非法訪問你的數據庫,有安全隱患,建議不要勾選。
          點“Next”,MySQL配置向導將依據你上面的所有設定配置MySQL,以便MySQL的運行符合你的需要
          點“Execute”開始配置,當出現“Service started successfully”時,說明你的配置完成,MySQL服務啟動成功
          點“Finish”完成,整個MySQL的配置完成,剩下的就是用MySQL客戶端連接MySQL服務器,然后使用了。


          安裝JDBC驅動:
          解壓縮mysql-connector-java-3.1.10.zip
          將要使用的是mysql-connector-java-3.1.10-bin-g.jar和mysql-connector-java-3.1.10-bin.jar

          配置
          在C:\Program Files\Java目錄下建立mysqlforjdbc子目錄,進入該目錄將mysql-connector-java-3.1.10-bin.jar到該目錄下
          進入C:\Program Files\Java\jdk1.5.0_04\lib目錄將mysql-connector-java-3.1.10-bin-g.jar拷貝到該目錄下
          然后配置classpath,追加%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;到該環境變量中去
          追加以后環境變量如下:
          CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib\servlet-api.jar;%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;
          配置這個的目的是讓java應用程序找到連接mysql的驅動.


          查看并啟動MySQL服務
          在Windows XP下安裝完MySQL后,它就已經自動啟動服務了,并且在開始菜單中有其客戶端的快捷方式連接
          可以通過Windows的服務管理器查看。“開始”-“運行”,輸入“services.msc”,回車。
          彈出Windows的服務管理器,然后就可以看見服務名為“mysql”的服務項了,其右邊標明“已啟動”
          在開始菜單-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客戶端的快捷方式連接
          輸入安裝是設置的密碼即可


          數據庫的使用

          Mysql安裝完畢以后,在開始菜單-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客戶端的快捷方式連接
          輸入安裝時設置的密碼

          使用mysql的基本命令(在mysql命令行編輯每輸入完命令后最后一定要有分號)
          顯示數據庫:show databases;
          使用數據庫:use 數據庫名;


          建庫
          在mysql里建一個數據庫first,以及在數據庫里建一個表about
          命令:create database first;

          為數據庫設置權限(用戶和密碼)
          命令:grant all privileges on first.* to test@localhost identified by  “123456”;
          當你執行完這個命令以后,只要你再以用戶名:test,密碼:123456登錄時你就只可以對first這個數據庫操作,這樣避開使用root
          輸入命令:use first;
          使用first數據庫;

          在first庫中建表
          命令:create table about(id int(8) primary key,name varchar(10));

          在表中假如數據:
          命令:insert into  about values('xyw1026','laojiang');

          退出
          命令:exit

          JSP連接mysql
          在C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps目錄下建立子目錄myapp
          進入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目錄下
          用記事本編寫一個文件保存為first.jsp
          代碼如下:
          <%@ page contentType="text/html;charset=gb2312"%>
          <%@ page import="java.sql.*"%>
          <html>
          <body>
          <%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
          String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
          //first為你的數據庫名
          Connection conn= DriverManager.getConnection(url);
          Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
          String sql="select * from first";
          ResultSet rs=stmt.executeQuery(sql);
          while(rs.next()) {%>
          您的第一個字段內容為:<%=rs.getString(1)%>
          您的第二個字段內容為:<%=rs.getString(2)%>
          <%}%>
          <%out.print("數據庫操作成功,恭喜你");%>
          <%rs.close();
          stmt.close();
          conn.close();
          %>
          </body>
          </html>

          在瀏覽器中輸入:
          http://127.0.0.1:8080/myapp/first.jsp
          若出現:
          id|num
          0 |laojiang

          數據庫操作成功,恭喜你

          表示配置成功


          進入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目錄
          在myapp目錄下新建一個目錄WEB-INF,注意,目錄名稱是區分大小寫的;
          在WEB-INF下用記事本新建一個文件,命名為web.xml,內容如下:

          <?xml version="1.0" encoding="ISO-8859-1"?>

          <!DOCTYPE web-app
          PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
          "

          <web-app>
          <display-name>My Web Application</display-name>
          <description>
          A application for test.
          </description>
          </web-app>

          在myapp下用記事本新建一個測試的jsp頁面,文件名為index.jsp,文件內容如下:

          <html><body><center>
          Now time is: <%=new java.util.Date()%>
          </center></body></html>


          重啟Tomcat
          打開瀏覽器,輸入
          http://localhost:8080/myapp/index.jsp
          看到當前時間的話說明成功安裝。

          建立自己的Servlet:
          用記事本新建一個servlet程序,文件名為HelloWorld.java,文件內容如下:

          import java.io.*;
          import javax.servlet.*;
          import javax.servlet.http.*;
          public class HelloWorld extends HttpServlet
          {
          public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
          {

          response.setContentType("text/html");
          PrintWriter out = response.getWriter();
          out.println("<html><head><title>");
          out.println("This is my first Servlet");
          out.println("</title></head><body>");
          out.println("<h1>Hello,World!</h1>");
          out.println("</body></html>");

          }
          }


          編譯
          將HelloWorld.java剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes目錄下
          命令行方式下輸入:
          cd C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes
          javac HelloWorld.java
          用javac HelloWorld.java來編譯這個文件,如果出現無法import javax.servlet.*
          則將C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib目錄下的servlet-api.jar文件拷貝并添加到
          C:\Program Files\Java\jre1.5.0_04\lib\ext目錄中去就可以了

          然后在C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes下會產生一個編譯后的servlet文件:HelloWorld.class
          用記事本打開C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\ROOT\WEB-INF目錄下的web.xml如下所示,添加后的內容如下:
          .
          .
          .
          <!-- JSPC servlet mappings start -->

              <servlet>
                  <servlet-name>org.apache.jsp.index_jsp</servlet-name>
                  <servlet-class>org.apache.jsp.index_jsp</servlet-class>
              </servlet>

              <servlet-mapping>
                  <servlet-name>org.apache.jsp.index_jsp</servlet-name>
                  <url-pattern>/index.jsp</url-pattern>
              </servlet-mapping>

             
              <servlet>
                  <servlet-name>HelloWorld</servlet-name>
                  <servlet-class>HelloWorld</servlet-class>
              </servlet>

              <servlet-mapping>
                  <servlet-name>HelloWorld</servlet-name>
                  <url-pattern>/servlet/HelloWorld</url-pattern>
              </servlet-mapping>

          <!-- JSPC servlet mappings end -->

          </web-app>

          這段話中的servlet這一段聲明了你要調用的Servlet,而servlet-mapping則是將聲明的servlet“映射”到/servlet/HelloWorld地址上

          啟動Tomcat,啟動瀏覽器,輸入http://localhost:8080//servlet/HelloWorld 如果看到輸出HelloWorld!就說明編寫的servlet成功了。
          注意:修改了web.xml以及新加了class,都要重啟Tomcat


          也可以在自己創建的目錄下測試如:
          將HelloWorld.class拷貝到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes目錄下
          其中classes目錄若沒有就創建一個
          用記事本打開C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF目錄下的web.xml如下所示,修改后的內容如下:
          .
          .
          .
          <!-- JSPC servlet mappings start -->
             
              <servlet>
                  <servlet-name>HelloWorld</servlet-name>
                  <servlet-class>HelloWorld</servlet-class>
              </servlet>

              <servlet-mapping>
                  <servlet-name>HelloWorld</servlet-name>
                  <url-pattern>/servlet/HelloWorld</url-pattern>
              </servlet-mapping>

          <!-- JSPC servlet mappings end -->

          </web-app>


          啟動Tomcat,啟動瀏覽器,輸入http://localhost:8080/myapp/servlet/HelloWorld 如果看到輸出HelloWorld!就說明編寫的servlet成功了。
          注意:修改了web.xml以及新加了class,都要重啟Tomcat


          建立自己的javaBean:

          用記事本新建一個java程序,文件名為TestBean.java,文件內容如下:
          package test;
          public class TestBean{
          private String name = null;
          public TestBean(String strName_p){
          this.name=strName_p;
          }
          public void setName(String strName_p){
          this.name=strName_p;
          }
          public String getName(){
          return this.name;
          }
          }

          編譯
          將TestBean.java放在c:\test下,使用如下命令編譯:
          C:\test>javac TestBean.java
          然后在c:\Test下會產生一個編譯后的bean文件:TestBean.class
          將TestBean.class文件剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes\test目錄下,
          若無某些子目錄則創建一個

          新建一個TestBean.jsp文件,文件內容為:
          <%@ page import="test.TestBean" %>
          <html><body><center>
          <%
          TestBean testBean=new TestBean("This is a test java bean.");
          %>
          Java bean name is: <%=testBean.getName()%>
          </center></body></html>

          重啟Tomcat,啟動瀏覽器,輸入http://localhost:8080/myapp/TestBean.jsp 如果看到輸出Java bean name is: This is a test java bean
          就說明編寫的javaBean成功了。


          (特別注明:本文內容均來自互聯網)

          posted @ 2005-08-18 01:29 我的JAVA 閱讀(1134) | 評論 (3)編輯 收藏


          2005年8月17日

           

          webwork是個優秀的開源框架,特別是其攔截器機制,我認為是整個系統最大的亮點,可在其上面做大量文章
          我的開發環境為Eclipse3.0.1+lomoz,數據庫我用的是MySQL4.0.12,當然,也用到了mysqlcc,服務器我用的是tomcat4.0.3和tomcat4.1
          請先下載webwork.,spring.,hibernate,并把JAR文件放到web-inf的lib目錄里面。同時,請下載http://unc.dl.sourceforge.net/sourceforge/aopalliance/aopalliance.zip ,將aopalliance.jar放到lib目錄里面。
          還有webwork2-spring.jar,以及mysql的驅動都要下載并放到lib里面,缺一不可
          然后是配置log4j,如果沒有正確配置log,TOMCAT將不能正常發布你的項目。配置log4j很簡單,
          在web-inf/classes下建立一個log4j.properties的文件,內容如下
              log4j.rootLogger=INFO, A1 , R
              log4j.appender.A1=org.apache.log4j.ConsoleAppender
              log4j.appender.A1.layout=org.apache.log4j.PatternLayout
              log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n
              log4j.appender.R=org.apache.log4j.RollingFileAppender
              log4j.appender.R.File=d:/Tomcat 4.1/webapps/demo/logs/log4j.log
              log4j.appender.R.MaxFileSize=100KB
              log4j.appender.R.MaxBackupIndex=1
              log4j.appender.R.layout=org.apache.log4j.PatternLayout
              log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
          其中log4j.appender.R.File這一項請按照你TOMCAT的安裝位置進行修改,關于log4j的詳細內容,推薦大家看Hilton的學習筆記以及IBM網站上的相關文章.
           好了,開始我們的webwork之旅了。首先是配置web.xml文件
          <?xml version="1.0" ?>
          <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

          <!-- Copyright (c) 2002 by ObjectLearn. All Rights Reserved. -->
          <web-app>
                 <listener>
                        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
                 </listener>
                 <listener>
                        <listener-class>com.atlassian.xwork.ext.ResolverSetupServletContextListener</listener-class>
                 </listener>
              <servlet>
                  <servlet-name>webwork</servlet-name>
                  <servlet-class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
              </servlet>
              <servlet-mapping>
                  <servlet-name>webwork</servlet-name>
                  <url-pattern>*.action</url-pattern>
              </servlet-mapping>

               <taglib>
                  <taglib-uri>webwork</taglib-uri>
                  <taglib-location>/WEB-INF/webwork.tld</taglib-location>
              </taglib>

          </web-app>

          我們配置了兩個監聽器,還有一個servlet,這個servlet負責action的轉發工作,關于action的詳細工作原理,大家可以參看xwork的源代碼
          在接下來配置之前,我想大概說一下我想實現的功能,就是簡單的往mysql的一個表中插入一些數據
          首先我用Middlegen-Hibernate和hibernate-extensions(我沒用eclipse的hibernate插件,我喜歡用這兩樣工具來生成)生成了表對應的hbm.xml文件和兩個JAVA類,表的字段是"tablename,fieldname,chinesename", 表名是
          "systable",其中tablename,fieldname做雙主鍵,這樣,生成出來的類應該是兩個,一個PK主鍵類和主類本身,我把他們加入到了我的項目中.
          然后我做了一個接口類
           package com.cz.struct;

           /**
            * @author tijichen
            *
            * TODO To change the template for this generated type comment go to
            * Window - Preferences - Java - Code Style - Code Templates
            */
           public interface SystableDAO {
            public abstract void insert(Systable data);
           }
          然后是實現類
           package com.cz.struct;
           import net.sf.*;
           import org.springframework.orm.hibernate.support.HibernateDaoSupport;
           /**
            * @author tijichen
            *
            * TODO To change the template for this generated type comment go to
            * Window - Preferences - Java - Code Style - Code Templates
            */
           public class SysTableDAOImp extends HibernateDaoSupport implements
           SystableDAO{
            public void insert(Systable data)
            {
             this.getHibernateTemplate().save(data);
            }
           }
          為什么要用接口類?因為spring會用到JAVA的動態代理,關于這部分,大家可以看xiaxin的spring指南
          在insert 方法中,我直接調用了spring提供的hibernate模板方法,真是方便呀

          然后是 spring的配置了,請在web-lib/下建立applicationContext.xml文件,內容如下
          <?xml version="1.0" encoding="UTF-8"?>
          <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
          <beans>
            <bean id="dataSource"
              class="org.springframework.jdbc.datasource.DriverManagerDataSource"
             destroy-method="close">
             <property name="driverClassName">
              <value>org.gjt.mm.mysql.Driver</value>
             </property>
             <property name="url">
              <value>jdbc:mysql://localhost/mystructs</value>
             </property>
             <property name="username">
              <value>chenzhi</value>
             </property>
             <property name="password">
              <value>1</value>
             </property>
            </bean>
            <bean id="sessionFactory"
             class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
             <property name="dataSource">
              <ref local="dataSource" />
             </property>
             <property name="mappingResources">
              <list>
               <value>com\cz\struct\SysTable.hbm.xml</value>
              </list>
             </property>
             <property name="hibernateProperties">
              <props>
               <prop key="hibernate.dialect">
                net.sf.hibernate.dialect.MySQLDialect
               </prop>
               <prop key="hibernate.show_sql">
                true
               </prop>
              </props>
             </property>
            </bean>
            <bean id="transactionManager"
             class="org.springframework.orm.hibernate.HibernateTransactionManager">
             <property name="sessionFactory">
              <ref local="sessionFactory" />
             </property>
            </bean>
            <bean id="systableDAO" class="com.cz.struct.SysTableDAOImp">
             <property name="sessionFactory">
              <ref local="sessionFactory" />
             </property>
            </bean>
            <bean id="systableDAOProxy"
             class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
             <property name="transactionManager">
              <ref bean="transactionManager" />
             </property>
             <property name="target">
              <ref local="systableDAO" />
             </property>
             <property name="transactionAttributes">
              <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
                <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
              </props>
             </property>
            </bean>
          </beans>

          在這個配置文件里面,我們設置了datasource\sessionfactory以及spring的動態代理,還有hibernate所需要的XML映射文件路徑
          然后是配置xwork.xml
          <!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN" "http://www.opensymphony.com/xwork/xwork-1.0.dtd">
          <xwork>
           <include file="webwork-default.xml" />
            <package name="default" extends="webwork-default"
             externalReferenceResolver="com.atlassian.xwork.ext.SpringServletContextReferenceResolver">
            <interceptors>
            <interceptor name="reference-resolver"
            class="com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor" />
            <interceptor-stack name="vxStack">
            <interceptor-ref name="params" />
            <interceptor-ref name="model-driven" />
            <interceptor-ref name="reference-resolver" />
            </interceptor-stack>
            </interceptors>
          <action name="Test" class="com.cz.struct.TestAction">
           <external-ref name="systableDAO">systableDAOProxy</external-ref>
           <result name="success" type="dispatcher">
           <param name="location">/index.jsp</param>
           </result>

           <interceptor-ref name="vxStack" />
          </action>
          </package>
          </xwork>

          在配置action的external-ref的時候我遇到了一個不大不小的玩笑,一般編輯XML的時候我都是在editplus里面編輯的
          ,最開始我寫成
          <external-ref name="systableDAO">
           systableDAOProxy
          </external-ref>
          結果系統提示找不到叫systableDAOProxy這個名字的bean,結果一查,發現旁邊不能加上空格和tab,哎。。肯定是返回串的時候沒加trim
          的后果
          好了,最后是我們的TestAction.java
          package com.cz.struct;
          import com.opensymphony.xwork.*;
          import com.opensymphony.webwork.*;
          import java.util.*;
          /**
           * @author tijichen
           *
           * TODO To change the template for this generated type comment go to
           * Window - Preferences - Java - Code Style - Code Templates
           */
          public class TestAction extends ActionSupport
          {
           private SystableDAO systabledao;
           
           String testname=null;
           public void setSystableDAO(SystableDAO dao)
           {
            this.systabledao=dao;
           }
           public SystableDAO getSystableDAO()
           {return this.systabledao;}
              public String execute() throws Exception {
               testname="executeing";
               SystablePK pk=new SystablePK();
               Systable newdata=new Systable();
               pk.setFieldName("test");
               pk.setTableName("test3");
               newdata.setComp_id(pk);
               newdata.setChineseName("tets");

               systabledao.insert(newdata);
                  return Action.SUCCESS;
              }
           
          }
          ok,編譯打包,然后在瀏覽器地址欄中輸入http://localhost:8080/你的發布目錄/Test.action
          看看,是不是數據庫里面多出了一條數據了?
          至于其他,比如從頁面提交的值插入數據庫等等,這里都不多說了,webwork自帶的sample就是最好的參考資料

          posted @ 2005-08-17 01:06 我的JAVA 閱讀(1308) | 評論 (0)編輯 收藏

           

          package zmsjdbc;
          import java.sql.*;
          public class mysql1
          {

            private   String url="jdbc:mysql://localhost:3306/beyond";
                      //先下載MYSQL 驅動  mm.mysql-2.0.4-bin.jar 放在D:\JBuilder9\jdk1.4\jre\lib\ext 下

           private   String user="root";
           private   String pwd="";
           public   Connection  getcon()
           {
             Connection con;
              try
              { //加載驅動程序
                Class.forName("org.gjt.mm.mysql.Driver").newInstance();
                //創建連接
                con=DriverManager.getConnection(url,user,pwd);
                return con;
               }

               catch(ClassNotFoundException e)
               {
                   System.out.println("加載驅動程序出錯");
               }


               catch(Exception e)
               {
                 System.out.println("出現了好大的錯誤");
               }

               return null;
           }
           public  ResultSet  executeSql(String sqlstr)
             {
               Connection conn;
               Statement stmt;

                try
                {
                  conn=getcon();
                  stmt=conn.createStatement();
                  ResultSet  rs=stmt.executeQuery(sqlstr);

                  return rs;
                }
                catch(SQLException e)
                {
                  System.out.print("獲取數據集時出現錯誤");
                }
                return null;
             }

            public static void main(String[] args)
            {
              mysql1 mysql11 = new mysql1();
              Connection conn;
              ResultSet  rs;
             rs= mysql11.executeSql("select * from zms1");
              try
              {
                while(rs.next())
                {
                  System.out.println(rs.getString("name"));
                }
              }
              catch(Exception e)
              {
                 System.out.println(e.getMessage());
              }


            }

          }


          posted @ 2005-08-17 00:01 我的JAVA 閱讀(339) | 評論 (0)編輯 收藏


          僅列出標題  

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

          Copyright © 我的JAVA

          主站蜘蛛池模板: 宜兰县| 丁青县| 怀来县| 额济纳旗| 彩票| 沅江市| 略阳县| 图木舒克市| 南川市| 云龙县| 宣恩县| 安多县| 丹巴县| 永寿县| 竹北市| 库尔勒市| 噶尔县| 汕尾市| 扶绥县| 宜都市| 信阳市| 临颍县| 德化县| 文水县| 清苑县| 西乡县| 嵊州市| 巧家县| 崇州市| 呼玛县| 都安| 福安市| 文昌市| 保亭| 威海市| 汉中市| 阜康市| 普兰店市| 利川市| 冷水江市| 武隆县|