自定義MyStruts框架

阿新 • • 發佈：2019-01-21

前言

通過之前的傳統mvc開發jsp+servlet模式引入struts框架。
首先通過案例來分析之前傳統開發的不足之處。

案例

功能：使用者登陸、註冊
登陸成功 – 首頁頁面
登入失敗–登入頁面
註冊成功 – 登陸頁面

採用mvc設計模式
Entity+Dao+service+Servlet+jsp

其中servlet作為MVC的Controller，無非就是三個步驟：
1.得到web層的資料、封裝到JavaBean
2.呼叫Service的邏輯程式碼
3.跳轉到相對應的JSP頁面

開發程式碼

UserDao.java

public class UserDao {
    // 模擬登陸
    public User login(User user){
        if ("tom".equals(user.getName()) && "888".equals(user.getPwd()) ){
            // 登陸成功
            return user;
        }
        // 登陸失敗
        return null;
    }

    // 模擬註冊
    public void register(User user) {
        System.out 
.println("註冊成功：使用者，" + user.getName());
    }
}

UserService.java

private UserDao ud = new UserDao();

    // 模擬登陸
    public User login(User user){
        return ud.login(user);
    }

    // 模擬註冊
    public void register(User user) {
        ud.register(user);
    }

LoginServlet.java

public class 
 LoginServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        //封裝屬性
        String name = request.getParameter("name");
        String pwd = request.getParameter("pwd");
        User user  = new User(name,pwd);

        //業務操作
        UserService userService = new UserService();
        User u = userService.login(user);

        //跳轉頁面
        if(u!=null){
            //跳轉到首頁
            request.getSession().setAttribute("userInfo", u);
            response.sendRedirect(request.getContextPath()+"/index.jsp");
        }else{
            //跳轉到註冊頁面
            request.getRequestDispatcher("/register.jsp").forward(request, response);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doGet(req, resp);
    }

}

RegisterServlet.java

public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        //封裝屬性
        String name = request.getParameter("name");
        String pwd = request.getParameter("pwd");
        User user  = new User(name,pwd);

        //業務操作
        UserService userService = new UserService();
        userService.register(user);

        //跳轉頁面
        response.sendRedirect(request.getContextPath()+"/login.jsp");
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        doGet(request, response);
    }

分析：
通過上面程式碼簡單實現了使用者登入和註冊功能。
傳統mvc開發不足：
1. 跳轉程式碼寫死，不靈活
2. 每次都去寫servlet，web.xml中配置servlet！
(配置目的：請求, Servlet處理類)
3.每個業務請求操作都要寫一個servlet，導致servlet過多

這時的Servlet主要起到控制的作用，如果每次都要封裝資料，呼叫service方法，處理某些業務，那麼servlet會顯得十分龐大。這時我們需要優化servlet，抽取出通用的部分，只讓它控制方法的呼叫和跳轉頁面。因此要把其中的操作封裝到一個action類中。每個servlet對應一個action類。

改造servlet+action

新增LoginAction.java

/**
 * Action表示動作類 1. 一個servlet對應一個action 2. action中負責處理具體的請求 
 */
public class LoginAction {
    public Object login(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Object uri = null;
        // 封裝屬性
        String name = request.getParameter("name");
        String pwd = request.getParameter("pwd");
        User user = new User(name, pwd);

        // 業務操作
        UserService userService = new UserService();
        User u = userService.login(user);

        // 跳轉頁面
        if (u != null) {
            // 跳轉到首頁
            request.getSession().setAttribute("userInfo", u);
            uri = "/index.jsp";
        } else {
            // 跳轉到登入頁面
            uri = request.getRequestDispatcher("/login.jsp");
        }
        return uri;
    }
}

修改LoginSerlet.java–只起到呼叫業務方法，轉發控制功能

// 建立Action物件，呼叫登陸方法
        LoginAction loginAction = new LoginAction();
        Object uri = loginAction.login(request, response);
        // 跳轉
        if (uri instanceof String) {
            response.sendRedirect(request.getContextPath() + uri.toString());
        } else {
            ((RequestDispatcher) uri).forward(request, response);
        }

RegisterAction.java

public class RegisterAction {
    public Object register(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {
        Object uri;

        // 1. 獲取請求資料，封裝
        String name = request.getParameter("name");
        String pwd = request.getParameter("pwd");
        User user = new User();
        user.setName(name);
        user.setPwd(pwd);

        // 2. 呼叫Service
        UserService userService = new UserService();
        userService.register(user);
        // 3. 跳轉
         uri = request.getRequestDispatcher("/login.jsp");
         return uri;

    }
}

RegisterServlet.java

RegisterAction registerAction = new RegisterAction();
        Object uri = registerAction.register(request, response);

        // 跳轉
        if (uri instanceof String) {
            response.sendRedirect(request.getContextPath() + uri.toString());
        } else {
            ((RequestDispatcher)uri).forward(request, response);
        }

分析：
從LoginServlet和RegisterServlet中，可以看出兩個Servlet，程式碼非常相似，只是通過不同請求，呼叫service中不同的方法，來實現頁面跳轉的。那麼，我們要想把兩個servlet合併成一個，來處理不同的請求。只需要知道請求的uri,例如：mystruts/login.action.我們通過解析uri得到login，然後根據login來找到不同的action，呼叫action中的login方法即可。如何找出指定的action呢，如果寫到程式碼裡，用if來判斷那麼不利於維護。我們可以寫在xml配置檔案中，在xml中定義不同的action，每個action定義多個處理請求的方法，然後利用反射技術來實現，根據使用者不同請求，呼叫不同的方法，實現跳轉到指定的頁面。

自定義mystruts

我們需要改造傳統的servlet開發方式，因此需要定義如下的xml配置檔案儲存action中方法，和指定的跳轉頁面。
mystruts.xml

<?xml version="1.0" encoding="UTF-8"?>
<mystruts>
    <package>
        <!-- 配置請求路徑，與處理action類的關係 -->
        <!-- 
            1. 請求路徑與處理Action的關係
                 /login = LoginAction                          login
                        success = /index.jsp                     登陸成功(重定向)
                        loginFaild  = /login.jsp                 登陸失敗           
         -->
        <action name="login" class="nwpu.geeker.framework.action.LoginAction" method="login">
            <result name="loginSuccess" type="redirect">/index.jsp</result>
            <result name="loginFaild">/login.jsp</result>
        </action>

        <action name="register" class="nwpu.geeker.framework.action.RegisterAction" method="register">
            <result name="registerSuccess">/login</result>
        </action>       
    </package>
</mystruts>

在xml檔案中指定了使用者請求uri，處理請求的Action.java,和呼叫方法以及結果顯示檢視。

我們還需要以下類來讀取配置檔案的資訊，通過反射技術來呼叫方法。
ActionMapping.java————主要封裝xml配置檔案中一個action的詳細資訊，包括：請求路徑名稱，處理請求的action類名，處理呼叫的方法，該action全部的檢視集合。
Result.java 主要封裝一個結果檢視資訊。包括指定跳轉的name,跳轉的方式（轉發、重定向等），跳轉的頁面。
ActionMappingManager.java—主要是載入xml配置檔案，儲存全部的action集合。
ActionServlet.java—–xml配置檔案中所有action共有一個servlet，根據使用者不同請求，呼叫不同action方法，實現頁面跳轉。

Resulet.java

/**
 * 封裝結果檢視
 * <result name="success" type="redirect">/index.jsp</result>
 */
public class Result {

    // 跳轉的結果標記
    private String name;
    // 跳轉型別，預設為轉發； "redirect"為重定向
    private String type;
    // 跳轉的頁面
    private String page;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getPage() {
        return page;
    }
    public void setPage(String page) {
        this.page = page;
    }

}

ActionMapping.java

/**
 * 封裝action節點
 */
public class ActionMapping {

    // 請求路徑名稱
    private String name;
    // 處理aciton類的全名
    private String className;
    // 處理方法
    private String method;
    // 結果檢視集合
    private Map<String,Result> results;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }
    public String getMethod() {
        return method;
    }
    public void setMethod(String method) {
        this.method = method;
    }
    public Map<String, Result> getResults() {
        return results;
    }
    public void setResults(Map<String, Result> results) {
        this.results = results;
    }   
}

ActionMappingManager.java

/**
 * 載入配置檔案, 封裝整個mystruts.xml
 */
public class ActionMappingManager {

    // 儲存全部action的集合
    private Map<String,ActionMapping> allActions ;

    public ActionMappingManager(){
        allActions = new HashMap<String,ActionMapping>();
        // 初始化
        this.init();
    }

    /**
     * 根據請求路徑名稱，返回Action的對映物件
     * @param actionName   當前請求路徑
     * @return             返回配置檔案中代表action節點的AcitonMapping物件
     */
    public ActionMapping getActionMapping(String actionName) {
        if (actionName == null) {
            throw new RuntimeException("傳入引數有誤，請檢視struts.xml配置的路徑。");
        }

        ActionMapping actionMapping = allActions.get(actionName);
        if (actionMapping == null) {
            throw new RuntimeException("路徑在struts.xml中找不到，請檢查");
        }
        return actionMapping;
    }

    // 初始化allActions集合
    private void init() {
        /********DOM4J讀取配置檔案***********/
        try {
            // 1. 得到解析器
            SAXReader reader = new SAXReader();
            // 得到src/mystruts.xml  檔案流
            InputStream inStream = this.getClass().getResourceAsStream("/mystruts.xml");
            // 2. 載入檔案
            Document doc = reader.read(inStream);

            // 3. 獲取根
            Element root = doc.getRootElement();

            // 4. 得到package節點
            Element ele_package = root.element("package");

            // 5. 得到package節點下，  所有的action子節點
            List<Element> listAction = ele_package.elements("action");

            // 6.遍歷 ，封裝
            for (Element ele_action : listAction) {
                // 6.1 封裝一個ActionMapping物件
                ActionMapping actionMapping = new ActionMapping();
                actionMapping.setName(ele_action.attributeValue("name"));
                actionMapping.setClassName(ele_action.attributeValue("class"));
                actionMapping.setMethod(ele_action.attributeValue("method"));

                // 6.2 封裝當前aciton節點下所有的結果檢視
                Map<String,Result> results = new HashMap<String, Result>();

                // 得到當前action節點下所有的result子節點
                 Iterator<Element> it = ele_action.elementIterator("result");
                 while (it.hasNext()) {
                     // 當前迭代的每一個元素都是 <result...>
                     Element ele_result = it.next();

                     // 封裝物件
                     Result res = new Result();
                     res.setName(ele_result.attributeValue("name"));
                     res.setType(ele_result.attributeValue("type"));
                     res.setPage(ele_result.getTextTrim());

                     // 新增到集合
                     results.put(res.getName(), res);
                 }

                // 設定到actionMapping中
                actionMapping.setResults(results);

                // 6.x actionMapping新增到map集合
                allActions.put(actionMapping.getName(), actionMapping);
            }


        } catch (Exception e) {
            throw new RuntimeException("啟動時候初始化錯誤",e);
        }
    }
}

ActionServlet.java

/**
 * 核心控制器,此專案只有這一個servlet
 * 1. 攔截所有的*.action為字尾的請求
 * 2. 請求:http://localhost:8080/mystruts/login.action
 *        http://localhost:8080/mystruts/register.action
 */
public class ActionServlet extends HttpServlet{

    private ActionMappingManager actionMappingManager;

    // 只執行一次  (希望伺服器啟動時候執行)
    @Override
    public void init() throws ServletException {
        System.out.println("ActionServlet.init()");
        actionMappingManager = new ActionMappingManager();
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        try {
            // 1. 獲取請求uri, 得到請求路徑名稱   【login】
            String uri = request.getRequestURI();
            // 得到 login
            String actionName=uri.substring(uri.lastIndexOf("/")+1, uri.indexOf(".action"));

            // 2. 根據路徑名稱，讀取配置檔案，得到類的全名   【cn..action.LoginAction】
            ActionMapping actionMapping = actionMappingManager.getActionMapping(actionName);
            String className = actionMapping.getClassName();

            // 當前請求的處理方法   【method="login"】
            String method = actionMapping.getMethod();

            // 3. 反射： 建立物件，呼叫方法； 獲取方法返回的標記
            Class<?> clazz = Class.forName(className);
            Object obj = clazz.newInstance();  //LoginAction loginAction = new LoginAction();
            Method m = clazz.getDeclaredMethod(method, HttpServletRequest.class,HttpServletResponse.class );
//注意這裡必須是HttpServletRequest.class，不能是request.getClass()，不能使執行時傳遞的//class
            // 呼叫方法返回的標記
            String returnFlag =  (String) m.invoke(obj, request, response);

            // 4. 拿到標記，讀取配置檔案得到標記對應的頁面 、 跳轉型別
            Result result = actionMapping.getResults().get(returnFlag);
            // 型別
            String type = result.getType();
            // 頁面
            String page = result.getPage();

            // 跳轉
            if ("redirect".equals(type)) {
                response.sendRedirect(request.getContextPath() + page);
            } else {
                request.getRequestDispatcher(page).forward(request, response);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        doGet(req, resp);
    }
}

Web.xml
注意：要在啟動時執行servlet初始化方法載入mystruts.xml檔案

 <!-- 核心控制器 -->
  <servlet>
    <servlet-name>ActionServlet</servlet-name>
    <servlet-class>nwpu.geeker.framework.ActionServlet</servlet-class>
    <!-- 啟動時候執行servlet初始化方法 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>ActionServlet</servlet-name>
    <url-pattern>*.action</url-pattern>
  </servlet-mapping>

總結：

由於傳統web的servlet控制器模組存在弊端：
一個專案需要建立非常多的Servlet
跳轉的頁面程式碼寫死了，不利於維護。改變需求的時候需要更改更多地程式碼
因此struts就應運而生了，本文主要簡單模擬Struts的開發流程

使用一個ActionServlet核心控制器來管理全部的Web請求，自定義XML配置檔案，儲存所有action和result資訊，然後讀取配置檔案。通過uri來判斷要呼叫哪個Action中的方法，然後根據呼叫方法的返回值，確定跳轉頁面。

自定義MyStruts框架

前言

案例

開發程式碼

改造servlet+action

自定義mystruts

總結：

自定義MyStruts框架

java 中的自定義viewUtils框架

自定義註解框架的那些事

簡單封裝自定義MVC框架

自定義xUtils框架

python web框架【補充】自定義web框架

ideat使用struts2之自定義MVC框架

自定義MVC框架之工具類-模型類

自定義web框架

JavaScript自定義勻速運動框架

Java Web自定義MVC框架詳解

自定義小型框架概述

自定義Web框架自定義Web框架

【Android進階】如何寫一個很屌的動畫（1）---先實現一個簡易的自定義動畫框架

（二十四）自定義動畫框架

自定義View框架完全解析

手把手教你如何自定義DAO框架（重量級乾貨）（yet）

day48:django前戲之HTTP協議&自定義web框架

NancyFx 2.0的開源框架的使用-CustomModule(自定義模塊)

自定義統一api返回json格式（app後臺框架搭建三）

自定義MyStruts框架

前言

案例

開發程式碼

改造servlet+action

自定義mystruts

總結：

相關推薦