第一次接觸mina這個物件，在網上看了一些相關的資料，同時也參考了別人的一些分析mina的心得和方式！
mina是何物？
Mina是一個用于開發高性能和高可用性的網絡應用程序基礎架構，它封裝了底層的I/O和線程并發等復雜工作。
Mina主要是基于java NIO類庫開發；采用非阻塞方式的異步傳輸、事件驅動、批量數據傳輸；支持TCP、UDP網絡協議

首先從服務器端啟動NioSocketAcceptor對象進行分析。
1、實例化DefaultSocketSessionConfig會話配置器和異步傳輸NioProcessor處理器
2、實例化AbstractPollingIoAcceptor構造器同時實例化SimpleIoProcessorPool處理器池
      --〉在SimpleProcessorPool中初始化執行器<線程池>，然后初始化一個IoProcessor對象數組，長度為3，最后將處理器對象放入到IoProcessor數組中
      --〉處理化傳輸帶元數據
      --〉初始化服務監視器
      --〉初始化異常監視器
3、初始化過濾鏈
4、初始化選擇器

架構介紹

應用結構圖

深入分析結構圖

mina的基本應用可以分為3層：
1、I/O Serivce：實際執行I/O層
2、I/OFilter chain：數據過濾和轉換層，主要是把字節轉換為需要的數據格式或者反過來處理
3、I/OHandler：業務處理層
創建Mina應用分為3部分：
1、創建I/O 2、創建過濾鏈
3、創建I/O業務處理

 Dojo介紹
       Dojo 是一個用javascript語言實現的開源DHTML工具包。它是在幾個項目捐助基礎上建立起來的(nWidgets, Burstlib, f(m)), 這也是為什么叫它a \"unified\" toolkit的原因。Dojo的目標是解決開發DHTML應用程序遇到的那些，長期存在 、歷史問題。historical problems with DHTML 跨瀏覽器問題。Dojo讓你更容易 使web頁面具有動態能力，或在任何穩健的支持javascript語言的環境中發揮作用。

a、利用dojo提供的組件，你可以提升你的web應用程序可用性、交互能力以及功能上的提高；
b、你也可以 更容易的建立degradeable user interfaces ？？，dojo提供小巧的 widgets ，animate transitions；
c、利用它的低級APIs和可兼容的代碼，寫出輕便的、單一風格（復雜）的javascript代碼，Dojo的 event system, I/O APIs, and generic language enhancement form the basis of a powerful programming environment.
d、通過Dojo提供的工具，你可以為你的代碼寫命令行式的單元測試代碼。
e、the Dojo package system使你自己的代碼更容易維護，偶合性更低。

Dojo通過很少的代碼完成了以上的功能。（以后可能我詳細說說dojo的package system ，只需要三個js文件）。當你寫腳本時，只需要包含很少的js文件（大小）。也可以選擇的（包含）下載dojo提供的龐大的功能。Dojo provides MultiplePointsOfEntry, InterpreterIndependence, ForwardLookingAPIs, and focuses on ReducingBarriersToAdoption.
　　dojo試圖建立一種新的標簽語言DojoML。目標是，在DojoML和javascript腳本語言不變的情況下，用不同的render方式展示數據， Renderings may be made available in several rendering contexts (such as SVG, or perhaps even the desktop or Flash)。（比較美好啊）更進一步，the DojoML 剖析器可以接受html和svg為輸入，容易的建立DegradeableResponsiveApplications。

第一部分  安裝
第一個小節  怎么安裝Dojo Toolkit
 Dojo在磁盤上只是一堆文件，它不需要特殊的設置，它可以通過以下三種途徑獲得：
 1、可以從google的內容分布網絡獲得
   加載的方法可以參考http://code.google.com/intl/zh-CN/apis/ajaxlibs/documentation/index.html#dojo
 2、.在你自己的服務器上使用Dojo
  a、下載最新的dojo包，地址：http://dojotoolkit.org/downloads；目前最新的包為1.3.1
  b、解壓下載的壓縮文件
         --dojo-release-1.3.1-src
            ----dijit
            ----dojo
            ----dojox
            ----util
  c、可以通過D:\Apache-Source\dojo\1.3.1\dojo-release-1.3.1-src\dojo-release-1.3.1-src\dijit\themes\themeTester.html 這樣的路徑來查看相關的JS例子
3、每日構建代碼
   你可以通過SVN地址獲得
For instance, Dojo Core repository is:
http://svn.dojotoolkit.org/src/dojo/trunk

There are two versions of this view: anonymous and committer.

For users (readonly):
http://svn.dojotoolkit.org/src/view/anon/all/trunk

For committers (read/write):
https://svn.dojotoolkit.org/src/view/committer/all/trunk

第二部分 Ajax
第一個小節 ajax
a、ajax and Dojo
1）XHR選項
例子：

// post some data, ignore the response:
dojo.xhrPost({
form: "someFormId", // read the url: from the action="" of the <form>
timeout: 3000, // give up after 3 seconds
content: { part:"one", another:"part" } // creates ?part=one&another=part with GET, Sent as POST data when using xhrPost
});
// get some data, convert to JSON
dojo.xhrGet({
url:"data.json",
handleAs:"json",
load: function(data){
for(var i in data){
console.log("key", i, "value", data[i]);
}
}
});

2）XHR回調
有三種方法可以附加到XHR選擇對象，以確定當數據回調時該怎么做。

   如果不輸入絕對的URL訪問地址，例如：URL=http://localhost:8080/petstore；則Glassfish能夠自動的搜索項目中是否存在index.html或者index.jsp頁面作為入口頁面。 
   CatalogFacade對象在服務器啟動時被實例化，然后將實例化的CatalogFacade對象放置到ServletContext環境中，這樣可以直接從ServletContext環境中取得CatalogFacade對象進行相關數據方法的調用。
   index.jsp中涉足到一個js框架DOJO，這個需要進一步的學習。
   對數據的增、刪、改、查主要用到了JPA來處理。     由于PetStore涉及到了jsf，那就沒有辦法了，還是先看看JSF
--------------------------------------------------------------------------
    JSF是有JCP（JAVA Community Process）團隊研發出來的一套標準，并在2004年3月發表JavaServer Faces1.0成果。

    看到一篇內容對初學者目前jsf的了解很重要：注意這篇文章是2006年的內容
       JSF1.1 ， JSF1.2 ， myfaces,oracle ADF,ajax4jsf ， facelets, 它們究竟是什么，有什么關系呢？

JSF1.1 、 1.2 都是 JSF 的標準，定義例如接口、規范（ JSF 是面向接口編程的），必須通過實現才能被我們所使用，而實現包括有 JSF RI(Reference Implementation) ，還有 myfaces core1.1.4 的實現等。 JSF RI 是 SUN 對 JSF 的實現，相對來說兼容性比較好，也比較穩定（因為 1.1 已經很久沒更新過了，已經轉向 1.2 去了），而 myfaces 更新比較快，功能也比較多一點，初學的推薦 JSF RI1.1 就可以了， 1.2 需要新的 servlet2.5/jsp2.1 以及服務器支持，現在還不穩定。

myfaces ，它是一個大的項目，下面有幾個子項目，分別是 myfaces core, sandbox ,tabago,tomahawk ，（奇怪的名字，好難說，我簡稱它為 TOM ），還有一個新的 ADF Faces （跟 oracle adf 有關，應該是兼容整合 adf 的功能吧）。 Tabago,tom 都是組件庫， tabago 比較好玩的是支持換膚，還有一些支持 ajax 的組件， TOM 則是一個豐富的增強組件庫，大概有三十個之多，例如 TREE ， TAB 等等。 Sandbox 是測試用的。

Oracle ADF 是 oracle 為 jsf 做的一個大型的組件庫，以前是收費的，現在開源了，我沒用過，不好說。

Ajax4jsf 是為 jsf 提供 AJAX 支持的一個標簽庫，使用它提供的標簽，就能在原有的 JSF 程序上輕易的加上 AJAX 的功能，而且不用寫任何 Javascript 。

Facelets 這個是很激動人心的一個框架，有了這個框架才把 JSF 的組件化發揮出來，通過模板的方式來組合成我們所需要的組件，而且可以不使用 <h:input> 這樣的標簽庫，而用 <input type=”text” jsfc=”h:input”> 這樣的方式來使用組件，這樣就可以方便的使用 UI 可視化工具去開發我們的 WEB 程序。這個框架我會在以后的文章中詳細的說，以及和 jsp2.0 的模板功能作對比。
--------------------------------------------------------------------------------
   JSF的session超時問題會在頁面上拋出如下異常：
javax.faces.application.ViewExpiredException: viewId:/pages/index.faces - View /pages/index.faces could not be restored.
 at com.sun.faces.lifecycle.RestoreViewPhase.execute(RestoreViewPhase.java:185)
 at com.sun.faces.lifecycle.LifecycleImpl.phase(LifecycleImpl.java:251)
 at com.sun.faces.lifecycle.LifecycleImpl.execute(LifecycleImpl.java:117)
 at javax.faces.webapp.FacesServlet.service(FacesServlet.java:244)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:230)
 at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:175)
 at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:128)
 at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:104)
 at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
 at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:261)
 at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:844)
 at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:581)
 at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:447)
 at java.lang.Thread.run(Unknown Source)
    解決方案：
          在web.xml中添加如下代碼：
  <error-page>
    <exception-type>javax.faces.application.ViewExpiredException</exception-type>
    <location>/pages/SessionRefire.jsp</location>
  </error-page>

----------------------------------------------------
注意：所有的JSF標簽一定要包含在<f:view></f:view>這個節點中，不然會報一下問題：

javax.servlet.ServletException: Component javax.faces.component.UIViewRoot@f1fad1 not expected type.  Expected: javax.faces.component.UIOutput.  Perhaps you're missing a tag?
javax.faces.webapp.FacesServlet.service(FacesServlet.java:256)

 

 Hibernate本身自帶的連接池算法不成熟，并不適合用于產品系統或者性能測試。出于最佳性能和穩定性考慮你應該使用第三方連接池。
比如使用：C3PO。
C3PO是一個隨Hibernate一同分發的開源JDBC連接池。

使用HTML5構建下一代的Web Form

作者 蔣博 發布于 2009年6月22日 上午4時52分

社區

Architecture,

Java

主題

編程,

語言

標簽

W3C,

標識語言

HTML5 是由 WHATWG (Web Hypertext Application Technology Working Group) 發起的，最開始的名稱叫做Web Application 1.0，而后這個標準吸納了Web Forms 2.0的標準，并一同被W3C組織所采用，合并成為下一代的HTML5標準。

前言

HTML語言作為如今編程最為廣泛的語言，具有易用、快捷、多瀏覽平臺兼容等特點，但是隨著時代的進步，HTML的標準卻停滯不前，這一次還在不斷開發中的HTML5標準的更新可以說給這門標記語言帶來了新的生命力。本文將著重討論HTML5中的Web Forms 2.0, 即表單的部分。

表單是網頁中常見的控件(集)。小到網站注冊登錄，大到一個企業的數據管理系統，都基本上有表單的身影。表單之所以如此重要，主要是因為它擔負大量的用戶和網頁后臺數據更新交互的任務。Web開發人員，對于網頁表單可以說又愛又恨，愛的是它方便的收集、組織數據的功能，恨的是它的功能很大程度上也就僅此而已。一些在最終網站用戶看起來稀松平常的功能，比如說輸入類型檢查、表單校驗、錯誤提示等等，開發人員無不需要花費大量精力利用 JavaScript和DOM編程來滿足這些天然所需的功能點，而隨著Ajax的流行，出現的一些JavaScript的工具庫，比如Dojo, YUI等都提供了方便的JavaScript Widget或者API來減輕開發人員的負擔。

HTML5的表單新特性

HTML5 Web Forms 2.0是對目前Web表單的全面提升，它在保持了簡便易用的特性的同時，增加了許多內置的控件或者控件屬性來滿足用戶的需求，并且同時減少了開發人員的編程。在我看來，HTML5 主要在以下幾個方面對目前的Web表單做了改進：

• 新的控件類型
  • 還在為類型檢查犯愁嗎，還在為那一長串看不太明白的檢驗輸入的正則表達式而苦惱嗎，HTML5提供的一系列新的控件將天然的具備類型檢查的功能。比如說URL輸入框，Email輸入框等。
    

    <input type="url"></input>
    
            <input type="email"></input>
            

  • 當然還有非常重要的日期輸入框，要知道使用JavaScript和CSS來“手工”制作一個日期輸入框還是非常花功夫的，類似Dojo，YUI這樣的類庫也無不在這個widget上面大做文章。
    

    <input type="date"></input>

  • 作為我痛苦記憶的一部分，我經常記得我們開發人員要為一個select下拉別表動態的添加非常多的選項,這些選項大多數都是來自數據庫，比如說國家、省市列表等等。這個事情非常繁瑣。HTML5將支持data屬性，為select控件外聯數據源！
    

    <select data="http://domain/getmyoptions"></select>

• 改進的文件上傳控件，你可以使用一個控件上傳多個文件，自行規定上傳文件的類型（accept），你甚至可以設定每個文件最大的大小（maxlength）。你看出它和一般操作系統提供的文件上傳控件的區別了嗎，反正我覺得基本一致了。在HTML5應用中，文件上傳控件將變得非常強大和易用。
• 重復（repeat）的模型，HTML5提供一套重復機制來幫助我們構建一些重復輸入列表，其中包括一些諸如 add、remove、move-up，move-down的按鈕類型，通過這一套重復的機制，開發人員可以非常方便的實現我們經常看到的編輯列表，這是一個很常見的模式，我們可以增加一個條目、刪除某個條目、或者移動某個條目等等。
• 內建的表單校驗系統，HTML5為不同類型的輸入控件各自提供了新的屬性，來控制這些控件的輸入行為，比如我們常見的必填項required屬性，以及為數字類型控件提供的max、min等。而在你提交表單的時候，一旦校驗錯誤，瀏覽器將不執行提交操作，而會顯示相應的檢驗錯誤信息。

  <input type="text" required></input>
  
      <input type="number" min=10  max=100></input>

• XML Submission，我們一般常見的是form的編碼格式是application/x-www-form-urlencoded。開發人員都很清楚這種格式，數據送到服務器端，可以方便的存取。HTML5將提供一種新的數據格式：XML Submission，即application/x-www-form+xml。簡單的舉例說，服務器端將直接接收到XML形式的表單數據。
  

  <submission>
  
          <field name="name" index="0">Peter</field>
  
          <field name="password" index="0">password</field>
  
      </submission>

實例分析

我將利用HTML5新的表單系統, 做一個簡單的用戶注冊的界面，包括用戶名，密碼，出生日期，保密問題等內容，代碼如下：

<! doctype html>
<html>
<head>
<style>
p label {
width: 180px;
float: left;
text-align: right;
padding-right: 10px
}
table {
margin-left: 80px
}
table td {
border-bottom: 1px solid #CCCCCC
}
input.submit {
margin-left: 80px
}
</style>
</head>
<body>
<form action='/register' enctype="application/x-www-form+xml" method="post">
<p>
<label for='name'>ID(請使用Email注冊)</label>
<input name='name' required type='email'></input>
</p>
<p>
<label for='password'>密碼</label>
<input name='password' required type='password'></input>
</p>
<p>
<label for='birthday'>出生日期</label>
<input type='date' name='birthday' />
</p>
<p>
<label for='gender'>國籍</label>
<select name='country' data='countries.xml'></select>
</p>
<p>
<label for='photo'>個性頭像</label>
<input type='file' name='photo' accept='image/*' />
</p>
<table>
<thead>
<td><button type="add" template="questionId">+</button> 保密問題</td>
<td>答案</td>
<td></td>
</thead>
<tr id="questionId" repeat="template" repeat-start="1" repeat-min="1" repeat-max="3">
<td><input type="text" name="questions[questionId].q"></td>
<td><input type="text" name="questions[questionId].a"></td>
<td><button type="remove">刪除</button></td>
</tr>
</table>
<p>
<input type='submit' value='send' class='submit' />
</p>
</form>
</body>
</html>

由于目前HTML5標準仍然在開發中，不同的瀏覽器對HTML5特性的支持都相當有限。其中Opera在表單方面支持得比較好，本實例在Opera9上運行一切正常，效果圖如下：

這個實例運用了一些HTML5的新的表單元素，比如email類型的輸入框(ID)，日期類型的輸入框(出生日期)。并且使用了重復模型來引導用戶填寫保密問題，而在個性頭像的上傳中，通過限制文件類型，方便用戶選擇圖片進行合乎規范的內容上傳。而用戶選擇國籍的下拉選擇輸入框中，采用的是外聯數據源的形式，外聯數據源使用coutries.xml，內容如下：

<select xmlns="http://www.w3.org/1999/xhtml">
<option>China</option>
<option>Japan</option>
<option>Korea</option>
</select>

并且form的enctype是application/x-www-form+xml，也就是HTML5的XML提交。所以一旦form校驗通過，form的內容將會以XML的形式提交。你還會發現，在ID輸入框如果沒有值，或者輸入了非email類型的字符串時，一旦試圖提交表單，就會有提示錯誤的信息出現，而這都是瀏覽器內置的。

結語

HTML5對表單控件的更新，無疑是很振奮人心的。本文描述了一部分表單的新特性，還有一部分新特性同樣很令人期待。相信隨著標準的深入開發以及瀏覽器對HTML5支持程度的進一步提升，設計一個簡單易用的表單的工作，將變得非常輕松。

參考資料

1. W3C HTML5 規范： http://www.w3.org/TR/html5/
2. HTML5 與 HTML4的差異：http://www.w3.org/TR/html5-diff/
3. Opera dev: Improve your forms with HTML5： http://dev.opera.com/articles/view/improve-your-forms-using-html5/
4. Comparison of layout engines（HTML5）：
   http://en.wikipedia.org/wiki/Comparison_of_layout_engines_(HTML_5)

關于作者

蔣博，主要從事Web前端技術的開發工作，在Web開發與性能分析以及敏捷實踐等領域有較豐富的經驗。對HTML5的發展以及各種 JavaScript類庫有比較濃厚的興趣，經常關注社交型的網站發展情況，平常喜歡聽音樂，看一些歷史類書籍。（本文僅代表個人觀點，與公司立場無關。）

---

給InfoQ中文站投稿或者參與內容翻譯工作，請郵件至editors@cn.infoq.com。也歡迎大家加入到InfoQ中文站用戶討論組中與我們的編輯和其他讀者朋友交流。

    看完這本書給我的感覺，比較實在，基本上對spring有個初步的認識。
    接下來我會接著看<Spring參考手冊>，這樣更好的理解Spring這個輕量級的框架。
    
    從縱向第三方框架集成方面講
    1、 web層的集成
           spring對于web層集成外部框架有：Struts、webwork、Tapestry、JSF、Dinamica、VRaptor
    2、DAO層的集成
            spring對于DAO層集成外部框架有：Hibernate、Ibatis、JDO

    事務處理上，Spring可以利用不同的事務管理對象進行事務上的配置，根據不同的數據層環境而定。   Spring的容器事務主要是基于動態AOP來處理。
 下面這段xml配置片斷展示了Spring中的事務設定方式：
<beans>
     <bean id="dataSource"
                class="org.apache.commons.dbcp.BasicDataSource"
                destroy-method="close">
              <property name="driverClassName">
                       <value>org.gjt.mm.mysql.Driver</value>
              </property>
              <property name="url">
                        <value>jdbc:mysql://localhost/sample</value>
             </property>
             <property name="username">
                       <value>user</value>
             </property>
             <property name="password">
                        <value>mypass</value>
              </property>
       </bean>
      <bean id="transactionManager"
                 class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
                 <property name="dataSource">
                      <ref local="dataSource" />
                 </property>
       </bean>
        <bean id="userDAO" class="net.xiaxin.dao.UserDAO">
                  <property name="dataSource">
                        <ref local="dataSource" />
                 </property>
         </bean>
        <bean id="userDAOProxy"
                   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
                 <property name="transactionManager">
                          <ref bean="transactionManager" />
                 </property>
                 <property name="target">
                         <ref local="userDAO" />
                 </property>
                  <property name="transactionAttributes">
                         <props>
                            <prop key="insert*">PROPAGATION_REQUIRED</prop>
                            <prop key="get*">
                               PROPAGATION_REQUIRED,readOnly
                             </prop>
                           </props>
                    </property>
             </bean>
</beans>

------------------------------------------------------------------------------------------------------------------------------------------------------------------
EJB事務處理與Spring事務處理的區別，關鍵兩點：
1、Spring可以將任意Java Class 納入事務管理這里的UserDAO只是我們編寫的一個普通Java Class，其中包含了一些基本的數據應用邏輯。通過Spring，我們即可簡單的實現事務的可配置化。也就是說，我們可以隨意為某個類的某個方法指定事務管理機制。與之對比，如果使用EJB容器提供的事務管理功能，我們不得不按照EJB規范編將UserDAO 進行改造，將其轉換為一個標準的EJB。
2、Spring事務管理并不依賴特定的事務資源。EJB 容器必須依賴于JTA 提供事務支持。而Spring 的事務管理則支持JDBC、JTA 等多種事務資源。這為我們提供了更多的選擇，從而也使得我們的系統部署更加靈活。
  模板技術相對傳統JSP技術有以下三個主要的優勢：
   1、表現邏輯與業務邏輯的分離
   2、將UI和程序分離，即將美工人員和程序員分離
   3、如果需要，模板引擎可以脫離web容器單獨運行，為系統可能的移植需求提供了更多的彈性空間

   目前spring支持以下模板技術： 
   1、XSLT
         XSLT的性能相對較低，因為在XSLT中，每個節點都是一個java對象，大量對象的存儲對內存占用極大，同時大量對象的頻繁創建和銷毀也對JVM垃圾收集產生了較大的負面影響。
   2、Velocity
         目前最為成熟的模板技術，它是apache jakarta項目中的一個子項目。
   3、FreeMarker
         對于web開發而言，FreeMarker在生產效率和學習成本上更具優勢，而velocity的相對優勢在于更多第三方工具的支持和更廣泛的開發和用戶團體。
       對于web應用，spring提供了可配置的ApplicatonContext加載機制；加載器目前有兩種加載選擇：ContextLoaderListener和ContextLoaderServlet

    加載器目前有兩種選擇：ContextLoaderListener和ContextLoaderServlet。這兩者在功能上完全等同，只是一個是基于Servlet2.3版本中新引入的Listener接口實現，而另一個基于Servlet接口實現。開發中可根據目標Web容器的實際情況進行選擇。

在web.xml中增加：
<listener>
    <listener-class>
         org.springframework.web.context.ContextLoaderListener
     </listener-class>
</listener>
-----------------------------------------------------------------
<servlet>
      <servlet-name>context</servlet-name>
      <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
</servlet>
通過以上配置，Web容器會自動加載/WEB-INF/applicationContext.xml初始化

如果需要指定配置文件位置，可通過context-param加以指定
<context-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>/WEB-INF/myApplicationContext.xml</param-value>
</context-param>

  這個文檔的作者是夏昕。先看看這個文檔的內容，在作出評論！！ 
  看了spring初探這一章，給我的感覺就是利用java的反射機制，和hibernate差不多！！
 
  控制反轉 IOC（Inversion of control）：由容器控制程序之間的關系，而非傳統實現中，有程序直接操控。
  依賴注入DI（Dependency injection）：組件之間的依賴關系由容器在運行期決定，即由容器動態的將某種依賴關系注入到組件中。
 
 依賴注入的特性：依賴注入機制減輕了組件之間的依賴關系，同時也大大地提高了組件的可移植性，這意味組件得到重用的機會將會更多！

 注入主要有：接口方式、參數方式、構造方式，其實我覺得參數和構造應該都屬于參數傳值的方式。 
 
 什么叫熱部署？
      熱部署指的是配置文件修改后自動被容器讀取，無需重新啟動應用服務器。

<beans>
     <description>Spring Quick Start</description>
     <bean id="messageSource"
               class="org.springframework.context.support.ResourceBundleMessageSource">
           <property name="basenames">
              <list>
                    <value>messages</value>
              </list>
           </property>
      </bean>
</beans>
這里聲明了一個名為messageSource的Bean（注意對于Message定義，Bean ID必須為messageSource，這是目前Spring的編碼規約），對應類為ResourceBundleMessageSource，目前Spring中提供了兩個MessageSource接口的實現，即ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，后者提供了無需重啟即可重新加載配置信息的特性。

注意：實際上Spring實用了jdk中的ResourceBundle來讀取配置文件

對于屬性文件中的國際化中文問題：可以利用JDK中的轉碼工具native2ascii.exe來進行轉換    從hibernate的概要圖上可以看出hibernate的主要是將對象模型轉換成關系模型的過程。
第二章看完了，感覺框架中涉及的關鍵性概念及作用要記住：
SessionFactory(org.hibernate.SessionFactory)
   針對單個數據庫映射關系經過編譯后的內存鏡像，是線程安全的（不可變）。它是生成Session的工廠，本身要用到ConnectionProvider。該對象可以在進程或集群的級別上，為那些事務之間可以重用的數據提供可選得二級緩存。
Session(org.hibernate.Session)
   表示應用程序與持久存儲層之間交互操作的一個單線程對象，此對象生存期很短。其隱藏了ＪＤＢＣ連接，也是Transaction的工廠。其會持有一個針對持久化對象的必選（第一級）緩存，在遍歷對象圖或者根據持久化標識查找對象時會用到。
-----------------------------------------------------------------------------------------------------------------
目前好像沒有什么感覺！！

什么瞬態(transient)\什么持久化(persistent)\什么脫管(detached)
把一個對象說的這么理論化，不知為何？？？
                                           我找來一本《hibernate的參考手冊-翻譯版本》
    我訪問http://www.hibernate.org.cn ，既然目前處于域名轉讓？？？不知何解！可能已經不用了，網上有些人說已經轉向www.javaeye.com上了。
    還有個網站：http://www.java99.com/
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   例子：
          使用JAVA 數據庫(HSQL DB)

          運行Hibernate所使用的最小的jar為：
                  antlr.jar;cglib.jar;asm.jar;asm-attrs.jar;commons-collections.jar;commons-logging.jar;ehcache.jar;hibernate3.jar;jta.jar;dom4j.jar;log4j.jar
          其中第三方庫jar需要看自身使用的情況而定。 

 hibernate是通過反射機制來實例化javaBean，javaBean中默認構造函數是不帶參數的。
 hibernate主要依賴于映射文件將對象模型轉換成關系模型。hibernate的配置文件中的DTD文件放在hibernate3.jar包中。 

 標識符生成策略：
<hibernate-mapping>
  <class name="events.Event" table="EVENTS">
     <id name="id" column="EVENT_ID">
         <generator class="native"/>
     </id>
  </class>
</hibernate-mapping>

native：根據已配置的數據庫(方言)自動選擇最佳的標識符生成策略。

看完了第一章內容，感覺所講的東西只是傳達一個比較初略的了解。其實第一章內容根本沒有很多必要寫出來。 project
<project name="" default="" basedir="">
</project>

name：工程名稱
default：構建文件中的一個目標名，如果在命令行沒有指定目標，則使用默認的目標
basedir：定義工程的根目錄，一般情況下為"."
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
target
以下目標將編譯一組文件，并將它們打包到一個名為finallib.jar的文件中
<target name="build-lib">
  <javac srcdir="${src.ejb.dir}:${src.java.dir}"
             destdir="${build.dir}"
             debug="on"
             deprecation="on"
             includes="**/*.java"
             excludes="${global.exclude}">
      <classpath>
         <pathelement location="."/>
         <pathelemetn location="${lib.dir}/somelib.jar"/>
      </classpath>
   </javac>
   <jar jarfile="${dist}/lib/finallib.jar" basedir="${build.dir}"/>
</target>
-------------------------------------------------------------------
<copy todir="${weblogic.dir}/${weblogic.server.home}/public_html/jsp">
  <fileset dir="${src.www.dir}/jsp"/>
</copy>
-------------------------------------------------
相關概念：
特性(property)：在構建文件中由<property>標簽表示的名-值對
DataType：一類表示復雜數據集合的元素，例如fileset和path
數據元素(data element)：這個詞涵蓋了特性和DataType

property
<property name="my.first.property" value="ignore me"/>
<property file="user.properties"/>

<property name="property.one" value="one"/>
<property name="property.two" value="${property.one}:two"/>
--------------------------------------------------------------------
<path id="classpath">
  <fileset dir="${lib.dir}">
      <include name="**/*.jar"/>
  </fileset>
</path>
-------------------------------------------------
<target name="" depends="bot">
 <mkdir dir="${doc.dir}/api"/>
 <javadoc packagenames="irssibot.*"
                sourcepath="${src.dir}"
                destdir="${doc.dir}/api"
                author="true"
                version="true"
                use="true">
       <classpath refid="classpath"/>
    </javadoc>
</target>
------------------------------------------------------------
<target name="clean">
    <delete>
        <fileset dir="${build.classes}" includes="**/*.class"/>
    </delete>
 </target>

<target name="cleanall" depends="clean">
   <delete dir="${build.dir}"/>
   <delete dir="${dist.dir}"/>
   <delete dir="${doc.dir}/api"/>
</target> 這一章沒有什么新意。但是有一個點就是網絡任務需要關注一下

真搞不懂，一本書怎么寫這么多的文字，簡直多余！！
一個ANT寫這么厚？？？？？

我看的書籍是<Ant權威指南>，Ant的開發者：James Duncan Davidson。對于一些比較重要的內容我記錄了下來：
ANT命令行參考
ant [option [option...]] [target [target...]]
option :={-help：顯示描述Ant命令及其選項的幫助信息
               -projecthelp：顯示包含在構建文件中的、所有用戶編寫的幫助文檔。即為各個<target>中description屬  性的文本，以及包含在<description>元素中的任何文本。將有description屬性的目標列為主目標("Main target")，沒有此屬性的目標則列為子目標("subtarget")
               -version：要求Ant顯示其版本信息，然后退出
               -quiet：抑制并非由構建文件中的echo任務所產生的大多數信息
               -verbose：顯示構建過程中每個操作的詳細消息。此選項與-debug選項只能選其一
               -debug：顯示Ant和任務開發人員已經標志為調試消息的消息。此選項與-verbose只能選其一
               -emacs：對日志消息進行格式化，使它們能夠很容易地由Emacs的shell模式(shell-mode)所解析；也就是說，打印任務事件，但并不縮排，在其之前也沒有[taskname]
               -logfile filename：將日志輸出重定向到指定文件
               -logger classname：指定一個類來處理Ant的日志記錄。所指定的類必須實現了org.apache.tools.ant.BuildLogger接口
               -listener classname：為Ant聲明一個監聽類，并增加到其監聽者列表中。在Ant與IDE或其他Java程序集成時，此選項非常有用
               -buildfile filename：指定Ant需要處理的構建文件。默認的構建文件為build.xml
               -Dproperty=value：在命令行上定義一個特性名--值對
               -find filename：指定Ant應當處理的構建文件。與-buildfile選項不同，如果所指定文件在當前目錄中未找到，-find就要求Ant在其父目錄中再進行搜索。這種搜索會繼續在其祖父目錄中進行，直至達到文件系統的根為止，在此如果文件還未找到，則構建失敗
               }

     突然想學習學習Java-PetStore2.0，感覺比較有趣，學習一個Java-PetStore就涉及到GlassFish2.1、db-Derby-10.1.2.1、IDE-NetBeans6.5.1、Ant1.7.1，一堆的工具，java-PetStore2.0是一個netBeans工程，直接使用NetBeans就可以打開，也可以使用Ant操作；工程中所涉及的服務器GlassFish和數據庫Derby，NetBeans都已經為你準備好了。
     ANT一直都沒有好好的去學習過，現在打算先把ANT看看！！


-------------------------------------------------------------------------------------------
    在開發的過程中，我們可能需要將生產環境和調試環境分開來，這樣才能保證安全性，但是安裝兩個glassfish又不太可能，因為它太龐大了。另外做為一個工程發布也不太方便，每次都要將工程名改來改去，并且綁定的EJB在同一個域內里是不能同名的。這樣的話，要改變的東西實在是太多了。
    我們可有以第三種方法，那就是為glassfish添加另外的domain，一個domain跑我們的真實環境，一個domain跑我們的測試環境，因為是同一個glassfish，所以也不會存在從測試到真實環境的移植問題。以后只要改一個domain就可以了。我們在安裝glassfish的時候，它已經默認為我們安裝了一個domain，那就是domain1.
    我們查看setup.xml里面可以看出，是如何新建domain的，于是我們把我們需要的一些target提取了出來，見如下。下面的配置里面唯一可能需要改變的就是glassfish安裝目錄這個屬性了，其它可以按照我配的來，也可以自己修改。



然后用ant執行它就可以了，我這里的執行輸出如下：



這樣我們就可以看到glassfish的domains目錄下面，多出了一個domain3這個文件夾。然后有關數據庫連接池啊什么的，就可以到該目錄下面的config/domain.xml去改了，domain.xml里面的屬性我們以后有時候再好好研究一下。當然，我們也可以去glassfish的控制臺進行可視化修改，glassfish的控制臺是所有的應用服務器里面做得最好的一個了。訪問的端口就是我們新建domain的時候用到的admin.port的這個屬性。
三種依賴范圍：compile，test，provided,runtime,test,system

compile（編譯范圍）

compile是默認的范圍；如果沒有提供一個范圍，那該依賴的范圍就是編譯范圍。編譯范圍依賴在所有的classpath中可用，同時它們也會被打包。

provided（已提供范圍）

provided依賴只有在當JDK或者一個容器已提供該依賴之后才使用。例如，如果你開發了一個web應用，你可能在編譯classpath中需要可用的Servlet API來編譯一個servlet，但是你不會想要在打包好的WAR中包含這個Servlet API；這個Servlet API JAR由你的應用服務器或者servlet容器提供。已提供范圍的依賴在編譯classpath（不是運行時）可用。它們不是傳遞性的，也不會被打包。

runtime（運行時范圍）

runtime依賴在運行和測試系統的時候需要，但在編譯的時候不需要。比如，你可能在編譯的時候只需要JDBC API JAR，而只有在運行的時候才需要JDBC驅動實現。

test（測試范圍）

test范圍依賴在一般的 編譯和運行時都不需要，它們只有在測試編譯和測試運行階段可用。

system（系統范圍）

system范圍依賴與provided類似，但是你必須顯式的提供一個對于本地系統中JAR文件的路徑。這么做是為了允許基于本地對象編譯，而這些對象是系統類庫的一部分。這樣的構件應該是一直可用的，Maven也不會在倉庫中去尋找它。如果你將一個依賴范圍設置成系統范圍，你必須同時提供一個systemPath元素。注意該范圍是不推薦使用的（你應該一直盡量去從公共或定制的Maven倉庫中引用依賴）。

 

依賴版本界限：

(?, ?) 不包含量詞。意思為：?<xx<?

[?, ?] 包含量詞。意思為：？<=xx<=?

例如：指定一個依賴界限：JUnit 3.8 - JUnit 4.0

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>[3.8,4.0)</version>
<scope>test</scope>
</dependency>

 

查看有效的pom—〉mvn help:effective-pom
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Maven中的版本包含了以下部分：主版本，次版本，增量版本，和限定版本號;一個版本中，這些部分對應如下的格式:

<major version>.<minor version>.<incremental version>-<qualifier>

Maven提供了三個隱式的變量，可以用來訪問環境變量，POM信息，和Maven Settings.

env變量:暴露了你操作系統或者shell的環境變量

project變量暴露了POM。

settings變量暴露了Maven settings信息。

除了這三個隱式的變量，你還可以引用系統屬性，以及任何在Maven POM中和構建profile中自定義的屬性組

 

自定義屬性:

<properties>
<foo>bar</foo>
</properties>

 

超級POM
所有的Maven項目的POM都擴展自超級POM。你可以在${M2_HOME}/lib中的maven-2.0.9-uber.jar文件中找到pom-4.0.0.xml。
超級pom：
<project>
  <modelVersion>4.0.0</modelVersion>
  <name>Maven Default Project</name>

  <repositories>
    <repository>
      <id>central</id>
      <name>Maven Repository Switchboard</name>
      <layout>default</layout>
      <url>http://repo1.maven.org/maven2</url>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>central</id>
      <name>Maven Plugin Repository</name>
      <url>http://repo1.maven.org/maven2</url>
      <layout>default</layout>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
      <releases>
        <updatePolicy>never</updatePolicy>
      </releases>
    </pluginRepository>
  </pluginRepositories>

  <build>
    <directory>target</directory>
    <outputDirectory>target/classes</outputDirectory>
    <finalName>content-zh-0.5</finalName>
    <testOutputDirectory>target/test-classes</testOutputDirectory>
    <sourceDirectory>src/main/java</sourceDirectory>
    <scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
    <testSourceDirectory>src/test/java</testSourceDirectory>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>src/test/resources</directory>
      </testResource>
    </testResources>
  </build>

      <pluginManagement>
       <plugins>
         <plugin>
           <artifactId>maven-antrun-plugin</artifactId>
           <version>1.1</version>
         </plugin>      
         <plugin>
           <artifactId>maven-assembly-plugin</artifactId>
           <version>2.2-beta-1</version>
         </plugin>
         <plugin>
           <artifactId>maven-clean-plugin</artifactId>
           <version>2.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>2.0.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-dependency-plugin</artifactId>
           <version>2.0</version>
         </plugin>
         <plugin>
           <artifactId>maven-deploy-plugin</artifactId>
           <version>2.3</version>
         </plugin>
         <plugin>
           <artifactId>maven-ear-plugin</artifactId>
           <version>2.3.1</version>
         </plugin>
         <plugin>
           <artifactId>maven-ejb-plugin</artifactId>
           <version>2.1</version>
         </plugin>
         <plugin>
           <artifactId>maven-install-plugin</artifactId>
           <version>2.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-jar-plugin</artifactId>
           <version>2.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-javadoc-plugin</artifactId>
           <version>2.4</version>
         </plugin>
         <plugin>
           <artifactId>maven-plugin-plugin</artifactId>
           <version>2.3</version>
         </plugin>
         <plugin>
           <artifactId>maven-rar-plugin</artifactId>
           <version>2.2</version>
         </plugin>
         <plugin>               
           <artifactId>maven-release-plugin</artifactId>
           <version>2.0-beta-7</version>
         </plugin>
         <plugin>               
           <artifactId>maven-resources-plugin</artifactId>
           <version>2.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-site-plugin</artifactId>
           <version>2.0-beta-6</version>
         </plugin>
         <plugin>
           <artifactId>maven-source-plugin</artifactId>
           <version>2.0.4</version>
         </plugin>        
         <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.4.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-war-plugin</artifactId>
           <version>2.1-alpha-1</version>
         </plugin>
       </plugins>
     </pluginManagement>
 
  <reporting>
    <outputDirectory>target/site</outputDirectory>
  </reporting>
</project>

1).默認的超級POM定義了一個單獨的遠程Maven倉庫，ID為central,這是所有Maven客戶端默認配置訪問的中央Maven倉庫;該配置可以通過一個自定義的settings.xml文件來覆蓋,注意這個默認的超級POM關閉了從中央Maven倉庫下載snapshot構件的功能。如果你需要使用一個snapshot倉庫，你就要在你的pom.xml或者settings.xml中自定義倉庫設置.
2)build元素設置Maven標準目錄布局中那些目錄的默認值.
3)POM中定義的groupId，artifactId和version：這三項是所有項目都需要的坐標


groupId

一個groupId歸類了一組相關的構件。組定義符基本上類似于一個Java包名。例如：groupId org.apache.maven是所有由Apache Maven項目生成的構件的基本groupId。組定義符在Maven倉庫中被翻譯成路徑，例如，groupId org.apache.maven可以在repo1.maven.org的/maven2/org/apache/maven目錄下找到。

artifactId

artifactId是項目的主要定義符。當你生成一個構件，這個構件將由artifactId命名。當你引用一個項目，你就需要使用artifactId來引用它。artifactId和groupId的組合必須是唯一的。換句話說，你不能有兩個不同的項目擁有同樣的artifactId和groupId；在某個特定的groupId下，artifactId也必須是唯一的。

version

當一個構件發布的時候，它是使用一個版本號發布的。該版本號是一個數字定義符如“1.0”，“1.1.1”，或“1.1.2-alpha-01”。你也可以使用所謂的快照（snapshot）版本。一個快照版是一個處于開發過程中的組件的版本，快照版本號通常以SNAPSHOT結尾；如，“1.0-SNAPSHOT”，“1.1.1-SNAPSHOT”，和“1-SNAPSHOT”。Section 9.3.1, “項目版本”介紹了版本和版本界限。

 

maven概念：Maven是一個項目管理工具，它包含了一個項目對象模型 (Project Object Model)，一組標準集合，一個項目生命周期(Project Lifecycle)，一個依賴管理系統(Dependency Management System)，和用來運行定義在生命周期階段(phase)中插件(plugin)目標(goal)的邏輯。

項目特征定義的特征：
 1).依賴管理：項目間可以使用這些坐標來聲明依賴；由于項目是根據一個包含組標識符，構件標識符和版本的唯一的坐標定義的。
 2).遠程倉庫：和項目依賴相關的，我們可以使用定義在項目對象模型（POM）中的坐標來創建 Maven 構件的倉庫。
 3).全局性構建邏輯重用：插件被編寫成和項目模型對象（POM）一起工作，它們沒有被設計成操作某一個已知位置的特定文件。一切都被抽象到模型中，插件配置和自定義行為都在模型中進行。
 4).工具可移植性/集成：像 Eclipse，NetBeans，和 InteliJ 這樣的工具現在有共同的地方來找到項目的信息。在 Maven 出現之前，每個 IDE 都有不同的方法來存儲實際上是自定義項目對象模型（POM）的信息。Maven 標準化了這種描述，而雖然每個 IDE 仍然繼續維護它的自定義項目文件，但這些文件現在可以很容易的由模型生成。
 5).便于搜索和過濾構件：像 Nexus 這樣的工具允許你使用存儲在 POM 中的信息對倉庫中的內容進行索引和搜索。

    項目管理只是時間上的管理。
    MOT是告訴你自己的內心，你應該怎么在社會上去做人。
    其實我覺得做人是由后天性格+先天意識行為組合而成，而并不能由于某種培訓和讀書就能夠改變本身個人后天形成的性格問題。
    再者我們再回過頭來思考，我們先天意識行為是怎么樣產生的。

            1、想法不結合實際的情況
            2、直接插足項目工作的安排
            3、對管理上的專業知識不強
            4、想到什么做什么，沒有顧及后果或者以后產生的問題
            5、沒有針對問題去解決問題，反而火上加火
            6、相互的推讓問題的責任，嘴上說對責任要勇于承擔，但是自己卻在逃避
            7、不懂得怎么去管理人和協調人員的關系