2. 程式人生 > >Spring Web Flow 2.0 入門詳解

Spring Web Flow 2.0 入門詳解

阿新 • • 發佈：2019-02-11

目錄：

  1. 參考文獻
  2. 購物車用例
  3. 什麼情況下可以使用 Spring Web Flow？
  4. 配置 Spring Web MVC
  5. 配置 Spring Web Flow 2.0 的基礎
  6. 在購物車示例應用中配置 Spring Web Flow
  7. 用 Unified EL 實現業務邏輯
  8. 用 subflow 實現新增商品到購物車功能
  9. global transition 簡介

1.參考文獻

2.購物車用例

要了解 Spring Web Flow 是什麼東西，最好的辦法莫過於檢視示例，一個簡化的購物車的流程如下圖所示：

購物車示例

上圖 所示流程用 Spring Web Flow 2.0 的配置檔案表示如下清單 1：

清單 1 用 Spring Web Flow 語義表達購物車流程


……
<flow>
<view-state id="viewCart">
<transition on="submit" to="viewOrder"/>
</view-state>
<view-state id="viewOrder">
<transition on="confirm" to="viewConfirmed"/>
</view-state>
<view-state id="viewConfirmed">
<transition on="returnToIndex" to="returnToIndex"/>
</view-state>
<end-state id="returnToIndex"/>
</flow>

配置1中省略了許多技術細節，展示的只是一個業務的流程，主要是為了讓大家對 Spring Web Flow 的語義有個初始的印象。從配置 1 中，應注意到一個很重要的特徵—— Spring Web Flow 語義與 Servlet API 無關。更確切地講， Spring Web Flow 語義關注的是業務的流程，並未與 Sun 公司的 Web 規範緊密結合，這種描述是更高層次的抽象，差不多是在建模的角度來描述業務流程。

不過， Spring Web Flow 也並非只有抽象，現在還沒有哪一種工具或語言可以將一個模型直接轉換成相應的應用程式。 Spring Web Flow 更像是抽象建模和技術細節的混血兒，相比於湮沒在繁多的控制器和檢視中的 Web MVC 應用來講， Spring Web Flow 提供瞭如清單 1 所描述的更高層次的抽象，但同時它也整合了像 Unified EL 這樣的工具來控制技術上的細節。

Spring Web Flow 的基本元素

Flow 可看作是客戶端與伺服器的一次對話（ conversation ）。 Flow 的完成要由分多個步驟來實現，在 Spring Web Flow 的語義中，步驟指的就是 state 。Spring Web Flow 提供了五種 state ，分別是 Action State 、 View State 、 Subflow State 、 Decision State 、 End State ，這些 state 可用於定義 flow 執行過程中的各個步驟。除了 End State 外，其他 state 都可以轉換到別的 state ，一般通過在 state 中定義 transition 來實現到其他 state 的轉換，轉換的發生一般由事件（ event ）來觸發。

3.什麼情況下可以使用 Spring Web Flow？

前面講了， Spring Web Flow 提供了描述業務流程的抽象能力，但對一種 Web 開發技術而言，僅有這些是不夠的。同時， Spring Web Flow 是不是能夠取代其他 Web MVC 技術？或者在任何情況下都應優先使用 Spring Web Flow ？要回答這些問題，先來看一下 Spring Web Flow 所著力解決的技術問題。

3.1.Web 應用程式的三種範圍

Java Servlet 規範為 Web 應用程式中用到的各種物件規定了三種範圍（ scope ），分別是 request 範圍、 session 範圍和 application 範圍。

  1. request 範圍中的物件是跟客戶的請求繫結在一起的，每次請求結束都會銷燬物件，而新的請求過來時又會重新建立物件。 request 範圍適合存放資料量較大的臨時資料。
  2. session 範圍中的物件是跟會話（ session ）繫結在一起的，每次會話結束會銷燬這些物件，而新的會話中又會重新建立。 HTTP 協議本身是無狀態的，伺服器和客戶端要實現會話的管理，只能藉助於一些輔助的手段，如在協議的資料包中加一些隱藏的記號，等等。session 範圍適合存放本次會話需要保留的資料。
  3. application 範圍的物件是跟應用程式本身繫結在一起，從 Servlet API 的角度來講，就是存放在 ServletContext 中的物件，它們隨著 Servlet 的啟動而建立， Servlet 關閉時才會銷燬。application 範圍適合存放那些與應用程式全域性相關的資料。

現實開發中最令人頭痛的莫過於 session 範圍， Java Servlet 規範指明可在 web.xml 中按如下方式配置 session 的有效時間為100分鐘，如下清單 2所示：
清單 2 web.xml 中 session 的配置

<session-config>
    <session-timeout>100</session-timeout>
</session-config>

然而，現實中的 session 範圍更像是“雞肋”，把大量資料放入 session 會導致嚴重的效率問題，在分散式的環境中處理 session 範圍更是一不小心就會出錯，但拋棄 session 又會給開發帶來許多不便。 request 範圍雖說能存放量大的資料，但有效範圍有限。擺在開發者面前的很多用例都要求一種比 request 範圍要長，但又比 session 範圍要短的這麼一種有效範圍。

3.2.Spring Web Flow 的解決方案

針對 Java Servlet 規範中的這個缺陷， Spring Web Flow 2.0 中提供了以下兩種範圍：

  1. flow 範圍。此範圍內的物件在 flow 開始時建立， flow 結束時銷燬，在 flow 定義檔案中可通過“ flowScope ”變數名來訪問。
  2. conversation 範圍。此範圍內的物件與 flow 範圍物件基本相似，唯一不同在於 conversation 範圍內的物件所在的 flow 如果呼叫了其他 subflow ，那麼在 subflow 中也可訪問該物件。（也就是說：subflow中能夠訪問conversation中的物件）

subflow 定義：被其他 flow 所呼叫的 flow 即可稱為 subflow。

由於 flow 是由開發人員自己定義的，可根據業務的需求自由改變， flow 範圍和 conversation 範圍的使用也就突破了 Java Servlet 規範中 session 範圍和 request 範圍的侷限，真正做到了自由定製。

3.3.並非所有情形都適用 Spring Web Flow

可以看出， Spring Web Flow 所著力解決的問題即是客戶端與伺服器的對話（ conversation ）問題，這個範圍比 request 要長，而比 session 要短。為實現 conversation 範圍（即 flow 範圍），需要付出效率上的代價，因此，並非所有 Web 應用都適合使用 Spring Web Flow 。 Seth Ladd 等人所著 Expert Spring MVC and Web Flow 一書，對何時使用Spring Web Flow，列出瞭如下表格。

表 1 何時使用 Spring Web Flow
解決方案 何時使用
Spring MVC Controller 某個單獨的、只需較少業務邏輯就可建立的頁面，同時該頁面不是 flow 的一部分
Spring MVC SimpleFormController 某個只涉及表單提交的頁面，如一個搜尋框
Spring MVC AbstractWizardFormController 由一系列導航頁面組成的業務過程
Spring Web Flow 任何比較複雜的、有狀態的、需要在多個頁面之間跳轉的業務過程

3.4.Spring Web Flow 的其他特點

Web Flow 作為一個單獨的概念被提出來，也可算是 Spring Web Flow 的一大亮點。目前大多數 Web MVC 框架都把重點把在各種 controller 和形形色色的 view 技術上面，對 Web 應用流程本身的關注是不夠的， Web Flow 的提出就提供了一層抽象，設計者就可以從 Web Flow 抽象層面來進行設計、開發。當然， Web Flow 不能理解為只是 Web 頁面間的跳轉流程，定義 Spring Web Flow 的語義並非只限於頁面之間的跳轉，而可以是 Web 應用中的各種行為。由此，用例的模型建構好以後，就可直接從該模型轉換到相應的 Web Flow，開發人員的設計變得更加直觀、有效。

另外，在 Spring Web Flow 中重用 Web Flow 是比較容易的。在定義 flow 、 state 時可通過繼承某個已有的 flow 或 state ，來避免重複定義。同時，一個 flow 可以呼叫其它 flow ，就跟一般程式語言中在某個函式內部呼叫其它函式一樣方便。

4.配置 Spring Web MVC

Spring Web Flow 2.0 就是 Spring Web MVC 的一個擴充套件，如果粗略一些來講，所謂 flow 就相當於 Spring Web MVC 中一種特殊的 controller ，這種 controller 可通過 XML 檔案加以配置，因此在使用 Spring Web Flow 2.0 前須先對 Spring Web MVC進行配置，步驟如下：
  1. 建立 Web 應用的目錄結構
  2. 在 /WEB-INF/lib 下匯入相關類庫
  3. 在 Web 應用部署描述符檔案 web.xml 中宣告 DispatcherServlet 並指定配置檔案
  4. 新增 DispatcherServlet 對映
  5. 建立 web-application-config.xml 檔案
  6. 建立 webmvc-config.xml 檔案
  7. 建立 index.jsp
  8. 建立 Web 應用的目錄結構
本示例應用將採用 eclipse Dynamic Web Project 嚮導預設生成的目錄結構，在 WEB-INF 目錄下新增 config 和 flows 子目錄，其中 config 子目錄用來存放各種配置檔案， flows 子目錄下存放 Spring Web Flow 的定義檔案。最後目錄如圖3所示：


4.1.宣告 DispatcherServlet 並指定配置檔案

為使用 Spring Web MVC ，須在 web.xml 中宣告 DispatcherServlet ，見清單 3 ：

清單 3 宣告 DispatcherServlet 和指定配置檔案
<servlet>
  <servlet-name>CartServlet</servlet-name>
  <servlet-class>
  org.springframework.web.servlet.DispatcherServlet
  </servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name> 
    <param-value> 
	/WEB-INF/config/web-application-config.xml 
	</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup>
</servlet>

4.2.新增 DispatcherServlet 對映

要讓 DispatcherServlet 處理所有以 /spring/ 開頭的請求，見清單4 ：

清單 4 web.xml 中的 DispatcherServlet對映
<servlet-mapping>
<servlet-name>CartServlet</servlet-name>
<url-pattern>/spring/*</url-pattern>
</servlet-mapping>

4.3.建立 web-application-config.xml

開發基於 Spring Web Flow 的應用往往會有大量的配置，這些配置全放在一個檔案中是不合適的。本示例參考 Spring Web Flow 2.0 自帶示例（可以找找看），將不同功能的配置檔案分開。其中 web-application-config.xml 用於配置與 Web 應用全域性相關的內容， Spring Web MVC 的相關配置放在 webmvc-config.xml 中，教程後面要新增的 Spring Web Flow 的配置則放在 webflow-config.xml 中。在 web-application-config.xml 中用 import 元素匯入其他的配置檔案。 web-application-config.xml的內容見清單 5：

清單 5 web-application-config.xml

<?xml version="1.0" encoding="utf-8"?>
<beans 
  xmlns="http://www.springframework.org/schema/beans" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-2.5.xsd">
	<!-- 搜尋 samples.webflow 包裡的 @Component 註解，並將其部署到容器中 --> 
	<context:component-scan base-package="samples.webflow" /> 
	<!-- 啟用基於註解的配置 --> 
	<context:annotation-config /> 
	<import resource="webmvc-config.xml"/>
</beans>
注意：xml檔案內容最好頂行頂格寫，不然可能會出現一些錯誤。

加入註解功能是出於最後執行 Web Flow 示例的需要（後面使用到的時候會指明），在這裡只要知道註解功能已被啟用就可以了。

4.4.建立 webmvc-config.xml

webmvc-config.xml 主要用於配置 Spring Web MVC 。所要做的就是新增一個 viewResolver （檢視解析器），用於將檢視名解析成真實的檢視資源。另外，再配置好URL 請求的 handler （處理器），用於將 URL 請求定向到某個控制器，在本例中，用到的是 UrlFilenameViewController。

清單 6 webmvc-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
  xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd"> 
	<bean id="viewResolver" 
	  class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
	  <property name="viewClass" 
	  value="org.springframework.web.servlet.view.JstlView"/> 
	  <property name="prefix" value="/WEB-INF/jsp/"/> 
	  <property name="suffix" value=".jsp"/> 
	</bean> 
	<bean id="viewMappings" 
	  class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> 
	  <property name="defaultHandler">
	  <!-- UrlFilenameViewController 會將 "/index" 這樣的請求對映成名為 "index" 的檢視 --> 
	  <bean class="org.springframework.web.servlet.mvc.UrlFilenameViewController" /> 
	</property> 
  </bean>
</beans>

4.5.建立 index.jsp

現在的 index.jsp 只是顯示一行文字。

清單 7 index.jsp

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Cart Application</title>
  </head>
  <body>
    <h1>Hello!</h1>
  </body>
</html>

4.6.執行應用程式

將應用程式釋出到 Tomcat 容器，再通過 http://localhost:8080/CartApp/spring/index.jsp 訪問 index.jsp 頁面（應用程式所在資料夾名是 CartApp ），測試 Spring Web MVC 配置是否正確。如果一切正常，可得到如下頁面：


4.7.示例程式碼

5.0.配置 Spring Web Flow 2.0 的基礎

配置好 Spring Web MVC 的環境後，接下來就可以往裡面加入 Spring Web Flow 2.0 的配置。不過，要搞明白 Spring Web Flow 2.0 的配置，必須先要了解相關的理論知識。

5.1.FlowRegistry

FlowRegistry 是存放 flow 的倉庫，每個定義 flow 的 XML 文件被解析後，都會被分配一個唯一的 id ，並以 FlowDefinition 物件的形式存放在 FlowResigtry 中。 FlowRegistry 配置方式可參看清單 8。

清單 8 FlowRegistry 的配置

<webflow:flow-registry id="flowRegistry">
<webflow:flow-location path="/WEB-INF/flows/shopping.xml" id=”shopping”/>
</webflow:flow-registry>

說明：以下的示例清單中的 XML 配置元素預設使用了 webflow 名字空間，這也是 Spring Web Flow 習慣上的名字空間，參看教程後面 webflow-config.xml 檔案，可以更多瞭解 webflow 名字空間。

每個 flow 都必須要有 id 來標識，如果在配置中省略，那麼該 flow 預設的 id 將是該定義檔案（xml檔案）的檔名去掉字尾所得的字串（例如本例中如果去掉id="shopping"，那麼flow的id就是shopping.xml去掉字尾名.xml後的shopping作為id）。

5.2.FlowExecutor

FlowExecutor 是 Spring Web Flow 的一個核心介面，啟動某個 flow ，都要通過這個介面來進行。從配置角度來說，只要保證有個 FlowExecutor 就可以了， Spring Web Flow 的預設行為已經足夠。預設配置參看清單9。

清單 9 FlowExecutor 的配置

<webflow:flow-executor id="flowExecutor" />

5.3.哪個 flow 被執行了？

FlowRegistry 中註冊的 flow 可能會有多個，但前面介紹過，每個 flow 都會有 id ，沒有配置的，也會有個預設值， FlowExecutor 就是通過 id 來找出要執行的 flow 。至於這個 id ，則是要由使用者來指定的。在預設配置情況下，如果客戶端傳送瞭如下URL請求：http://localhost:8080/CartApp/spring/shopping。則從 Spring Web Flow 的角度來看，這個 URL 就表示客戶想要執行一個 id 為“ shopping ”的 flow ，於是就會在 FlowRegistry 中查詢名為“ shopping ”的 flow，由FlowExecutor負責執行。

5.4Spring Web Flow 如何與 Spring Web MVC 整合在一起？

客戶端傳送的請求，先會由 servlet 容器（本教程示例中即為 Tomcat ）接收， servlet 容器會找到相應的應用程式（本教程中即為 CartApp ），再根據 web.xml 的配置找到出符合對映條件的 servlet 來處理。 Spring Web MVC 中處理請求的 servlet 是 DispatcherServlet ，如果請求的路徑滿足 DispatcherServlet 的對映條件，則 DispatcherServlet 會找出 Spring IoC 容器中所有的 HandlerMapping ，根據這些 HandlerMapping 中匹配最好的 handler （一般情況下都是 controller ，即控制器）來處理請求。當 Controller 處理完畢，一般都會返回一個 view （檢視）的名字，DispatcherServlet再根據這個view的名字找到相應的檢視資源返回給客戶端。

搞清楚 Spring Web MVC 處理請求的流程後，基本上就可以明白要整合 Spring Web MVC 與 Spring Web Flow 所需要的配置了。為了讓客戶端的請求變成執行某個 flow 的請求，要解決以下幾個問題：

  1. 需要在某個 HandlerMapping 中配置負責處理 flow 請求的 handler （或 controller ）
  2. 該handler （或 controller ）要負責啟動指定的 flow
  3. flow 執行過程中以及執行完成後所涉及的檢視應呈現給客戶端

5.5.FlowHandler 和 FlowController

現在，需要一種接收執行 flow 的請求，然後根據請求來啟動相應 flow的handler （處理器）， Spring Web Flow 2.0 提供了兩種方案可供選擇。第一種方案是自己編寫實現了 FlowHandler 介面的類，讓這個類來實現這個功能。第二種方案是使用一個現成的叫做 FlowController 的控制器。第一種方案靈活性比較大，在許多場合可能也是唯一的選擇，但對每個 flow 都需要編寫相應的 FlowHandler 。本教程的示例採用第二種方案，對 FlowHandler 的介紹可參看 Spring Web Flow 2.0 自帶的文件。 FlowController 其實是個介面卡，一般來講，我們只要明白 FlowController 可根據客戶端請求的結尾部分，找出相應的 flow 來執行。配置 FlowController只需指定FlowExecutor即可，具體配置見清單10：

清單 10 FlowController 的配置
<bean id="flowController" class="org.springframework.webflow.mvc.servlet.FlowController">
    <property name="flowExecutor" ref="flowExecutor"/>
</bean>

另外還需在 HandlerMapping 中指明 /shopping.do 請求由 flowController 來處理，配置見清單11：

清單 11 在 viewMappings 中新增配置
<bean id="viewMappings"
		class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<!-- /shopping.do 請求由 flowController 來處理 -->
		<property name="mappings">
			<value> /shopping.do=flowController </value>
		</property>
......
	</bean>
需要指出的是，不管設成 /shopping.do 還是設成 /shopping ，或者 /shopping.htm ，效果都是一樣的， flowController 都會去找 id 為 shopping的flow來執行。

5.6.FlowBuilder Services

清單 8 所示 FlowRegistry 的配置，其中省略了 flow-registry 元素中一項比較重要的屬性， flow-builder-services 。 flow-builder-services 屬性的配置指明瞭在這個 flow-registry “倉庫”裡的 flow 的一些基本特性，例如，是用 Unified EL 還是 OGNL 、 model （模型）物件中的資料在顯示之前是否需要先作轉換，等等。在本示例中，我們需要在 flow-builder-services 屬性中指明 Spring Web Flow 中所用到的 view ，由 Spring Web MVC 的“ View Resolver ”來查詢，由 Spring Web MVC 的“ View Class”來解析，最後呈現給客戶。具體配置參看清單12：

清單 12 flow-builder-services 配置 
	<!--Web Flow 中的檢視通過 MVC 框架的檢視技術來呈現 -->
	<webflow:flow-builder-services id="flowBuilderServices" view-factory-creator="mvcViewFactoryCreator" />
	<!-- 指明 MVC 框架的 view resolver ，用於通過 view 名查詢資源 -->
	<bean id="mvcViewFactoryCreator" class="org.springframework.webflow.mvc.builder.MvcViewFactoryCreator">
		<property name="viewResolvers" ref="viewResolver" />
	</bean>

5.7.Spring Web Flow 2.0 配置小結

所有這些配置的目的無非是兩個：一是要讓客戶端的請求轉變成 flow 的執行，二是要讓 flow 執行過程中、或執行結束後得到的檢視能返還給客戶端。如果對這裡的講解還不是很清楚，可先看下一節實際的配置，再回過頭來看本章內容，以加深理解。

6.在購物車示例應用中配置 Spring Web Flow

實現示例應用的購物車流程，可按以下步驟操作：
  1. 在 /WEB-INF/lib 目錄下匯入相關類庫
  2. 在 webmvc-config.xml 中新增與 Spring Web Flow 整合的配置
  3. 新增 Spring Web Flow 的配置檔案 webflow-config.xml
  4. 新增 flow 定義檔案 shopping.xml
  5. 新增三個 jsp 頁面
  6. 修改 index.jsp

6.1.在 /WEB-INF/lib 目錄下匯入相關類庫

將以下幾個 jar 包匯入 /WEB-INF/lib 目錄：
  • org.springframework.webflow-2.0.2.RELEASE.jar
  • org.springframework.js-2.0.2.RELEASE.jar
  • org.springframework.binding-2.0.2.RELEASE.jar
  • jboss-el.jar

6.2.在 webmvc-config.xml 中新增配置

Spring Web MVC 相關的配置前面已經分析過了，完整的配置見清單 13 ：

清單 13 webmvc-config.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView">
		</property>
		<property name="prefix" value="/WEB-INF/jsp/">
		</property>
		<property name="suffix" value=".jsp">
		</property>
	</bean>
	<bean id="viewMappings"
		class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<!-- /shopping.do 請求由 flowController 來處理 -->
		<property name="mappings">
			<value> /shopping.do=flowController </value>
		</property>
		<property name="defaultHandler">
			<!-- UrlFilenameViewController 會將 "/index" 這樣的請求對映成名為 "index" 的檢視 -->
			<bean class="org.springframework.web.servlet.mvc.UrlFilenameViewController" />
		</property>
	</bean>
	<bean id="flowController" class="org.springframework.webflow.mvc.servlet.FlowController">
		<property name="flowExecutor" ref="flowExecutor" />
	</bean>
</beans>

6.3.新增配置檔案 webflow-config.xml

在 /WEB-INF/config 目錄下新增 webflow-config.xml 檔案， schema 名字空間可直接複製清單 14 中的內容。

清單 14webflow-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:webflow="http://www.springframework.org/schema/webflow-config"
	xsi:schemaLocation=" http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
    http://www.springframework.org/schema/webflow-config 
    http://www.springframework.org/schema/webflow-config/spring-webflow-config-2.0.xsd">
	<webflow:flow-executor id="flowExecutor" />
	<!-- 所有 flow的定義檔案它的位置在這裡進行配置， flow-builder-services 用於配置 flow 的特性 -->
	<webflow:flow-registry id="flowRegistry" flow-builder-services="flowBuilderServices">
		<webflow:flow-location path="/WEB-INF/flows/shopping.xml" id="shopping" />
		<webflow:flow-location path="/WEB-INF/flows/addToCart.xml" id="addToCart" />
	</webflow:flow-registry>
	<!--Web Flow 中的檢視通過 MVC 框架的檢視技術來呈現 -->
	<webflow:flow-builder-services id="flowBuilderServices" view-factory-creator="mvcViewFactoryCreator" />
	<!-- 指明 MVC 框架的 view resolver ，用於通過 view 名查詢資源 -->
	<bean id="mvcViewFactoryCreator" class="org.springframework.webflow.mvc.builder.MvcViewFactoryCreator">
		<property name="viewResolvers" ref="viewResolver" />
	</bean>
</beans>

webflow-config.xml 建立完成以後，不要忘記在 web-application-config.xml 中新增 import 元素，將 webflow-config.xml 檔案匯入。

清單 15 在 web-application-config.xml 中匯入 webflow-config.xml
<import resource="webflow-config.xml"/>

6.4.新增 flow 定義檔案 shopping.xml

在 /WEB-INF/flows 目錄下建立 shopping.xml 檔案，描述了圖 2 所示的流程。

清單 16 shopping.xml
<?xml version="1.0" encoding="UTF-8"?>
<flow xmlns="http://www.springframework.org/schema/webflow"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/webflow
 http://www.springframework.org/schema/webflow/spring-webflow-2.0.xsd">
 <!-- view-state中的view對應jsp資料夾中的jsp頁面，on是觸發事件，to對應state id -->
	<view-state id="viewCart" view="viewCart">
		<transition on="submit" to="viewOrder">
		</transition>
	</view-state>
	<view-state id="viewOrder" view="viewOrder">
		<transition on="confirm" to="orderConfirmed">
		</transition>
	</view-state>
	<view-state id="orderConfirmed" view="orderConfirmed">
		<transition on="returnToIndex" to="returnToIndex">
		</transition>
	</view-state>
	<end-state id="returnToIndex" view="externalRedirect:servletRelative:/index.jsp">
	</end-state>
</flow>

與清單 1 相比，在 view-state 元素中指定了 view 屬性的名字，這個名字也是 Spring Web MVC 中 viewResolver （在webmvc-config.xml中定義）所查詢的 view 的名字。從清單 16 的配置中可以知道，這三個 view-state 元素所對應的檢視資源分別應該是： viewCart.jsp 、 viewOrder.jsp 和 orderConfirmed.jsp 。清單 16 中最後的 end-state 指明瞭當 flow 執行結束後跳轉到初始的 index.jsp 頁面，在此處的 view 屬性的名字需要解釋一下。 externalRedirect 用在 view 名字中，表示所指向的資源是在 flow 的外部， servletRelative 則表明所指向資源的路徑起始部分與 flow 所在 servlet 相同。 Spring Web Flow 2.0還提供了其他幾個關鍵詞用於重定向，這裡就不多介紹了。

在webmvc-config.xml中定義的viewResolver如下所示：

<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView">
		</property>
		<property name="prefix" value="/WEB-INF/jsp/">
		</property>
		<property name="suffix" value=".jsp">
		</property>
	</bean>

這表示所有view-state中的view屬性同名對應到了/WEB-INF/jsp目錄下的.jsp檔案。

6.5.新增三個 jsp 頁面

在 /WEB-INF/jsp 目錄下建立三個 flow 所需的檢視資源。以下清單中只有viewCart.jsp給出完整的程式碼，其他兩個只給出 jsp 頁面中 body 元素以內的程式碼，其餘省略。
清單 17 viewCart.jsp
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>View Cart</title>
</head>
<body>
	<h1>View Cart</h1>
	<a href="${flowExecutionUrl}&_eventId=submit">Submit</a>
</body>
</html>
清單 18 viewOrder.jsp
<h1>Order</h1>
<a href="${flowExecutionUrl}&_eventId=confirm">Confirm</a>
清單 19 orderConfirmed.jsp
<h1>Order Confirmed</h1>
<a href="${flowExecutionUrl}&_eventId=returnToIndex">Return to index</a>

這幾個頁面都使用了變數 flowExecutionUrl ，表示 flow 執行到當前狀態時的 URL 。 flowExecutionUrl 的值已經由 Spring Web Flow 2.0 框架的程式碼進行賦值，並放入相應的 model 中供 view 訪問。 flowExecutionUrl 的值包含 flow 在執行過程中會為每一狀態生成的唯一的 key ，因此不可用其他手段來獲取。請求引數中 _eventId 的值與清單 16 中 transition 元素的 on 屬性的值是對應的，在接收到_eventId引數後，相應transition會被執行。

6.6.修改 index.jsp 頁面

在 index.jsp 頁面中新增啟動 flow 的連結，從 webmvc-config.xml 配置檔案中可以看出，要啟動 flow ，只需提供 /shopping.do 連結即可。
清單 20 index.jsp
<h1>Hello!</h1><br/>
<a href="shopping.do">View Cart</a>

6.7.執行應用程式

將應用程式釋出到 Tomcat 伺服器，訪問 index.jsp ，並啟動 flow ，測試頁面的跳轉。效果如圖 5所示：

圖 4 flow 執行效果
————————————————————————————————————————————————————

6.8示例程式原始碼

CartApp3原始碼下載地址：http://www.dbank.com/download/CartApp3.rar?f=c0n9qasa5r&i=1&h=1321062828&v=60993861

7.用 Unified EL 實現業務邏輯

到現在為止，這個購物車應用只是實現了頁面之間的跳轉，接下來我們要實現與業務邏輯相關的功能。由於本教程的重點在於介紹如何應用 Spring Web Flow ，所實現的業務比較簡單，與實際應用有較大的距離，請讀者諒解。

業務的邏輯涉及到資料的獲取、傳遞、儲存，相關的業務功能函式的呼叫等內容，這些功能的實現都可用 Java 程式碼來完成，但定義 Spring Web Flow 的語法與 Java 是無關的，這就要求 Spring Web Flow 提供與 Java 程式碼的整合機制。要了解這種機制，關鍵在於搞清楚兩個問題：

  • 業務邏輯程式碼在什麼時候被呼叫？
  • 業務邏輯程式碼在呼叫後得到的資料如何儲存、傳遞？

7.1.業務邏輯程式碼在什麼時候被呼叫？

在 Spring Web Flow 中，業務邏輯程式碼的執行可由以下三種情形來觸發：
  • 客戶端請求中包含了 _eventId 引數
  • 執行到框架自定義的切入點
  • 執行到 <action-state> 元素

7.1.1客戶端請求中包含了 _eventId 引數

這種方式一般用在 state 之間的 transition ，通過指定 _eventId 引數的值，表明了客戶的行為，從而導致相應事件的發生，在 Spring Web Flow 的定義檔案中可以通過 evaluate 元素來指定要處理的業務邏輯。參看清單21：

清單 21 transition 示例
<transition on="submit"> 
    <evaluate expression="validator.validate()" /> 
</transition>

清單 21 的程式碼表示，當客戶端的請求中包含“ _eventId=submit ”，則 evaluate 元素中 expression 屬性所指明的表示式會被執行，即 validator 物件的validate 方法會得到呼叫。

7.1.2執行到框架自定義的切入點

Spring Web Flow 定義了 5 個切入點，通過 flow 定義檔案的配置，可在這 5 個切入點插入相關業務邏輯程式碼。
表 2 Spring Web Flow 自定義的切入點

切入點名稱 XML 元素名稱 觸發時刻
flow start on-start flow 執行之前
state entry on-entry 進入某個 state 之後，做其他事情之前
view render on-render 在進入 view 的 render 流程之後，在 view 真正 render出來之前
state exit on-exit 在退出 state 之前
flow end on-end flow 執行結束之後
清單 22 給出了在 view render 切入點插入業務邏輯程式碼的例子：
清單 22 on-render 元素
<view-state id="viewCart" view="viewCart" >
    <on-render>
        <evaluate expression="productService.getProducts()" result="viewScope.products"/>
    </on-render>
</view-state>

7.1.3執行到 <action-state> 元素

Spring Web Flow 中的這個 <action-state> 是專為執行業務邏輯而設的 state 。如果某個應用的業務邏輯程式碼即不適合放在 transition 中由客戶端來觸發，也不適合放在 Spring Web Flow 自定義的切入點，那麼就可以考慮新增 <action-state> 元素專用於該業務邏輯的執行。示例程式碼參看清單23：

清單 23 action-state 示例
<action-state id="addToCart">
    <evaluate expression="cart.addItem(productService.getProduct(productId))"/>
    <transition to="productAdded"/>
</action-state>

7.2.業務邏輯程式碼在呼叫後得到的資料如何儲存、傳遞？

Spring Web Flow 的定義中可直接使用表示式語言（ Expression Language ），前面的程式碼都是用的 Unified EL ，對於習慣用 OGNL 的開發人員，可通過 flow-builder-services 的配置改成使用 OGNL 。不管是哪一種表示式語言， Spring Web Flow 都提供了一些固定名稱的變數，用於資料的儲存、傳遞。在 Spring Web Flow 的解決方案 一節中，已經提到 Spring Web Flow 所著力解決的問題即是資料存取範圍的問題，為此， Spring Web Flow 提供了兩種比較重要的範圍，一是 flow 範圍，另一個是 conversation 範圍。通過 flowScope 和 conversationScope 這兩個變數， Spring Web Flow 提供了在這兩種範圍裡存取資料的方法。清單 24演示瞭如何將業務邏輯程式碼執行的結果存放到flow範圍中。

清單 24 flowScope 示例
<evaluate expression="productService.getProducts()" result="flowScope.products" />

注意：Spring Web Flow 2.0 在預設配置下，flowScope 和 conversationScope 的實現依賴於 Java 序列化和反序列化技術，因此存放於 flowScope 或 conversationScope 中的物件需要實現 java.io.Serializable 介面。

Spring Web Flow 還提供了大量其他的變數，以方便資料的存取。如 viewScope 範圍即是從進入 view-state 至退出 view-state 結束， requestScope 即和一般的 request 範圍沒什麼區別，等等。另外還有一些用於獲取 flow 以外資料的變數，如 requestParameters 、 messageContext 等等。具體變數的列表可參看 Spring Web Flow自帶的文件。

為示例應用新增商品

接下來，我們要在示例應用的 viewCart.jsp 頁面中新增商品，可按以下步驟操作：
  1. 新增 Product 類
  2. 新增 ProductService 類
  3. 修改 shopping.xml 檔案
  4. 修改 viewCart.jsp 頁面

新增 ProductService 類

ProductService 主要提供商品列表，並能根據商品的 id 查找出該商品，由於示例較簡單，這裡只添加了三條紀錄。見清單 26：
清單 26 ProductService 類
package samples.webflow;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Service;

@Service("productService")
public class ProductService {
    
    private Map<Integer, Product> products = new HashMap<Integer, Product>();

    public ProductService() {
	products.put(1, new Product(1, "Bulldog", 1000));
	products.put(2, new Product(2, "Chihuahua", 1500));
	products.put(3, new Product(3, "Labrador", 2000));
    }

    public List<Product> getProducts() {
	return new ArrayList<Product>(products.values());
    }

    public Product getProduct(int productId) {
	return products.get(productId);
    }
}
Service 註解表示 Spring IoC 容器會初始化一個名為 productService 的 Bean ，這個 Bean 可在 Spring Web Flow 的定義中直接訪問。（這也是為什麼在web-application-config.xml中添加註解的原因）

修改 shopping.xml 檔案

要在 viewCart 頁面中顯示商品，只需在 view-state 元素的 on-render 切入點呼叫 productService 的 getProducts 方法，並將所得結果儲存到 viewScope 中即可。見清單27：
清單 27 shopping.xml 需修改的部分
	<!-- view-state中的view對應jsp資料夾中的jsp頁面，on是觸發事件，to對應state id -->
	<view-state id="viewCart" view="viewCart">
		<on-render>
		<!-- 要在 viewCart 頁面中顯示商品，只需在 view-state 元素的 on-render 切入點呼叫 productService 的
		 getProducts 方法，並將所得結果儲存到 viewScope 中即可 -->
			<evaluate expression="productService.getProducts()" result="viewScope.products" />
		</on-render>
		<transition on="submit" to="viewOrder">
		</transition>
	</view-state>

修改 viewCart.jsp 頁面

清單 27 表明 productService 的 getProducts 方法所得的結果會存放在 viewScope 中名為 products 的變數中， jsp 頁面的程式碼可直接訪問該變數。見清單 28：

清單 28 修改後的 viewCart.jsp 頁面
<?xml version="1.0" encoding="utf-8" ?>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>View Cart</title>
</head>
<body>
	<h1>View Cart</h1>
	<a href="${flowExecutionUrl}&_eventId=submit">Submit</a>
	<h2>Products for Your Choice</h2>
	<table>
		<c:forEach var="product" items="${products}">
			<tr>
				<td>${product.description}</td>
				<td>${product.price}</td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

7.3.執行應用程式

圖 5 viewCart.jsp 頁面效果
——————————————————————————————————————————

7.4.示例程式碼

CartApp4示例程式碼下載地址：http://www.dbank.com/download/CartApp4.rar?f=c0n9qasa5r&i=3&h=1321064658&v=11ec87d6

8.用 subflow 實現新增商品到購物車功能

商品已經有列表了，接下來就要增加把商品放入購物車的功能，在本示例中用 subflow 來實現這一功能，操作步驟如下：
  1. 實現 Cart 和 CartItem 兩個業務類
  2. 在 shopping.xml 中新增配置
  3. 在 /WEB-INF/flows 目錄下新增 addToCart.xml
  4. 在 webflow-config.xml 中新增 addToCart.xml 的位置
  5. 修改 viewCart.jsp 頁面

8.1.實現 Cart 和 CartItem 兩個業務類

CartItem 表示存放於購物車中的條目，主要記錄相應商品及商品數量，同時不要忘記實現 java.io.Serializable 介面，見清單 29：
清單 29 CartItem 類
package samples.webflow;
import java.io.Serializable;
//購物車中的條目
public class CartItem implements Serializable {
    private static final long serialVersionUID = 8388627124326126637L;
    private Product product;//商品
    private int quantity;//數量

    public CartItem(Product product, int quantity) {
	this.product = product;
	this.quantity = quantity;
    }

    //計算該條目的總價格
    public int getTotalPrice() {
	return this.quantity * this.product.getPrice();
    }

    //增加商品的數量
    public void increaseQuantity() {
	this.quantity++;
    }

    /**
     * Return property product
     */
    public Product getProduct() {
	return product;
    }

    /**
     * Sets property product
     */
    public void setProduct(Product product) {
	this.product = product;
    }

    /**
     * Return property quantity
     */
    public int getQuantity() {
	return quantity;
    }

    /**
     * Sets property quantity
     */
    public void setQuantity(int quantity) {
	this.quantity = quantity;
    }
}

除去相應的屬性外， CartItem 可根據商品的數量算出該商品的總價格（ getTotalPrice ），也可通過 increaseQuantity 增加商品數量。
Cart 是購物車的實現類，其同樣要實現 java.io.Serializable 介面，但它沒有像 ProductService 一樣成為由 Spring IoC 容器管理的 Bean ，每個客戶的購物車是不同的，因此不能使用 Spring IoC 容器預設的 Singleton 模式。見清單 30：

清單 30 Cart 類
package samples.webflow;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//購物車的實現類
public class Cart implements Serializable {

    private static final long serialVersionUID = 7901330827203016310L;
    private Map<Integer, CartItem> map = new HashMap<Integer, CartItem>();
   
    //getItems 用於獲取當前購物車裡的物品
    public List<CartItem> getItems() {
	return new ArrayList<CartItem>(map.values());
    }
    
    //addItem 用於向購物車新增商品
    public void addItem(Product product) {
	int id = product.getId();
	CartItem item = map.get(id);
	if (item != null)
	    item.increaseQuantity();
	else
	    map.put(id, new CartItem(product, 1));
    }

    //getTotalPrice 用於獲取購物車裡所有商品的總價格
    public int getTotalPrice() {
	int total = 0;
	for (CartItem item : map.values())
	    total += item.getProduct().getPrice() * item.getQuantity();
	return total;
    }
}
Cart 主要實現三個業務函式， getItems 用於獲取當前購物車裡的物品， addItem 用於向購物車新增商品， getTotalPrice 用於獲取購物車裡所有商品的總價格。

8.2.在 shopping.xml 中新增配置

在 shopping flow 開始時必須分配一個 Cart 物件，由於要呼叫 subflow ，這個 Cart 物件應存放於 conversationScope 中。同時要新增一個 subflow-state 用於執行新增商品到購物車的任務。
清單 31 shopping.xml 中新增的配置
        <var name="mycart" class="samples.webflow.Cart" />
	<on-start>
		<set name="conversationScope.cart" value="mycart"></set>
	</on-start>
	<!-- view-state中的view對應jsp資料夾中的jsp頁面，on是觸發事件，to對應state id -->
	<view-state id="viewCart" view="viewCart">
		<on-render>
			<!-- 要在 viewCart 頁面中顯示商品，只需在 view-state 元素的 on-render 切入點呼叫 productService 
				的 getProducts 方法，並將所得結果儲存到 viewScope 中即可 -->
			<evaluate expression="productService.getProducts()" result="viewScope.products" />
		</on-render>
		<transition on="submit" to="viewOrder" />
		<transition on="addToCart" to="addProductToCart" />
	</view-state>
	<subflow-state id="addProductToCart" subflow="addToCart">
		<transition on="productAdded" to="viewCart" />
	</subflow-state>

8.3.在 /WEB-INF/flows 目錄下新增 addToCart.xml

清單 31 中 subflow-state 元素的 subflow 屬性即指明瞭這個被呼叫的 flow 的 id 為“ addToCart ”，現在就要新增addToCart flow的定義。

清單 32 addToCart.xml
<?xml version="1.0" encoding="UTF-8"?>
<flow xmlns="http://www.springframework.org/schema/webflow"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/webflow 
    http://www.springframework.org/schema/webflow/spring-webflow-2.0.xsd">
	<on-start>
		<set name="requestScope.productId" value="requestParameters.productId" />
	</on-start>
	<action-state id="addToCart">
		<evaluate expression="cart.addItem(productService.getProduct(productId))" />
		<transition to="productAdded" />
	</action-state>
	<end-state id="productAdded" />
</flow>

addToCart flow 主要由一個 action-state 構成，完成新增商品到購物車的功能， addToCart flow 的實現需要有輸入引數，即 productId 。在本示例中是通過請求引數來傳遞，通過 requestParameters 來獲取該數值。這裡還要注意到清單 32 中的 end-state 的 id 為“ productAdded ”，與清單 31 中 subflow-state 中的 transition元素的on屬性的名稱是對應的。

8.4.在 webflow-config.xml 中新增 addToCart.xml 的位置

新增加的 flow 不要忘記在 flow-registry 中註冊。

清單 33 flow-registry 中註冊 addToCart
<webflow:flow-registry id="flowRegistry" flow-builder-services="flowBuilderServices">
  <webflow:flow-location path="/WEB-INF/flows/shopping.xml" id="shopping"/>
  <webflow:flow-location path="/WEB-INF/flows/addToCart.xml" id="addToCart"/> 
</webflow:flow-registry>

8.5.修改 viewCart.jsp 頁面

最後就可以來看在檢視中如何顯示相關的資訊，並觸發相應的 webflow 事件，見清單 34：

清單 34 完整的 viewCart.jsp 的程式碼
<?xml version="1.0" encoding="utf-8" ?>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>View Cart</title>
</head>
<body>
	<h1>View Cart</h1>
	<h2>Items in Your Cart</h2>
	<c:choose>
		<c:when test="${empty cart.items}">
			<p>Your cart is empty.</p>
		</c:when>
		<c:otherwise>
			<table border="1" cellspacing="0">
				<tr>
					<th>Item</th>
					<th>Quantity</th>
					<th>Unit Price</th>
					<th>Total</th>
				</tr>

				<c:forEach var="item" items="${cart.items}">
					<tr>
						<td>${item.product.description}</td>
						<td>${item.quantity}</td>
						<td>${item.product.price}</td>
						<td>${item.totalPrice}</td>
					</tr>
				</c:forEach>

				<tr>
					<td>TOTAL:</td>
					<td></td>
					<td></td>
					<td>${cart.totalPrice}</td>
				</tr>
			</table>
		</c:otherwise>
	</c:choose>

	<a href="${flowExecutionUrl}&_eventId=submit">Submit</a>
	<h2>Products for Your Choice</h2>

	<table>
		<c:forEach var="product" items="${products}">
			<tr>
				<td>${product.description}</td>
				<td>${product.price}</td>


				<td><a
					href="${flowExecutionUrl}&_eventId=addToCart&productId=${product.id}">[add
						to cart]</a></td>


			</tr>
		</c:forEach>

	</table>
</body>
</html>

8.5.執行效果

圖 6 新增購物車後的效果

8.6程式碼例項

CartApp5程式碼例項下載地址：http://www.dbank.com/download/CartApp5.rar?f=c0n9qasa5r&i=4&h=1321064658&v=7aab5c3a

9.global transition 簡介

顧名思義， global transition 是一種全域性的 transition ，可在 flow 執行的各個 state 中被觸發。

清單 35 global-transitons
<global-transitions>
    <transition on="cancelShopping" to="returnToIndex"/>
</global-transitions>
客戶端請求中如果包含 _eventId=cancelShopping ，則會重新回到 index.jsp 頁面。








相關推薦

Spring Web Flow 2.0 入門詳解

目錄： 參考文獻購物車用例什麼情況下可以使用 Spring Web Flow？配置 Spring Web MVC配置 Spring Web Flow 2.0 的基礎在購物車示例應用中配置 Spring Web Flow用 Unified EL 實現業務邏輯用 subflow

經典ASP NET MVC3 0入門詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Retrofit 2.0使用詳解，配合OkHttp、Gson，Android最強網路請求框架

1.使用retrofit，需要下載一些jar包 2.介紹這些jar包的作用 在1.x版本的retrofit框架： 只需要Retrofit包和gson-2.4.jar包就行了，那時的Retrofit預設是使用okhttp jar包來網路請

OpenCV contrib 3.2.0擴充套件模組新增與編譯（VS2017+OpenCV3.2.0）詳解與排坑

一Cmake配置與生成 安裝cmake下載地址：https://cmake.org/download/ 獲取最新版本：cmake-3.8.1-win64-x64.msi（可執行程式，不是壓縮包） 下載完畢直接執行安裝，只有一個步驟要注意， 選擇‘addCmake t

RxJava 2.0 使用詳解

前言 在上一篇部落格中，提到了RxJava的一些比較核心的東西，還有與1.x版本的一些區別！ 現在我們具體瞭解一下它的使用！ 使用 最基本的的使用 我們知道一個簡單的RxJava的應用，需要一個觀察者或者訂閱者Observer，一個被觀察者Ob

Spring batch學習 持久化表結構詳解(2)

true fig 序列化 roc col id字段 exce har class #接上一篇 這一篇講一下持久化需要表 batch_job_execution, batch_job_execution_context, batch_job_execution_pa

區塊鏈以及區塊鏈技術入門詳解(2)

很多人迷惑於區塊鏈和以太坊，不知如何學習，本文簡單說了一下學習的一些方法和資源。 一、    以太坊和區塊鏈的關係      從區塊鏈歷史上來說，先誕生了比特幣，當時並沒有區塊鏈這個技術和名詞，然後業界從比特幣中提取了技術架構和體系，稱

%date~0,4%和 %time~0,2%等用法詳解

在windows中，有個原始並且功能強大的批處理，好像是被人遺忘了，比如博主最近在一個專案中就用到它，非常好用。今天就和博主一直來看看用批處理生動生成每日的資料夾。 為了能正確地生成每天的日期資料夾，請先將本機時間的短日期格式設定為yyyy-MM-dd。   然後就開始寫bat批處理檔案了，新

Spring Security 入門詳解

Spring Security 入門詳解   1.Spring　Security介紹 Spring Security是基於spring的應用程式提供宣告式安全保護的安全性框架，它提供了完整的安全性解決方案，能夠在web請求級別和方法呼叫級別 處理身份證驗證和授權．它充分使用了依

spring cloud 2.0 入門系列一 （10）分散式鏈路追蹤-Zipkin

服務說明 Zipkin是什麼 Zipkin分散式跟蹤系統；它可以幫助收集時間資料，解決在microservice架構下的延遲問題；它管理這些資料的收集和查詢；Zipkin的設計是基於谷歌的Google Dapper論文。 每個應用程式向Zipkin報告定時

NPOI2.2.0.0例項詳解(七)—設定EXCEL字型

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using NPOI.HSSF.UserM

Spring入門詳解【基礎掃盲】

Spring基礎介紹 什麼是Spring、Strust、Hibernate struts 是 web 框架(jsp/action/actionfrom) hibernate 是 orm框架,處於持久層. spring 是容器框架,用於配置bean,並

spring security oauth2.0配置詳解

spring security oauth2.0 實現 目標 現在很多系統都支援第三方賬號密碼等登陸我們自己的系統，例如：我們經常會看到，一些系統使用微信賬號，微博賬號、QQ賬號等登陸自己的系統，我們現在就是要模擬這種登陸的方式，很多大的公司已經實現了這

Idea環境下使用JFinal開發Web專案入門詳解（圖文版）

       最近看到網上有人推薦使用JFinal（官網：http://www.jfinal.com/）開發WEB + ORM專案，自己於是到官網學習JFinal，官方文件提供了使用eclipse開發Jfinal專案的步驟，只是對Idea做了簡略說明，沒有詳細的介紹，對於智

Spring Boot 入門詳解

原始碼分析： J2EE的整體整合解決方案和自動配置都在spring-boot-autoconfigure-X.X.X.RELEASE.jar中：

NPOI2.2.0.0例項詳解(八)—設定EXCEL單元格【數字格式】

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using NPOI.HSSF.UserM

NPOI2.2.0.0例項詳解(四)—設定EXCEL單元格對齊方式

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using NPOI.HSSF.UserM

NPOI2.2.0.0例項詳解(六)—設定EXCEL單元格邊框

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using NPOI.HSSF.UserM

NPOI2.2.0.0例項詳解(十)—設定EXCEL單元格【文字格式】

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using NPOI.HSSF.UserM

spring cloud 2.0 入門系列一 （4）斷路器-Hystrix

Spring Cloud Hystrix Hystrix [hɪst’rɪks]的中文含義是豪豬, 因其背上長滿了刺,而擁有自我保護能力. Netflix的 Hystrix 是一個幫助解決分散式系統互動時超時處理和容錯的類庫, 它同樣擁有保護系統的能力.