恕我斗膽直言，對開源的 WEB 框架了解多少，有沒有嘗試寫過框架呢？XML 的決議方式有哪些？能答出來嗎？！

心中沒有答案也沒關系，因為通過今天的分享，能讓你輕松 get 如下幾點，絕對識訓滿滿，

a）XML 決議的方式；

b）digester 的用法；

c) Java WEB 框架的實作思路；

d）從 0 到 1 徒手實作一個迷你 WEB 框架，

1. XML 決議方式

在 Java 專案研發程序中，不論專案大小，幾乎都能見到 XML 組態檔的蹤影，使用 XML 可以進行專案配置；也可以作為對接三方 API 時資料封裝、報文傳輸轉換，等等很多使用場景，

而 XML 檔案該如何決議？則是一個老生常談的問題，也是研發中選型經常面臨的一個問題，通過思維導圖梳理，把問題都扼殺在搖籃里，

如導圖所示，DOM 和 SAX 是 XML 常見的兩大核心決議方式，兩者的主要區別在于它們決議 XML 檔案的方式不同，使用 DOM 決議，XML 檔案以 DOM 樹形結構加載入記憶體，而 SAX 采用的是事件模型，

基于這兩大決議方式，衍生了一系列的 API，也就是造出了一大批輪子，到呼叫哪款輪子呢？下面就叨咕叨咕，

上面羅列的這些，你都知道或者用過嗎？為了便于你記憶，咱們就聊聊發展歷史吧，

首先 JAXP 的出現是為了彌補 JAVA 在 XML 標準制定上的空白，而制定的一套 JAVA XML 標準 API，是對底層 DOM、SAX 的 API 簡單封裝；而原始 DOM 對于 Java 開發者而言較為難用，于是一批 Java 愛好者為了能讓決議 XML 得心應手，碼出了 jdom；另一批人在 jdom 的基礎上另起爐灶，碼出了 dom4j，由于 jdom 性能不抵 dom4j，dom4j 則獨占鰲頭，很多開源框架都用 dom4j 來決議組態檔，

XStream 本不應該出現在這里，但是鑒于是經驗分享，索性也列了出來，在以往專案中報文轉換時用的稍微多些，尤其是支付 API 對接時用的超級多，使用它可以很容易的實作 Java 物件和 XML 檔案的互轉（感興趣的可以自行填補一下），

digester 是采用 SAX 來決議 XML 檔案，在 Tomcat 中就用 Digester 來決議配置，在 Struts 等很多開源專案，也都用到了 digester 來決議組態檔，在實際專案研發中，也會用它來做協議決議轉換，所以這塊有必要深入去說一下，對你看原始碼應該會有幫助，

2. digester 的用法

弱弱問一句：有沒有聽過 digester，若沒有聽過，那勢必要好好讀本文啦，

假如要對本地的 miniframework-config.xml 檔案，采用 digester 的方式進行決議，應該怎么做？（組態檔的內容有似曾相識的感覺沒？文末解謎）

<?xml version="1.0" encoding="UTF-8"?>
<action-mappings>
    <action path="/doOne" type="org.yyxj.miniframework.action.OneAction">
        <forward name="one" path="/one.jsp" redirect="false"/>
    </action>
    <action path="/doTwo" type="org.yyxj.miniframework.action.TwoAction">
        <forward name="two" path="/two.jsp" redirect="true"/>
    </action>
</action-mappings>

2.1. 定義決議規則檔案 rule.xml

digester 進行決議 xml，需要依賴決議規則（就是告訴 digester 怎么個決議法），可以使用 Java 硬編碼的方式指定決議規則；也可以采用零配置思想，使用注解的方式來指定決議規則；還可以使用 xml 方式配置決議規則，

為了清晰起見，本次就采用 xml 方式進行配置決議規則，決議規則 rule.xml 內容如下，

<?xml version='1.0' encoding='UTF-8'?>
<digester-rules>
    <pattern value="action-mappings">
        <!-- value是匹配的xml標簽的名字，匹配<action>標簽 -->
        <pattern value="action">
            <!--每碰到一個action標簽,就創建指定類的物件-->
            <object-create-rule classname="org.yyxj.miniframework.config.ActionMapping"/>
            <!--
                物件創建后,呼叫ActionMappings的addActionMapping()方法,
                將其加入它上一級元素所對應的物件ActionMappings中
            -->
            <set-next-rule methodname="addActionMapping"/>
            <!--
                將action元素的各個屬性按照相同的名稱
                賦值給剛剛創建的ActionMapping物件
            -->
            <set-properties-rule/>
            <!-- 匹配<forward>標簽 -->
            <pattern value="forward">
                <!--每碰到一個forward標簽,就創建指定類的物件-->
                <object-create-rule classname="org.yyxj.miniframework.config.ForwardBean"/>
                <!--
                    物件創建后,呼叫ActionMapping的addForwardBean()方法,
                    將其加入它上一級元素所對應的物件ActionMapping中
                -->
                <set-next-rule methodname="addForwardBean"/>
                <!--
                    將forward元素的各個屬性按照相同的名稱
                    賦值給剛剛創建的ForwardBean物件
                -->
                <set-properties-rule/>
            </pattern>
        </pattern>
    </pattern>
</digester-rules>

2.2. 創建規則決議依賴的 Java 類

首先是 ActionMappings 類，要提供 addActionMapping 方法以便添加 ActionMapping 物件，考慮到后面會依據請求路徑找 ActionMapping，索性也定義一個 findActionMapping 的方法，代碼如下，

package org.yyxj.miniframework.config;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 一猿小講
 */
public class ActionMappings {

    private Map<String, ActionMapping> mappings = new HashMap<String, ActionMapping>();

    public void addActionMapping(ActionMapping mapping) {
        this.mappings.put(mapping.getPath(), mapping);
    }

    public ActionMapping findActionMapping(String path) {
        return this.mappings.get(path);
    }

    @Override
    public String toString() {
        return mappings.toString();
    }
}

依據決議規則檔案，接下來會匹配到 miniframework-config.xml 檔案的 action 標簽，要定義對應的 ActionMapping 類，包含請求路徑及讓誰處理的類路徑，當然也要提供 addForwardBean 方法用于添加 ForwardBean 物件，代碼定義如下，

package org.yyxj.miniframework.config;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 一猿小講
 */
public class ActionMapping {

    private String path;

    private String type;

    private Map<String, ForwardBean> forwards = new HashMap<String, ForwardBean>();

    public void addForwardBean(ForwardBean bean) {
        forwards.put(bean.getName(), bean);
    }

    public ForwardBean findForwardBean(String name) {
        return forwards.get(name);
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return path + "==" + type + "==" + this.forwards.toString();
    }
}

依據決議規則檔案，接下來會匹配到 miniframework-config.xml 檔案的 forward 標簽，那么就要創建與之對應的 ForwardBean 類，并且擁有 name、path、redirect 三個屬性，代碼定義如下，

package org.yyxj.miniframework.config;

/**
 * @author 一猿小講
 */
public class ForwardBean {

    private String name;

    private String path;

    private boolean redirect;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public boolean isRedirect() {
        return redirect;
    }

    public void setRedirect(boolean redirect) {
        this.redirect = redirect;
    }

    @Override
    public String toString() {
        return name + "==" + path + "==" + redirect;
    }
}

2.3. 引入依賴包，撰寫測驗類

<dependency>
    <groupId>commons-digester</groupId>
    <artifactId>commons-digester</artifactId>
    <version>2.1</version>
</dependency>

撰寫測驗類，

package org.yyxj.miniframework.config;

import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;
import org.xml.sax.SAXException;

import java.io.IOException;

/**
 * Digester用法測驗類
 *
 * @author 一猿小講
 */
public class Test {

    public static void main(String[] args) throws IOException, SAXException {
        String rlueFile = "org/yyxj/miniframework/config/rule.xml";
        String configFile = "miniframework-config.xml";
        Digester digester = DigesterLoader.createDigester(
                Test.class.getClassLoader().getResource(rlueFile));
        ActionMappings mappings = new ActionMappings();
        digester.push(mappings);
        digester.parse(Test.class.getClassLoader().getResource(configFile));
        System.out.println(mappings);
    }
}

2.4. 跑起來，看看決議是否 OK？

程式輸出如下：
{/doOne=/doOne==org.yyxj.miniframework.action.OneAction=={one=one==/one.jsp==false}, /doTwo=/doTwo==org.yyxj.miniframework.action.TwoAction=={two=two==/two.jsp==true}}

到這兒 digester 決議 xml 就算達到了預期效果，digester 決議其實起來很簡單，照貓畫虎擼兩遍，就自然而然掌握，所以不要被烏央烏央的代碼給嚇退縮（代碼只是方便你施展 CV 大法），

不過，會用 digester 決議 xml 還不算完事，還想擴展一下思路，站在上面代碼的基礎之上，去嘗試實作一個迷你版的 WEB 框架，

3. WEB 框架的實作思路

此時請忘記 digester 決議的事情，腦海里只需保留開篇提到的 miniframework-config.xml 檔案，怕你忘記，就再貼一遍，

圖中紅色圈住部分，其實可以這么理解，當用戶請求的 path 為 /doOne 時，會交給 OneAction 去處理，處理完之后的回傳結果若是 one，則跳轉到 one.jsp，給前端回應，

為了說的更清晰，說清楚思路，還是畫一張圖吧，

ActionServlet 主要是接收用戶請求，然后根據請求的 path 去 AcitonMappings中尋找對應的 ActionMapping，然后依據 ActionMapping 找到對應的 Action，并呼叫 Action 完成業務處理，然后把回應視圖回傳給用戶，多少都透漏著 MVC 設計模式中 C 的角色，

Action 主要是業務控制器，其實很簡單，只需提供抽象的 execute 方法即可，具體怎么執行交給具體的業務實作類去實作吧，

4. 徒手實作迷你版的 WEB 框架

鑒于 ActionMappings、ActionMapping、ForwardBean 已是可復用代碼，主要是完成 miniframework-config.xml 檔案的決議，那接下來只需把圖中缺失的類定義一下就 Ok 啦，

4.1. 中央控制器 ActionServlet

package org.yyxj.miniframework.controller;

import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;
import org.yyxj.miniframework.config.ActionMapping;
import org.yyxj.miniframework.config.ActionMappings;
import org.yyxj.miniframework.config.ForwardBean;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 中央控制器
 * 1. 接收客戶端的請求；
 * 2. 根據請求的 path 找到對應的 Action 來處理業務，
 *
 * @author 一猿小講
 */
public class ActionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    private ActionMappings mappings = new ActionMappings();

    public static final String RULE_FILE = "org/yyxj/miniframework/config/rule.xml";

    public static final String EASY_STRUTS_CONFIG_FILE = "miniframework-config.xml";

    @Override
    public void init() {
        Digester digester = DigesterLoader.createDigester(ActionServlet.class.getClassLoader().getResource(RULE_FILE));
        digester.push(mappings);
        try {
            digester.parse(ActionServlet.class.getClassLoader().getResource(EASY_STRUTS_CONFIG_FILE));
        } catch (Exception e) {
            // LOG
        }
    }

    @Override
    public void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=utf-8");

        // 獲取請求路徑
        String uri = request.getRequestURI();
        String path = uri.substring(uri.lastIndexOf("/"), uri.lastIndexOf("."));

        // 1：根據請求路徑獲取對應的 Action 來處理具體的業務
        ActionMapping mapping = mappings.findActionMapping(path);
        try {
            Action action = (Action) Class.forName(mapping.getType()).newInstance();
            // 2：進行業務處理，并回傳執行的結果
            String result = action.execute(request, response);
            // 3：依據執行結果找到對應的 ForwardBean
            ForwardBean forward = mapping.findForwardBean(result);
            // 4：回應
            if (forward.isRedirect()) {
                response.sendRedirect(request.getContextPath() + forward.getPath());
            } else {
                request.getRequestDispatcher(forward.getPath()).forward(request, response);
            }
        } catch (Exception e) {
            // LOG
            System.err.println(String.format("service ex [%s]", e.getMessage()));
        }
    }
}

4.2. 業務控制器 Action 及業務實作

package org.yyxj.miniframework.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 業務控制器
 * @author 一猿小講
 */
public abstract class Action {
    public abstract String execute(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

緊接著就定義具體的業務實作唄，

package org.yyxj.miniframework.action;

import org.yyxj.miniframework.controller.Action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 業務實作
 *
 * @author 一猿小講
 */
public class OneAction extends Action {

    @Override
    public String execute(HttpServletRequest request,
                          HttpServletResponse response) throws Exception {
        return "one";
    }
}

TwoAction 與 OneAction 一樣都是繼承了 Action，實作 execute 方法，

package org.yyxj.miniframework.action;

import org.yyxj.miniframework.controller.Action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 業務實作
 *
 * @author 一猿小講
 */
public class TwoAction extends Action {
    @Override
    public String execute(HttpServletRequest request,
                          HttpServletResponse response) throws Exception {
        return "two";
    }
}

4.3. 配置 web.xml，配置服務啟動入口

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <servlet>
        <servlet-name>ActionServlet</servlet-name>
        <servlet-class>org.yyxj.miniframework.controller.ActionServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ActionServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

4.4. 畫三個 JSP 頁面出來，便于驗證

index.jsp 內容如下，

<%@ page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>My JSP 'index.jsp' starting page</title>
  </head>
  
  <body>
       <a href="doOne.do">DoOneAction</a><br/>
       <a href="doTwo.do">DoTwoAction</a><br/>
  </body>
</html>

one.jsp 內容如下，

<%@ page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

一猿小講 say one .... ...

two.jsp 內容如下，

<%@ page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

一猿小講 say two .... ...

4.5. 部署、啟動 WEB 服務

到這一個迷你版的 WEB 框架就完事啦，把專案打成 war 包，放到 tomcat 里跑起來，驗證一下，

4.6. 專案結構一覽

藍色圈住部分可以打成 miniframework.jar 包，當做可復用類別庫，在其它專案中直接引入，只需撰寫紅色圈住部分的業務 Action 以及頁面就好啦，

5. 答疑解謎

本次主要聊了聊 xml 決議的方式，著重分享了 digester 的用法，并站在 digester 決議 xml 的基礎之上，徒手模擬了一個 WEB 的迷你版的框架，

如果你研究過 Tomcat 的原始碼或者使用過 Struts 的話，今天的分享應該很容易掌握，因為它們都用到了 digester 進行決議組態檔，

鑒于目前據我知道的很多公司的老專案，技術堆疊還停留在 Struts 上，所以有必要進行一次老技術新談，

坊間這么說「只要會 XML 決議，搞懂反射，熟悉 Servlet，面試問到什么框架都不怕，因為打通了任督二脈，框架看一眼就基本知道原理啦」，

不過，技術更新確實快，稍有不慎就 out，不過在追逐新技術的同時，老技術的思想理念也別全拋在腦后，如果真能打通任督二脈，做到融會貫通那就最好啦，

好了，本次的分享就到這里，希望你們喜歡，請多關注一猿小講，后續會輸出更多原創精彩文章，敬請期待！

可以微信搜索公眾號「一猿小講」回復「1024」get 精心為你準備的編程進階資料，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/4523.html

標籤：架構設計

上一篇：臭名昭著的手機驗證碼功能是如何實作的

下一篇：訊息佇列全面了解（一）

搞懂 XML 決議，徒手造 WEB 框架