臨時插入一個小插曲，說說SpringMVC的一些小應用。
對於框架型別的東西，不敢談的太深，容易把自己陷進去，這裡就只總結一些應用及表面的東西。

往實際點說，我認為SpringMVC最好用的地方就是檢視解析和註解。至於更深層的，自認為還不能在部落格上歸納。

這兩個特點幾乎讓我們擺脫了繁重的配置以及底層功能的實現讓我們可以更加關注業務邏輯。

1.MVC架構

說起檢視，那麼必須的瞭解到MVC架構。

這是網上隨處可見的圖，根據這個圖簡單的梳理一下，自認為沒有網上的大神理解透徹，所以不深入。

用我的視角，MVC有三個部分

所以，controller會告訴框架，我們要展示的檢視是什麼，而同時，會將模型的資料傳遞給檢視，控制器就是一個排程員。

而我們主要集中在SpringMVC對檢視的處理。

最常見的應該是這一段程式碼：

    <!-- 定義跳轉的檔案的前後綴 ，檢視模式配置-->
 
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">    
        <!-- 這裡的配置我的理解是自動給後面action的方法return的字串加上字首和字尾，變成一個 可用的url地址 -->    
        <property name="prefix" value="/WEB-INF/static/cms/" />    
        <property name="suffix" value=".jsp" />
 
    
    </bean>  

一開始對於SpringMVC的理解就只有這一段程式碼，而在專案中，我一開始也只記住了這一段程式碼。
簡單點說，就是講controller設定的檢視名稱，對映到正確的檢視上面。

這一篇只針對檢視，那麼只需要理清楚兩個地方。

• 資料對映
• 檢視指定

2.資料對映與檢視指定

資料對映說明白點，就是模型裡面的資料，我們怎麼給檢視。檢視指定就是說對映到哪個檢視。都很簡單，沒必要分開講。
通常我們常用四個物件來完成這個過程：

• ModelAndView
• Model
• ModelMap

• Map

  註解方式：

• @SessionAttribute（這個就不舉例了，感覺用的也不多）
• @ModelAttribute

這些我在一位博主的博文裡面看到了不錯的梳理
連結

我只是貼上一些實際的用法：

package com.cms.controller;

import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.mysql.fabric.Response;


/**
*@author:gang
*@version:
**/
@Controller
@RequestMapping("/test")
public class MVCTest {

    private Map<String, String> map;
    private List<String> list;
    private String [] array ={"1","2","3"};
    private String name = new String("110");

    @RequestMapping("/modelandview")
    public ModelAndView modelAndViewTest(HttpServletRequest request){
        ModelAndView modelAndView = new ModelAndView();
        //設定對比引數
        //記住，要初始化，不然會包NullpointException
        map = new HashMap<String, String>();
        HashMap<String, String> map2 = new HashMap<String, String>();
        map2.put("mapkey1", "001");
        map2.put("mapkey3", "002");
        map.put("mapkey", "mapvalue1_001");
        map.put("mapkey1", "mapvalue1_002");
        list = new LinkedList<String>();
        list.add("list1_1");
        list.add("list1_2");
        array[0]="1_1";
        name="modelandview";

        //新增資料
        modelAndView.addObject(map);
        modelAndView.addObject(map2);
        modelAndView.addObject("map", map); 
        modelAndView.addObject("list", list);   
        modelAndView.addObject("array", array);
        modelAndView.addObject("name", name);
        HttpSession session = request.getSession();
        session.setAttribute("name2", name2);
        System.out.println(modelAndView.isEmpty());
        modelAndView.setViewName("mvctest");
        System.out.println(modelAndView.getViewName());

        //返回檢視
        return modelAndView;
    }
//  
    @RequestMapping("/modelmap")
    public String modelMap(ModelMap modelMap){
        //設定對比引數
        map.put("mapkey", "mapvalue2_001");
        map.put("mapkey1", "mapvalue2_002");
        list.add("list2_1");
        list.add("list2_2");
        array[0]="2_1";
        name="modelMAP";
        //新增資料模型
        modelMap.put("map", map);
        modelMap.put("name", name);
        modelMap.addAttribute("list", list);
        modelMap.put("array", array);
        //對映檢視名
        return "mvctest";
    } 
//  
    @RequestMapping("/model")
    public String modelTest(Model model){
        //設定對比引數
        map.put("mapkey", "mapvalue3_001");
        map.put("mapkey1", "mapvalue3_002");
        list.add("list3_1");
        list.add("list3_2");
        array[0]="3_1";
        name="model";
        //新增資料模型
        model.addAttribute("name", name);
        model.addAttribute("list", list);
        model.addAttribute("array",array);
        model.addAttribute(map);
        //對映檢視名
        return "mvctest";
    }

    @RequestMapping("/map")
    public String mapTest(Map<String, Object> map){
        map.put("mapkey", "mapvalue3_001");
        map.put("mapkey1", "mapvalue3_002");
        list.add("list3_1");
        list.add("list3_2");
        name="map";
        //新增資料模型
        map.put("name", name);
        map.put("map", map);
        map.put("list", list);
        map.put("array", Arrays.asList("map4_1", "map4_2", "map4_3"));
        //對映檢視名
        return "mvctest";
    }
    //註解的使用
    @ModelAttribute(value="modelAttribute")
    public String modelAttribute(){
        return "modelAttribute success";
    }

    @ModelAttribute
    public void modelAttribute(ModelMap model){
        model.addAttribute("modelAttribute02", "modelAttribute02");
    }

}

以及對應的結果顯示

以及註解的

3.實現方式探討

這一篇我們主要是為了去探討更深層的一點，起因是這一段程式碼：

//沒有名字，他是怎麼對映的呢
modelAndView.addObject(map);

所以，我們用Debug一步步跟蹤原始碼來看看
注意，debug時tomcat的開啟會明顯變慢，需要將Tomcat的初始化時間調節一下，不然會報錯

下面正式開始：

//看到這一個方法，是不是很神奇，居然是將資料儲存在modelmap中，
//也側面解釋了modelAndView.addAllObjects(modelMap)方法的執行方式
public ModelAndView addObject(Object attributeValue) {
        getModelMap().addAttribute(attributeValue);
        return this;
}

//包括另外一個addObject
public ModelAndView addObject(String attributeName, Object attributeValue) {
        getModelMap().addAttribute(attributeName, attributeValue);
        return this;
        }

繼續：
那麼接著看，後面是怎麼執行的呢
也是分成有name和無name兩個方面

//無name
public ModelMap addAttribute(Object attributeValue) {
        Assert.notNull(attributeValue, "Model object must not be null");
        //為空的集合就返回這個ModelMap
        if (attributeValue instanceof Collection && ((Collection<?>) attributeValue).isEmpty()) {
                return this;
        }
        return addAttribute(Conventions.getVariableName(attributeValue), attributeValue);
}
//有name
public ModelMap addAttribute(String attributeName, Object attributeValue) {
        Assert.notNull(attributeName, "Model attribute name must not be null");
        put(attributeName, attributeValue);
        return this;
}

可以發現，
首先用Assert工具類進行判斷,這個工具類我們會在附件中貼上來，Asserts是Spring的斷言工具類，通常用於資料合法性檢查，可以將複雜的if判斷語句進行簡化，例如下面的例子

Assert.notNull(attributeValue, "Model object must not be null");
Assert.notNull(attributeName, "Model attribute name must not be null");

我們繼續，先進行了Assert判斷，在判斷是否為集合，並且判斷是否為空，然後進行了put操作，實際上還是將物件放到了map物件之中
對於有名字的就不多說了，這裡就只分析不帶名字的是怎麼將名字對映到物件上的
可以看到，有一個這樣的語句Conventions.getVariableName(attributeValue),

return addAttribute(Conventions.getVariableName(attributeValue), attributeValue);

很明顯，這是一個起別名的類，看一下具體的原始碼

public static String getVariableName(Object value) {
//判斷資料合法性
    Assert.notNull(value, "Value must not be null");
    //說明一個Class
    Class<?> valueClass;
    boolean pluralize = false;
    //判斷是什麼型別
    if (value.getClass().isArray()) {
        valueClass = value.getClass().getComponentType();
        pluralize = true;
    }
    else if (value instanceof Collection) {
        Collection<?> collection = (Collection<?>) value;
        if (collection.isEmpty()) {
            throw new IllegalArgumentException("Cannot generate variable name for an empty Collection");
        }
        Object valueToCheck = peekAhead(collection);
        //反射，根據值確定這個Class
        valueClass = getClassForValue(valueToCheck);
        pluralize = true;
    }
    else {
        valueClass = getClassForValue(value);
    }
    //根據屬性獲取name
    String name = ClassUtils.getShortNameAsProperty(valueClass);
    return (pluralize ? pluralize(name) : name);
}


    //到了這一步，基本上我們的推測就出來了，這個屬性的名字和型別應該是一樣的，那麼，，，我們debug看看

沒錯，是被對映為了型別名
那麼我們試試當有兩個map的時候呢

map2.put("mapkey1", "001");
map2.put("mapkey3", "002");
map.put("mapkey", "mapvalue1_001");
map.put("mapkey1", "mapvalue1_002");
modelAndView.addObject(map);
modelAndView.addObject(map2);

並沒有前面的資料。
所以說，hashmap是一個物件，在裡面可以取出所有包含的值，多個map會被後者替換

4.總結

檢視的實際應用基本上就這些了，對於其內部的詳細流程，及資料最終會被放在哪，我下次再詳細的分析。

5.附件：Assert

抽象類，每個方法的具體實現大概都可以猜出來

package org.springframework.util;

import java.util.Collection;
import java.util.Map;

public abstract class Assert {
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void isTrue(boolean expression) {
        isTrue(expression, "[Assertion failed] - this expression must be true");
    }
    public static void isNull(Object object, String message) {
        if (object != null) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void isNull(Object object) {
        isNull(object, "[Assertion failed] - the object argument must be null");
    }
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void notNull(Object object) {
        notNull(object, "[Assertion failed] - this argument is required; it must not be null");
    }
    public static void hasLength(String text, String message) {
        if (!StringUtils.hasLength(text)) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void hasLength(String text) {
        hasLength(text,
                "[Assertion failed] - this String argument must have length; it must not be null or empty");
    }
    public static void hasText(String text, String message) {
        if (!StringUtils.hasText(text)) {
            throw new IllegalArgumentException(message);
        }
    }

    public static void hasText(String text) {
        hasText(text,
                "[Assertion failed] - this String argument must have text; it must not be null, empty, or blank");
    }

    public static void doesNotContain(String textToSearch, String substring, String message) {
        if (StringUtils.hasLength(textToSearch) && StringUtils.hasLength(substring) &&
                textToSearch.contains(substring)) {
            throw new IllegalArgumentException(message);
        }
    }

    public static void doesNotContain(String textToSearch, String substring) {
        doesNotContain(textToSearch, substring,
                "[Assertion failed] - this String argument must not contain the substring [" + substring + "]");
    }

    public static void notEmpty(Object[] array, String message) {
        if (ObjectUtils.isEmpty(array)) {
            throw new IllegalArgumentException(message);
        }
    }

    public static void notEmpty(Object[] array) {
        notEmpty(array, "[Assertion failed] - this array must not be empty: it must contain at least 1 element");
    }

    public static void noNullElements(Object[] array, String message) {
        if (array != null) {
            for (Object element : array) {
                if (element == null) {
                    throw new IllegalArgumentException(message);
                }
            }
        }
    }
    public static void noNullElements(Object[] array) {
        noNullElements(array, "[Assertion failed] - this array must not contain any null elements");
    }
    public static void notEmpty(Collection<?> collection, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void notEmpty(Collection<?> collection) {
        notEmpty(collection,
                "[Assertion failed] - this collection must not be empty: it must contain at least 1 element");
    }
    public static void notEmpty(Map<?, ?> map, String message) {
        if (CollectionUtils.isEmpty(map)) {
            throw new IllegalArgumentException(message);
        }
    }
    public static void notEmpty(Map<?, ?> map) {
        notEmpty(map, "[Assertion failed] - this map must not be empty; it must contain at least one entry");
    }
    public static void isInstanceOf(Class<?> clazz, Object obj) {
        isInstanceOf(clazz, obj, "");
    }
    public static void isInstanceOf(Class<?> type, Object obj, String message) {
        notNull(type, "Type to check against must not be null");
        if (!type.isInstance(obj)) {
            throw new IllegalArgumentException(
                    (StringUtils.hasLength(message) ? message + " " : "") +
                    "Object of class [" + (obj != null ? obj.getClass().getName() : "null") +
                    "] must be an instance of " + type);
        }
    }
    public static void isAssignable(Class<?> superType, Class<?> subType) {
        isAssignable(superType, subType, "");
    }
    public static void isAssignable(Class<?> superType, Class<?> subType, String message) {
        notNull(superType, "Type to check against must not be null");
        if (subType == null || !superType.isAssignableFrom(subType)) {
            throw new IllegalArgumentException(message + subType + " is not assignable to " + superType);
        }
    }
    public static void state(boolean expression, String message) {
        if (!expression) {
            throw new IllegalStateException(message);
        }
    }
    public static void state(boolean expression) {
        state(expression, "[Assertion failed] - this state invariant must be true");
    }

}