Struts2攔截器之ExceptionMappingInterceptor（異常映射攔截器）

一、異常攔截器是什么？

異常攔截器的作用是提供一個機會，可以設置在action執行過程中發生異常的時候映射到一個結果字符串而不是直接中斷。

將異常整合到業務邏輯中，比如在分層系統的調用中可以從底層拋出一個異常，高層捕捉到這個異常就知道發生了什么事情啦。

二、如何使用？

1.兩種異常映射類型：

1.1.global

global的異常映射對整個package下的action都有效：

<struts>

    <package name="default" namespace="/" extends="struts-default">
    
        <!-- 全局異常配置 -->
        <global-exception-mappings>
            <exception-mapping result="login" exception="struts_practice_004.UsernameIsNullException"  />    
        </global-exception-mappings>
        
        <action name="loginAction" class="struts_practice_004.LoginAction">
            
            <result name="login">/login.jsp</result>
            <result name="success">/success.jsp</result>
        </action>
        
    </package>
</struts>

1.2.action

action級別的異常映射只對單個的action有效：

<struts>

    <package name="default" namespace="/" extends="struts-default">
    
        <action name="loginAction" class="struts_practice_004.LoginAction">
        
            <!-- action級別的異常映射 -->
            <exception-mapping exception="struts_practice_004.UsernameIsNullException" result="login" />
            
            <result name="login">/login.jsp</result>
            <result name="success">/success.jsp</result>
        </action>
        
    </package>
</struts>

2.配置異常映射的可選參數

logEnabled 日志是否開啟，默認關閉

logCategory 日志種類

logLevel 日志級別

3.使用異常映射的例子：

User實體：

/**
 * 用戶實體
 * @author CC11001100
 *
 */
public class User {

    private String username;
    private String passwd;

    public String getUsername() {
        return username;
    }

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

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

}

LoginAction：

/**
 * 登錄Action
 * 
 * @author CC11001100
 * 
 */
public class LoginAction extends ActionSupport {

    private User user;
    private LoginService loginService;
    
    public LoginAction() {
        loginService=new LoginService();
    }

    @Override
    public String execute() throws Exception {
        
        //嘗試登錄
        User u1=loginService.login(user);
        //如果為空，說明登錄失敗.
        if(u1==null){
            return LOGIN;
        }
        
        return SUCCESS;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

LoginService：

public class LoginService {

    /**
     * 登錄是否成功
     * @param user
     * @return
     */
    public User login(User user){
        if(true) throw new UsernameIsNullException();
        return user;
    }
    
}

struts.xml

<struts>

    <package name="default" namespace="/" extends="struts-default">
    
        <action name="loginAction" class="struts_practice_004.LoginAction">
            <exception-mapping exception="struts_practice_004.UsernameIsNullException" result="login" />
            <result name="login">/login.jsp</result>
            <result name="success">/success.jsp</result>
        </action>
        
    </package>
</struts>

前端頁面：

<form    action="loginAction" method="post">
     用戶名：<input type="text" name="user.username" /><br/>
     密&nbsp;&nbsp;碼：<input type="password" name="user.passwd" /><br/>
     <input type="submit" value="登錄" /><s:property value="exception"/>
 </form>
  
  <s:debug />

結果：

提示不太友好，感覺例子設計得很牽強....湊活着吧，我們都知道Action會被壓入值棧的棧頂，但是這里有一個<s:property value="exception"/> 這個是怎么訪問得到的呢？請看下面的源代碼分析。

三、工作原理？

異常攔截器處在默認攔截器棧的第一層，它的實現類是ExceptionMappingInterceptor，源代碼如下：

/**
 * 
 *  異常映射攔截器：
 *  
 *  1.捕捉異常
 *  2.將異常映射到結果字符串
 *
 */
public class ExceptionMappingInterceptor extends AbstractInterceptor {
    
    protected static final Logger LOG = LoggerFactory.getLogger(ExceptionMappingInterceptor.class);

    protected Logger categoryLogger;
    //是否將異常信息打印到日志
    protected boolean logEnabled = false;
    //logger的種類
    protected String logCategory;
    //日志的級別，默認是debug，從哪兒知道的？耐心往下看...
    protected String logLevel;
    
    /*------------------------- 在這下面是getter和setter ------------------------------*/
    public boolean isLogEnabled() {
        return logEnabled;
    }

    public void setLogEnabled(boolean logEnabled) {
        this.logEnabled = logEnabled;
    }

    public String getLogCategory() {
        return logCategory;
    }

    public void setLogCategory(String logCatgory) {
        this.logCategory = logCatgory;
    }

    public String getLogLevel() {
        return logLevel;
    }

    public void setLogLevel(String logLevel) {
        this.logLevel = logLevel;
    }
    /*----------------------------- getter和setter結束 ----------------------------------*/
    
    /**
     *  攔截器方法
     */
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        
        String result;

        try {
            //正常執行，繼續往下遞歸調用，如果執行過程中沒有拋出異常就相當於沒有異常攔截器
            //意思就是異常攔截器只有在拋出異常的時候才發揮作用，如果沒發生異常就感覺不到它的存在
            result = invocation.invoke();
        } catch (Exception e) {
            //如果在執行的過程catch到了異常，異常攔截器才會發揮作用
            
            //如果開啟日志記錄的話，默認是false，上面已經寫死了
            if (isLogEnabled()) {
                //記錄一下
                handleLogging(e);
            }
            
            //獲得異常映射信息，這個信息是在struts.xml中的<exception-mapping>中配置的
            List<ExceptionMappingConfig> exceptionMappings = invocation.getProxy().getConfig().getExceptionMappings();
            
            //找一下當前拋出的異常有沒有配置對應的結果字符串
            String mappedResult = this.findResultFromExceptions(exceptionMappings, e);
            
            if (mappedResult != null) {
                //如果找到了異常對應的結果字符串，那么保存結果
                result = mappedResult;
                //同時將這個異常包裹起來放到ValueStack的棧頂
                publishException(invocation, new ExceptionHolder(e));
            } else {
                //沒有沒有配置結果字符串，我也不知道該怎么處理了，直接往上拋吧
                throw e;
            }
        }
        
        //執行正常或者發生異常但配置了異常映射結果字符串才會執行到這里
        return result;
    }

    /**
     * Handles the logging of the exception.
     *  打印日志
     * @param e  the exception to log.
     */
    protected void handleLogging(Exception e) {
        //決定日志的打印方式
        if (logCategory != null) {
            //使用categoryLogger
            if (categoryLogger == null) {
                // init category logger
                categoryLogger = LoggerFactory.getLogger(logCategory);
            }
            doLog(categoryLogger, e);
        } else {
            //或是使用默認的這個
            doLog(LOG, e);
        }
    }
    
    /**
     * Performs the actual logging.
     * 
     * 打印日志的具體實現
     * 
     * @param logger  the provided logger to use.
     * @param e  the exception to log.
     */
    protected void doLog(Logger logger, Exception e) {
        //如果沒有指定logLevel的話，默認就是debug級別了
        if (logLevel == null) {
            logger.debug(e.getMessage(), e);
            return;
        }
        
        //根據指定的日志級別打印
        if ("trace".equalsIgnoreCase(logLevel)) {
            logger.trace(e.getMessage(), e);
        } else if ("debug".equalsIgnoreCase(logLevel)) {
            logger.debug(e.getMessage(), e);
        } else if ("info".equalsIgnoreCase(logLevel)) {
            logger.info(e.getMessage(), e);
        } else if ("warn".equalsIgnoreCase(logLevel)) {
            logger.warn(e.getMessage(), e);
        } else if ("error".equalsIgnoreCase(logLevel)) {
            logger.error(e.getMessage(), e);
        } else if ("fatal".equalsIgnoreCase(logLevel)) {
            logger.fatal(e.getMessage(), e);
        } else {
            //都不匹配啊，說明指定的日志級別不合法（這種情況八成是拼寫錯誤，血淚經驗....），拋出異常警告一下搞開發的這傻小子~
            throw new IllegalArgumentException("LogLevel [" + logLevel + "] is not supported");
        }
    }
    
    /**
     * 看看映射列表中有沒有對應的映射
     */
    protected String findResultFromExceptions(List<ExceptionMappingConfig> exceptionMappings, Throwable t) {
        String result = null;

        // Check for specific exception mappings
        //看看是否配置了異常映射，即<exception-mapping exception="" result="" />
        if (exceptionMappings != null) {
            //因為后面要比慘..啊是比小，所以就預先給一個最大值，比較簡單的技巧
            int deepest = Integer.MAX_VALUE;
            //遍歷映射列表項
            for (Object exceptionMapping : exceptionMappings) {
                //看不大懂，為什么放着泛型不用呢，直接取出來不就是ExceptionMappingConfig類型的么？ - -
                ExceptionMappingConfig exceptionMappingConfig = (ExceptionMappingConfig) exceptionMapping;
                //看看當前的異常類跟配置的<exception-mapping exception="就是這一個" />能不能匹配的上，是不是它本身或者其子類
                int depth = getDepth(exceptionMappingConfig.getExceptionClassName(), t);
                if (depth >= 0 && depth < deepest) {
                    //說明找到了，當前拋出的異常類是配置的類本身或者是其子類
                    //按照一般想法找到了就直接return就可以了唄，我剛開始也是這樣子想的，
                    //但是呢仔細看一看，結合上面的depth < deepest和下面的deepest = depth;
                    //所以呢，這里只是保存了一下仍然繼續的意思就是要從這些映射列表中找到一個跟當前類最接近的
                    //這里的接近是從t(此時的t是超類引用子類對象，它的運行時類型並不是Throwable)一直到Throwable
                    //的這段距離，從[t,Throwable]這個區間上找一個最靠左的，感覺這樣就能解釋清楚了，
                    //這樣做是為了最細程度的映射
                    deepest = depth;
                    result = exceptionMappingConfig.getResult();
                }
            }
        }

        return result;
    }

    /**
     * Return the depth to the superclass matching. 0 means ex matches exactly. Returns -1 if there's no match.
     * Otherwise, returns depth. Lowest depth wins.
     * 
     *  找一下這個映射類到拋出的異常類之間有幾個超類，可能有三種情況：
     *  1. 沒找到：-1表示exceptionMapping不是t的超類（這樣貌似也沒辦法映射到了，映射的話包括本類和子類）
     *  2. 本身：如果0的話表示exceptionMapping和t就是同一個類
     *  3. 子類：其它字符串表示中間的超類個數，表示t是exceptionMapping的一個子類，但我們要的是中間的繼承次數
     * 
     * @param exceptionMapping  the mapping classname
     * @param t  the cause
     * @return the depth, if not found -1 is returned.
     */
    public int getDepth(String exceptionMapping, Throwable t) {
        return getDepth(exceptionMapping, t.getClass(), 0);
    }

    /**
     * 找exceptionMapping到exceptionClass的“距離”
     */
    private int getDepth(String exceptionMapping, Class exceptionClass, int depth) {
        //看看這個映射類是不是當前異常類的超類
        if (exceptionClass.getName().contains(exceptionMapping)) {
            // Found it!
            //找到了
            return depth;
        }
        // If we've gone as far as we can go and haven't found it...
        //已經找到了頂層（Throwable），但仍然未找到，說明不可能找到了，返回不匹配
        if (exceptionClass.equals(Throwable.class)) {
            return -1;
        }
        
        //遞歸順着繼承鏈往上找
        return getDepth(exceptionMapping, exceptionClass.getSuperclass(), depth + 1);
    }

    /**
     * Default implementation to handle ExceptionHolder publishing. Pushes given ExceptionHolder on the stack.
     * Subclasses may override this to customize publishing.
     * 
     *  將這個ExceptionHolder壓入ValueStack的棧頂
     * 
     * @param invocation The invocation to publish Exception for.
     * @param exceptionHolder The exceptionHolder wrapping the Exception to publish.
     */
    protected void publishException(ActionInvocation invocation, ExceptionHolder exceptionHolder) {
        //壓入值棧的棧頂，以便OGNL表達式訪問
        invocation.getStack().push(exceptionHolder);
    }
}

 放入ValueStack棧頂的wrapper類的源代碼分析：

/**
 *
 * A simple wrapper around an exception, providing an easy way to print out the stack trace of the exception as well as
 * a way to get a handle on the exception itself.
 * 
 * 將異常wrapper一下，然后提供兩個方法以供簡便的獲得這個異常和異常追蹤棧。
 * 
 * getException() 
 * getExceptionStack() 
 * 
 * 這兩個getter方法是用來給OGNL訪問exception信息使用的，
 * 當發生異常的時候會將異常對象用這個類包裹起來放到ValueStack的棧頂，
 * 所以直接通過exception就可以訪問得到異常對象本身，
 * 通過exceptionStack就可以訪問得到這個異常棧信息。
 * 
 */
public class ExceptionHolder implements Serializable {

    //要包裹的異常本身
    private Exception exception;

    /**
     * Holds the given exception
     * 實例化這個類必須傳進來一個異常，它持有一個異常。
     * @param exception  the exception to hold.
     */
    public ExceptionHolder(Exception exception) {
        this.exception = exception;
    }

    /**
     * Gets the holded exception
     * 返回持有的異常對象
     * @return  the holded exception
     */
    public Exception getException() {
        return this.exception;
    }

    /**
     * Gets the holded exception stacktrace using {@link Exception#printStackTrace()}.
     * 以String的形式返回異常棧追蹤信息
     * @return  stacktrace
     */
    public String getExceptionStack() {
        String exceptionStack = null;
        
        if (getException() != null) {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);

            try {
                getException().printStackTrace(pw);
                exceptionStack = sw.toString();
            }
            finally {
                try {
                    sw.close();
                    pw.close();
                } catch (IOException e) {
                    // ignore
                }
            }
        }

        return exceptionStack;
    }
    
}

 用來表示異常映射的類的源代碼：

這個類使用了Builder模式：設計模式之構建者模式（Builder）

/**
 * Configuration for exception mapping.
 * 異常映射的配置信息
 */
public class ExceptionMappingConfig extends Located implements Serializable {
    
    //結果字符串
    private String name;
    //異常類的類名
    private String exceptionClassName;
    //映射到的結果字符串
    private String result;
    //傳遞的參數
    private Map<String,String> params;

    protected ExceptionMappingConfig(String name, String exceptionClassName, String result) {
        this.name = name;
        this.exceptionClassName = exceptionClassName;
        this.result = result;
        this.params = new LinkedHashMap<String,String>();
    }

    protected ExceptionMappingConfig(ExceptionMappingConfig target) {
        this.name = target.name;
        this.exceptionClassName = target.exceptionClassName;
        this.result = target.result;
        this.params = new LinkedHashMap<String,String>(target.params);
    }

    public String getName() {
        return name;
    }

    public String getExceptionClassName() {
        return exceptionClassName;
    }

    public String getResult() {
        return result;
    }

    public Map<String,String> getParams() {
        return params;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (!(o instanceof ExceptionMappingConfig)) {
            return false;
        }

        final ExceptionMappingConfig exceptionMappingConfig = (ExceptionMappingConfig) o;

        if ((name != null) ? (!name.equals(exceptionMappingConfig.name)) : (exceptionMappingConfig.name != null)) {
            return false;
        }

        if ((exceptionClassName != null) ? (!exceptionClassName.equals(exceptionMappingConfig.exceptionClassName)) : (exceptionMappingConfig.exceptionClassName != null))
        {
            return false;
        }

        if ((result != null) ? (!result.equals(exceptionMappingConfig.result)) : (exceptionMappingConfig.result != null))
        {
            return false;
        }

        if ((params != null) ? (!params.equals(exceptionMappingConfig.params)) : (exceptionMappingConfig.params != null))
        {
            return false;
        }

        return true;
    }

    @Override
    public int hashCode() {
        int hashCode;
        hashCode = ((name != null) ? name.hashCode() : 0);
        hashCode = (29 * hashCode) + ((exceptionClassName != null) ? exceptionClassName.hashCode() : 0);
        hashCode = (29 * hashCode) + ((result != null) ? result.hashCode() : 0);
        hashCode = (29 * hashCode) + ((params != null) ? params.hashCode() : 0);

        return hashCode;
    }

    /**
     * The builder for this object.  An instance of this object is the only way to construct a new instance.  The
     * purpose is to enforce the immutability of the object.  The methods are structured in a way to support chaining.
     * After setting any values you need, call the {@link #build()} method to create the object.
     */
    public static class Builder{

        private ExceptionMappingConfig target;

        public Builder(ExceptionMappingConfig toClone) {
            target = new ExceptionMappingConfig(toClone);
        }

        public Builder(String name, String exceptionClassName, String result) {
            target = new ExceptionMappingConfig(name, exceptionClassName, result);
        }

        public Builder name(String name) {
            target.name = name;
            return this;
        }

        public Builder exceptionClassName(String name) {
            target.exceptionClassName = name;
            return this;
        }

        public Builder result(String result) {
            target.result = result;
            return this;
        }

        public Builder addParam(String name, String value) {
            target.params.put(name, value);
            return this;
        }

        public Builder addParams(Map<String,String> params) {
            target.params.putAll(params);
            return this;
        }

        public Builder location(Location loc) {
            target.location = loc;
            return this;
        }

        public ExceptionMappingConfig build() {
            target.params = Collections.unmodifiableMap(target.params);
            ExceptionMappingConfig result = target;
            target = new ExceptionMappingConfig(target);
            return result;
        }
    }

}

 這是它的內存里的表示：