架構探險筆記10-框架優化之檔案上傳

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

確定檔案上傳使用場景

通常情況下，我們可以通過一個form（表單）來上傳檔案，就以下面的“建立客戶”為例來說明（對應的檔名是customer_create.jsp），需要提供一個form，並將其enctype屬性設為multipart/form-data，表示以form data方式提交表單資料。

注意：enctype的預設值為application/x-www-form-urlencoded，表示以url encoded方式提交表單資料。

下面我們使用jQuery與jQuery Form外掛快速編寫一個基於Ajax的檔案上傳表單，程式碼如下：

<% 
@ page pageEncoding="UTF-8" contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<c:set var="BASE" value="${pageContext.request.contextPath}"/>
<html>
<head>
    <title>客戶管理-建立客戶</title>
</head 
>
<body>

<h1>建立客戶介面</h1>
${msg}
<form id="customer_form" enctype="multipart/form-data">
    <table>
        <tr>
            <td>客戶名稱：</td>
            <td><input type="text" name="name" value="${customer.name}"></td>
        </ 
tr>
        <tr>
            <td>聯絡人：</td>
            <td><input type="text" name="contact" value="${customer.contact}"></td>
        </tr>
        <tr>
            <td>電話號碼：</td>
            <td><input type="text" name="telephone" value="${customer.telephone}"></td>
        </tr>
        <tr>
            <td>郵箱地址：</td>
            <td><input type="text" name="email" value="${customer.email}"></td>
        </tr>
        <tr>
            <td>照片：</td>
            <td><input type="file" name="photo" value="${customer.photo}"></td>
        </tr>
    </table>
    <button type="submit">儲存</button>
</form>

<script src="${BASE}/asset/lib/jquery/jquery.min.js"></script>
<script src="${BASE}/asset/lib/jquery-form/jquery.form.min.js"></script>
<script>
    $(function () {
        $('#customer_form').ajaxForm({
            type:'post',
            url:'${BASE}/customer_create',
            success:function (data) {
                if(data){
                    location.href = '${BASE}/customer';
                }
            }
        });
    });
</script>
</body>
</html>

當表單提交時，請求會轉發到CustomerController的createSubmit方法上。該方法帶有一個Param引數，我們打算通過該引數來獲取“表單欄位的名值對對映”與“所上傳的檔案引數物件”，應該如何編碼呢？下面是我們要實現的目標：

@Controller
public class CustomerController {
    /**
     * 處理 建立客戶請求 - 帶圖片
     */
    @Action("post:/customer_create")
    public Data createSubmit(Param param){
        Map<String,Object> fieldMap = param.getFieldMap();
        FileParam fileParam = param.getFile("photo");
        boolean result = customerService.createCustomer(fieldMap,fileParam);
        return new Data(result);
    } 
}

呼叫Param的getFieldMap()方法來獲取表單欄位的鍵值對對映（Map fieldMap），指定一個具體的檔案欄位名稱photo，並呼叫getFile方法即可獲取對應的檔案引數物件（FileParam fileParam）。隨後，可呼叫customerService的createCustomer方法，將fieldMap與fileParam這兩個引數傳入。

Controller層的程式碼就是這樣，具體業務邏輯都在Service層了，對於CustomerService而言，只需寫幾行程式碼即可實現業務邏輯，將輸入引數存入資料庫，同時將檔案上傳到伺服器上。

@Service
public class CustomerService {
    /**
     * 建立客戶
     */
    @Transaction
    public boolean createCustomer(Map<String,Object> fieldMap,FileParam fileParam){
        Boolean result = DBHelper.insertEntity(Customer.class,fieldMap);
        if (result){
            UploadHelper.uploadFile("/tmp/upload/",fileParam);
        }
        return result;
    }
}

可見，除了使用DatabaseHelper操作資料庫，還可以通過UploadHelper將檔案上傳到指定的伺服器目錄中。

注意：實際上，完全可以通過程式碼來讀取配置檔案中定義的檔案上傳路徑，此處只是為了簡化，請注意。

我們把計劃要完成的事情總結一下：

（1）改造Param結構，可以通過它來獲取已上傳的檔案引數（FileParam）

（2）使用UploadHelper助手類來上傳檔案。

實現檔案上傳功能

我們不妨從FileParam開始，它實際上是一個用於封裝檔案引數的JavaBean，程式碼如下：

/**
 * @program: FileParam
 * @description: 封裝檔案引數的Bean
 */
public class FileParam {
    private String fieldName;  //檔案表單的欄位名
    private String fileName;   //檔名
    private long fileSize;  //檔案大小
    private String contentType;    //上傳檔案的Content-Type,可判斷檔案型別
    private InputStream inputStream;   //上傳檔案的位元組輸入流

    public FileParam(String fieldName, String fileName, long fileSize, String contentType, InputStream inputStream) {
        this.fieldName = fieldName;
        this.fileName = fileName;
        this.fileSize = fileSize;
        this.contentType = contentType;
        this.inputStream = inputStream;
    }

    public String getFieldName() {
        return fieldName;
    }

    public String getFileName() {
        return fileName;
    }

    public long getFileSize() {
        return fileSize;
    }

    public String getContentType() {
        return contentType;
    }

    public InputStream getInputStream() {
        return inputStream;
    }
}

除了檔案引數（FileParam），我們還需要一個表單引數（FormParam），程式碼如下：

/**
 * @program: FormParam
 * @description: 封裝表單引數
 */
public class FormParam {
    private String fieldName;   //表單欄位名
    private Object fieldValue;   //表單欄位值

    public FormParam(String fieldName, Object fieldValue) {
        this.fieldName = fieldName;
        this.fieldValue = fieldValue;
    }

    public String getFieldName() {
        return fieldName;
    }

    public Object getFieldValue() {
        return fieldValue;
    }
}

在一個表單中，所有的引數可分為兩類：表單引數與檔案引數。有必要將Param類做一個重構，讓它封裝這兩類引數，並提供一系列的get方法，用於從該物件中獲取指定的引數。

/**
 * @program: Param
 * @description: 請求引數物件
 */
public class Param {
    private List<FormParam> formParamList;
    private List<FileParam> fileParamList;

    public Param(List<FormParam> formParamList) {
        this.formParamList = formParamList;
    }

    public Param(List<FormParam> formParamList, List<FileParam> fileParamList) {
        this.formParamList = formParamList;
        this.fileParamList = fileParamList;
    }

    /**
     * 獲取請求引數對映
     * @return
     */
    public Map<String,Object> getFieldMap(){
        Map<String,Object> fieldMap = new HashMap<String,Object>();
        if (CollectionUtil.isNotEmpty(formParamList)){
            for (FormParam formParam:formParamList){
                String fieldName = formParam.getFieldName();   //表單引數名
                Object fieldValue = formParam.getFieldValue();   //表單引數值
                if (fieldMap.containsKey(fieldName)){   //如果已經有此引數名
                    fieldValue = fieldMap.get(fieldName) + StringUtil.SEPARATOR + fieldValue;  // 舊的資料<-->新的資料作為value
                }
                fieldMap.put(fieldName,fieldValue);
            }
        }
        return fieldMap;
    }

    /**
     * 獲取上傳檔案對映
     */
    public Map<String,List<FileParam>> getFileMap(){
        Map<String,List<FileParam>> fileMap = new HashMap<String,List<FileParam>>();

        if (CollectionUtil.isNotEmpty(fileMap)){
            for (FileParam fileParam:fileParamList){    //遍歷檔案引數
                String fieldName = fileParam.getFieldName();    //獲取表單檔案欄位名
                List<FileParam> fileParamList;
                if (fileMap.containsKey(fieldName)){    //如果Map已經存在
                    fileParamList = fileMap.get(fieldName);   //獲取Map中的值
                }else{
                    fileParamList = new ArrayList<FileParam>();  //否則,新建一個值
                }
                fileParamList.add(fileParam);   //值
                fileMap.put(fieldName,fileParamList);   //放入到表單檔案欄位名,List<FileParam>的對映中
            }
        }
        return fileMap;
    }

    /**
     * 獲取所有上傳檔案
     * @param fieldName 表單檔案欄位名
     * @return
     */
    public List<FileParam> getFileList(String fieldName){
        return getFileMap().get(fieldName);
    }

    /**
     * 獲取唯一上傳檔案
     * @param fieldName 表單檔案欄位名
     * @return
     */
    public FileParam getFile(String fieldName){
        List<FileParam> fileParamList = getFileList(fieldName);
        if (CollectionUtil.isNotEmpty(fileParamList) && fileParamList.size() ==1){
            return fileParamList.get(0);
        }
        return null;
    }

    /**
     * 驗證引數是否為空
     * @return
     */
    public boolean isEmpty(){
        return CollectionUtil.isEmpty(formParamList) && CollectionUtil.isNotEmpty(fileParamList);
    }

    /**
     * 根據引數名獲取String型引數值
     * @param name
     * @return
     */
    public String getString(String name){
        return CastUtil.castString(getFieldMap().get(name));
    }

    /**
     * 根據引數名獲取Double型引數值
     * @param name
     * @return
     */
    public Double getDouble(String name){
        return CastUtil.castDouble(getFieldMap().get(name));
    }

    /**
     * 根據引數名獲取Long型引數值
     * @param name
     * @return
     */
    public long getLong(String name){
        return CastUtil.castLong(getFieldMap().get(name));
    }
    /**
     * 根據引數名獲取int型引數值
     * @param name
     * @return
     */
    public int getInt(String name){
        return CastUtil.castInt(getFieldMap().get(name));
    }
    /**
     * 根據引數名獲取boolean型引數值
     * @param name
     * @return
     */
    public boolean getBoolean(String name){
        return CastUtil.castBoolean(getFieldMap().get(name));
    }

}

可見Param包含了兩個成員變數：List<formParamList>與List<fileParamList>；它們分別封裝了表單引數與檔案引數，隨後提供了兩個構造器，用於初始化Param物件，還提供了兩個get方法，分別用於獲取所有的表單引數與檔案引數。返回值均為Map型別，其中Map表示請求引數對映，Map表示上傳檔案對映。對於同名的請求引數，通過一個特殊的分隔符進行了處理，該分隔符定義在StringUtil類中，程式碼如下：

    /**
     * 分隔符
     */
    public static final String SEPARATOR = String .valueOf((char)29);

對於同名的上傳檔案，通過一個List進行了封裝，可輕鬆實現多檔案上傳的需求。可通過List getFileList(String fieldName) 方法獲取所有上傳檔案，若只上傳了一個檔案，則可直接使用FileParam getFile(String fieldName)方法獲取唯一上傳檔案。還提供了一個boolean isEmpty()方法，用於驗證引數是否為空。最後，提供了一組根據引數名獲取指定型別的方法，例如，String getString(String name)、double getDouble(String name)等。

可藉助Apache Commons提供的FileUpload類庫實現檔案上傳特性，首先需要在pom.xml中新增如下依賴：

        <!--檔案上傳-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

接下來我們需要編寫一個UploadHelper類來封裝Apache Commons FileUpload的相關程式碼：

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.bean.FileParam;
import org.smart4j.framework.bean.FormParam;
import org.smart4j.framework.bean.Param;
import org.smart4j.framework.util.CollectionUtil;
import org.smart4j.framework.util.FileUtil;
import org.smart4j.framework.util.StreamUtil;
import org.smart4j.framework.util.StringUtil;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @program: UploadHelper
 * @description: 檔案上傳助手類
 * @author: Created by Autumn
 * @create: 2018-12-14 16:21
 */
public final class UploadHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(UploadHelper.class);

    /**
     * Apache Commons FileUpload提供的Servlet檔案上傳物件
     */
    private static ServletFileUpload servletFileUpload;

    /**
     * 初始化
     */
    public static void init(ServletContext servletContext){
        /*獲取tomcat的work目錄*/
        File repository = (File) servletContext.getAttribute("javax.servlet.context.tempdir");

        /**
         * DiskFileItemFactory構造的兩個引數
         *  第一個引數：sizeThreadHold - 設定快取(記憶體)儲存多少位元組資料，預設為10240位元組，即10K
         *    如果一個檔案沒有大於10K，則直接使用記憶體直接儲存成檔案就可以了。
         *    如果一個檔案大於10K，就需要將檔案先儲存到臨時目錄中去。
         *  第二個引數 File 是指臨時目錄位置 - 可以不用tomcat的work目錄可以用任意一個目錄
         */
        DiskFileItemFactory fileItemFactory = new DiskFileItemFactory(DiskFileItemFactory.DEFAULT_SIZE_THRESHOLD, repository);
        servletFileUpload = new ServletFileUpload(fileItemFactory);

        int uploadLimit = ConfigHelper.getAppUploadLimit();  //獲取檔案上傳限制預設為10（M）
        if (uploadLimit != 0){
            servletFileUpload.setFileSizeMax(uploadLimit*1024*1024);   //設定單檔案最大大小為10M
        }
    }

    /**
     * 判斷請求是否為multipart型別
     */
    public static boolean isMultipart(HttpServletRequest request){
        return ServletFileUpload.isMultipartContent(request);
    }

    /**
     * 建立請求物件
     * 將request轉換為Param引數
     * @return
     */
    public static Param createParam(HttpServletRequest request) throws IOException {
        List<FormParam> formParamList = new ArrayList<FormParam>();
        List<FileParam> fileParamList = new ArrayList<FileParam>();

        try{
            /*解析request*/
            Map<String,List<FileItem>> fileItemListMap = servletFileUpload.parseParameterMap(request);   //將request轉換為Map
            if (CollectionUtil.isNotEmpty(fileItemListMap)){
                //遍歷Map集合，一個表單名可能有多個檔案
                for (Map.Entry<String,List<FileItem>> fileItemListEntry : fileItemListMap.entrySet()){
                    String fieldName = fileItemListEntry.getKey();    //獲取表單欄位名
                    List<FileItem> fileItemList = fileItemListEntry.getValue();   //檔案集合

                    if (CollectionUtil.isNotEmpty(fileItemListMap)){
                        for (FileItem fileItem:fileItemList){   //遍歷檔案集合
                            if (fileItem.isFormField()){   //如果是表單欄位
                                String fieldValue = fileItem.getString("UTF-8");
                                formParamList.add(new FormParam(fieldName,fieldValue));
                            }else{   //如果是檔案
                                String fileName = FileUtil.getRealFileName(new String(fileItem.getName().getBytes(),"UTF-8"));   //獲取檔名
                                if (StringUtil.isNotEmpty(fileName)){  //如果檔名不為空
                                    long fileSize = fileItem.getSize();  //獲取檔案大小
                                    String contentType = fileItem.getContentType();   //獲取檔案型別
                                    InputStream inputStream = fileItem.getInputStream();   //獲取檔案輸入流
                                    fileParamList.add(new FileParam(fieldName,fileName,fileSize,contentType,inputStream));
                                }
                            }
                        }
                    }
                }
            }
        } catch (FileUploadException e) {
            LOGGER.error("create param failure",e);
            throw new RuntimeException(e);
        }
        return new Param(formParamList,fileParamList);
    }


    /**
     * 上傳檔案
     * @param basePath
     * @param fileParam
     */
    public static void uploadFile(String basePath,FileParam fileParam){
        try{
            if (fileParam != null){
                String filePath = basePath + fileParam.getFileName();   //路徑+檔名
                FileUtil.createFile(filePath);  //建立檔案
                InputStream inputStream = new BufferedInputStream(fileParam.getInputStream());  //獲取檔案的輸入流
                OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(filePath));   //獲取輸出流
                StreamUtil.copyStream(inputStream,outputStream);   //輸入流拷貝到輸出流中
            }
        } catch (FileNotFoundException e) {
            LOGGER.error("upload file failure",e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 批量上傳檔案
     * @param basePath
     * @param fileParamList
     */
    public static void uploadFile(String basePath,List<FileParam> fileParamList){
        try {
            if (CollectionUtil.isNotEmpty(fileParamList)){
                for (FileParam fileParam : fileParamList){
                    uploadFile(basePath,fileParam);
                }
            }
        }catch (Exception e){
            LOGGER.error("upload file failure",e);
            throw new RuntimeException(e);
        }

    }
}

需要提供一個init方法，在該方法中初始化ServletFileUpload物件。一般情況下，只需設定一個上傳檔案的臨時目錄與上傳檔案的最大限制；上傳檔案的臨時目錄可設定為應用伺服器的臨時目錄，上傳檔案的最大限制可讓使用者自行配置。所以我們使用了ConfigHelper.getAppUploadLimit()來獲取，可以在smart.properties檔案中進行配置。

首先，在ConfigConstant中新增一個配置常量APP_UPLOAD_LIMIT;

    String APP_UPLOAD_LIMIT = "smart.framework.app.upload_limit";

這也就意味著，我們可以在smart.properties檔案中使用smart.framwork.app.upload_limit配置項來設定上傳檔案的最大限制。

然後，在ConfigHelper中新增一個int getAppUploadLimit()方法，用於獲取該配置的值，此時可設定該配置的初始值（10），也就是說，若不在smart.properties檔案中提供該配置，則上傳檔案的最大限制是10MB。

public class ConfigHelper {
    /**
     * 獲取應用檔案上傳限制
     * @return
     */
    public static int getAppUploadLimit(){
        return PropsUtil.getInt(CONFIG_PROPS,ConfigConstant.APP_UPLOAD_LIMIT,10);
    }
}

在UploadHelper中提供一個boolean isMultipart(HttpServletRequest request)方法，用於判斷當前請求物件是否為multipart型別。只有在上傳檔案時對應的請求型別才是multipart型別，也就是說，可通過isMultipart方法來判斷當前請求時否為檔案上傳請求。

接下來提供一個非常重要的方法，可從當前請求中建立Param物件，它就是Param createParam(HttpServletRequest request)方法：其中我們使用了ServletFileUpload物件來解析請求引數，並通過遍歷所有請求引數來初始化List formParamList與List fileParamList變數的值。在遍歷請求引數時，需要對當前的org.apache.commons.fileupload.FileItem物件進行判斷，若為普通表單欄位（呼叫fileItem.isFormField()返回true），則建立FormParam物件，並新增到formParamList物件中。否則即為檔案上傳欄位，通過FileUtil提供的getRealFileName來獲取上傳檔案後的真實檔名，並從FileItem物件中構造FileParam物件，新增到fileParamList物件中，最後，通過formParamList與fileParamList來構造Param物件並返回。

FileUtil程式碼如下

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;

/**
 * @program: FileUtil
 * @description: 檔案操作工具類
 * @author: Created by Autumn
 * @create: 2018-12-19 13:03
 */
public class FileUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(FileUtil.class);

    /**
     * 獲取真實檔名(自動去掉檔案路徑)
     *
     * @param fileName
     * @return
     */
    public static String getRealFileName(String fileName) {
        return FilenameUtils.getName(fileName);
    }

    /**
     * 建立檔案
     *
     * @param filePath
     * @return
     */
    public static File createFile(String filePath) {
        File file;
        file = new File(filePath);   //根據路徑建立檔案
        try {
            File parentDir = file.getParentFile();   //獲取檔案父目錄
            if (!parentDir.exists()) {  //判斷上層目錄是否存在
                FileUtils.forceMkdir(parentDir);   //建立父級目錄
            }
        } catch (IOException e) {
            LOGGER.error("create file failure",e);
            throw new RuntimeException(e);
            //e.printStackTrace();
        }
        return file;
    }
}

最後提供兩個用於上傳檔案的方法，一個用於上傳單個檔案，另一個用於批量上傳。此時用到了StreamUtil工具類的copyStream方法，程式碼如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;

/**
 * @program: StreamUtil
 * @description: 流操作常用工具類
 * @author: Created by Autumn
 * @create: 2018-10-24 15:41
 */
public class StreamUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(StreamUtil.class);

    /**
     * 從輸入流中獲取字串
     * @param is
     * @return
     */
    public static String getString(InputStream is){
        StringBuilder sb = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            String line;
            while((line=reader.readLine())!=null){
                sb.append(line);
            }
        } catch (IOException e) {
            LOGGER.error("get string failure",e);
            throw new RuntimeException(e);
        }
        return sb.toString();
    }

    /**
     * 將輸入流複製到輸出流
     * @param inputStream 輸入流
     * @param outputStream 輸出流
     */
    public static void copyStream(InputStream inputStream, OutputStream outputStream){
        try {
            int length;
            byte[] buffer = new byte[4*1024];
            while((length = inputStream.read(buffer,0,buffer.length)) != -1){
                outputStream.write(buffer,0,length);
            }
            outputStream.flush();
        } catch (IOException e) {
            LOGGER.error("copy stream failure",e);
            throw new RuntimeException(e);
        } finally {
            try {
                inputStream.close();
                outputStream.close();
            } catch (IOException e) {
                LOGGER.error("close stream failure",e);
            }
        }
    }

}

現在UploadHelper已編寫完畢，接下來需要找一個地方來呼叫init方法。整個web框架的入口也就是DispatcherServlet的init方法了，所有我們需要在該方法中呼叫UploadHelper的init方法。

除了在DispatcherServlet的init方法中新增一行程式碼，還需要對service程式碼進行一些重構。首先需要跳過/favicon.ico請求，只處理普通的請求。然後需要判斷請求物件是否為上傳檔案，針對兩種不同的情況來建立Param物件，其中通過UploadHelper來建立的方式已在前面描述了。相應的，我們也對以前的程式碼進行封裝，提供一個名為RequestHelper類，並通過它的createParam方法來初始化Param物件。

import org.smart4j.framework.bean.FormParam;
import org.smart4j.framework.bean.Param;
import org.smart4j.framework.util.ArrayUtil;
import org.smart4j.framework.util.CodecUtil;
import org.smart4j.framework.util.StreamUtil;
import org.smart4j.framework.util.StringUtil;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
 * @program: RequestHelper
 * @description: 請求助手類
 * @author: Created by Autumn
 * @create: 2018-12-25 13:22
 */
public class RequestHelper {

    public static Param createParam(HttpServletRequest request) throws IOException {
        List<FormParam> formParamList = new ArrayList<>();
        formParamList.addAll(parseParameterNames(request));
        formParamList.addAll(parseInputStream(request));
        return new Param(formParamList);
    }

    /**
     * 獲取Form表單普通引數並放入List<FormParam>中
     * 適用於application/x-www-form-urlencoded
     * @param request
     * @return List<FormParam>
     */
    private static List<FormParam> parseParameterNames(HttpServletRequest request){
        List<FormParam> formParamList = new ArrayList<FormParam>();
        Enumeration<String> paramNames = request.getParameterNames();   //獲取request中的所有引數名稱列舉
        while (paramNames.hasMoreElements()){   //遍歷引數名列舉
            String fieldName = paramNames.nextElement();   //獲取引數名稱
            //!!!!!!!!獲取引數值(例如CheckBox的值有多個) request.getParameter(String name)是獲得相應名的資料，如果有重複的名，則返回第一個的值.
            String[] fieldValues = request.getParameterValues(fieldName);
            if (ArrayUtil.isNotEmpty(fieldValues)){   //判斷是否為空
                Object fieldValue;   //引數最終值
                if (fieldValues.length == 1){  //如果只有一個值
                    fieldValue = fieldValues[0];   //直接賦值
                } else {  //如果有多個值(CheckBox多選)
                    StringBuilder sb = new StringBuilder("");
                    for (int i = 0; i< fieldValues.length; i++){  //遍歷
                        sb.append(fieldValues[i]);
                        if (i != fieldValues.length-1){  //如果不是最後一個
                            sb.append(StringUtil.SEPARATOR);  //加上通用分割符
                        }
                    }
                    fieldValue = sb.toString();

                }
                formParamList.add(new FormParam(fieldName,fieldValue));   //將引數鍵值對加入List引數列表中去
            }
        }
        return formParamList;
    }

    /**
     * 獲取引數流並放入List<FormParam>中
     * 適用於application/json，text/xml，multipart/form-data文字流或者大檔案形式提交的請求或者xml等形式的報文
     * @param request
     * @return
     * @throws IOException
     */
    private static List<FormParam> parseInputStream(HttpServletRequest request) throws IOException {
        List<FormParam> formParamList = new ArrayList<FormParam>();

        String body = CodecUtil.decodeURL(StreamUtil.getString(request.getInputStream()));
        if (StringUtil.isNotEmpty(body)){
            String[] kvs = StringUtil.splitString(body,"&");
            if (ArrayUtil.isNotEmpty(kvs)){
                for (String kv:kvs) {
                    String[] array = StringUtil.splitString(kv, "=");
                    if (ArrayUtil.isNotEmpty(array) && array.length == 2){
                        String fieldName = array[0];
                        String fieldValue = array[1];
                        formParamList.add(new FormParam(fieldName,fieldValue));
                    }
                }
            }
        }
        return formParamList;
    }
}

可見以上程式碼邏輯並未變化，只是將以前放在DispatcherServlet中的相關程式碼搬到了RequestHelper中了。最後獲取的View同樣也分兩種情況進行了處理，只是此時並未提供其他類來封裝這些程式碼，而是直接在當前類中添加了兩個私有方法handleViewResult與handleDataResult。

重構後的Dispatcher程式碼

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.smart4j.framework.bean.Data;
import org.smart4j.framework.bean.Handler;
import org.smart4j.framework.bean.Param;
import org.smart4j.framework.bean.View;
import org.smart4j.framework.helper.*;
import org.smart4j.framework.util.*;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: DispatcherServlet
 * @description: 請求轉發器
 * @author: Created by Autumn
 * @create: 2018-10-24 11:34
 */

@WebServlet(urlPatterns = "/*",loadOnStartup = 0)
public class DispatcherServlet extends HttpServlet {
    private static final Logger LOGGER = LoggerFactory.getLogger(DispatcherServlet.class);

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        //初始化相關Helper類
        HelperLoader.init();
        //獲取ServletContext物件(用於註冊Servlet)
        ServletContext servletContext = servletConfig.getServletContext();
        //註冊處理JSP的Servlet
        ServletRegistration jspServlet = servletContext.getServletRegistration("jsp");
        jspServlet.addMapping(ConfigHelper.getAppJspPath()+"*");
        //註冊處理靜態資源的預設Servlet
        ServletRegistration defaultServlet = servletContext.getServletRegistration("default");
        defaultServlet.addMapping(ConfigHelper.getAppAssetPath()+"*");
        //初始化上傳檔案大小，以及超過最大大小存放的目錄
        UploadHelper.init(servletContext);
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //獲取請求方法與請求路徑
        String requestMethod = req.getMethod().toLowerCase();
        String requestPath = req.getPathInfo();

        if (requestPath.equals("\favicon.ico")){
            return ;
        }
        //獲取Action處理器
        Handler handler= ControllerHelper.getHandler(requestMethod,requestPath);
        if(handler!=null){
            //獲取Controller類機器Bean例項
            Class<?> controllerClass = handler.getControllerClass();
            Object controllerBean = BeanHelper.getBean(controllerClass);

            Param param;
            if (UploadHelper.isMultipart(req)){   //如果是multipart/form-data stream
                param = UploadHelper.createParam(req);   //multipart方式
            }else{   //如果是非multipart方式提交(即application/x-www-form-urlencoded，application/json，text/xml)
                param = RequestHelper.createParam(req);   //非multipart表單方式
            }

            /*將一下程式碼放入RequestHelper中去
            //建立請求引數物件
            Map<String,Object> paramMap = new HashMap<String, Object>();
            Enumeration<String> paramNames = req.getParameterNames();
            while(paramNames.hasMoreElements()){
                String paramName = paramNames.nextElement();
                String paramValue = req.getParameter(paramName);
                paramMap.put(paramName,paramValue);
            }
            //獲取請求body中的引數
            String body = CodecUtil.decodeURL(StreamUtil.getString(req.getInputStream()));
            if (StringUtil.isNotEmpty(body)){
                String[] params = StringUtil.splitString(body,"&");
                if (ArrayUtil.isNotEmpty(params)){
                    for (String param:params){
                        String[] array = StringUtil.splitString(param,"=");
                        if (ArrayUtil.isNotEmpty(array)&&array.length==2){
                            String paramName = array[0];
                            String paramValue = array[1];
                            paramMap.put(paramName,paramValue);
                        }
                    }
                }
            }
            Param param = new Param(paramMap);
            */

            Object result = null;
            //呼叫Action方法
            Method actionMethod = handler.getActionMethod();
            /*優化沒有引數的話不需要寫引數*/
            if (param.isEmpty()){  //如果沒有引數
                result = ReflectionUtil.invokeMethod(controllerBean,actionMethod);  //就不傳引數
            }else{  //有引數
                result = ReflectionUtil.invokeMethod(controllerBean,actionMethod,param);  //傳引數
            }

            //處理Action方法返回值
            if (result instanceof View){
                //返回JSP頁面
                handleViewResult((View) result, req, resp);
            }else if (result instanceof Data){
                //返回Json資料
                handleDataResult((Data) result, resp);
            }
        }else{
            LOGGER.error("Request-Handler Mapping get null by Request("+requestMethod+","+requestPath+")");
            throw new RuntimeException("Request-Handler Mapping get null by Request("+requestMethod+","+requestPath+")");
        }

    }

    /**
     * 處理Json格式的資料
     * @param result Data物件
     * @param resp
     * @throws IOException
     */
    private void handleDataResult(Data result, HttpServletResponse resp) throws IOException {
        Data data = result;
        Object model = data.getModel();
        if (model!=null){
            resp.setContentType("application/json");
            resp.setCharacterEncoding("UTF-8");
            PrintWriter writer = resp.getWriter();
            String json = JsonUtil.toJson(model);
            writer.write(json);
            writer.flush();
            writer.close();
        }
    }

    /**
     * 處理檢視結果
     * @param result View物件(jsp路徑+資料)
     * @param req
     * @param resp
     * @throws IOException
     * @throws ServletException
     */
    private void handleViewResult(View result, HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        View view = result;
        String path = view.getPath();
        if (StringUtil.isNotEmpty(path)){
            if (path.startsWith("/")){   //如果View的Path以/開頭則以專案根目錄為根路徑
                resp.sendRedirect(req.getContextPath()+path);
            } else {    //如果View的Path沒有以/開頭,則以配置的APPJSP(/WEB-INF/view/)為根目錄
                Map<String,Object> model = view.getModel();
                for (Map.Entry<String,Object> entry:model.entrySet()){
                    req.setAttribute(entry.getKey(),entry.getValue());
                }
                req.getRequestDispatcher(ConfigHelper.getAppJspPath()+path).forward(req,resp);
            }

        }
    }
}

此時，一個簡單的檔案上傳特性已基本具備，可以在框架中正常使用了。

可能出現的問題

1.獲取註冊處理JSP的Servlet報錯

問題程式碼

這是因為tomcat用的是maven外掛，並不是真實的tomcat。所以導致獲取jsp的servlet失敗。

2.jQuery未引入導致用原生form提交

原生form提交的幾個要素

action：url 地址，伺服器接收表單資料的地址

method：提交伺服器的http方法，一般為post和get
enctype: 表單資料提交時使用的編碼型別，預設使用 "pplication/x-www-form-urlencoded" 。如果是使用POST請求，則請求頭中的content-type指定值就是該值。如果表單中有上傳檔案，編碼型別需要使用 "multipart/form-data" ，型別，才能完成傳遞檔案資料。

寫了method、enctype和action後，最後form表單的提交按鈕要用

<input type="submit">儲存</input>

缺一個都會用預設的get方式提交。

<form id="customer_form" action="${BASE}/customer_create" method="post" enctype="multipart/form-data">
    <input type="submit">儲存</input>
</form>

3.原生form表單提交multipart/form-data時檔案沒有內容

架構探險筆記10-框架優化之檔案上傳

確定檔案上傳使用場景

實現檔案上傳功能

可能出現的問題

1.獲取註冊處理JSP的Servlet報錯

2.jQuery未引入導致用原生form提交

架構探險筆記10-框架優化之檔案上傳

架構探險筆記9-框架優化

laravel框架之檔案上傳

【Android架構】基於MVP模式的Retrofit2+RXjava封裝之檔案上傳（三）

SpringMVC筆記八之檔案上傳下載

SSM框架之檔案上傳

CodeIgniter框架之檔案上傳

play框架之檔案上傳

ZendFramework之檔案上傳－－－待優化

falsk之檔案上傳

Spring Boot 整合之檔案上傳與下載

Struts2之檔案上傳與下載

Java架構-Spring mvc+oss儲存+fileupload多檔案上傳實現SSO單點登入模板管理

web安全之檔案上傳漏洞攻擊與防範方法

react-native之檔案上傳下載

SpringBoot | 第十七章：web 應用開發之檔案上傳

python3 + selenium 之檔案上傳下載

spring boot之檔案上傳

SpringMVC之檔案上傳（進度條顯示）

Python介面自動化測試之檔案上傳

架構探險筆記10-框架優化之檔案上傳

確定檔案上傳使用場景

實現檔案上傳功能

可能出現的問題

1.獲取註冊處理JSP的Servlet報錯

2.jQuery未引入導致用原生form提交

相關推薦