（轉自：孤傲蒼狼）簡單模擬Sping MVC

轉自：

http://www.cnblogs.com/xdp-gacl/p/4101727.html

在Spring MVC中，將一個普通的java類標註上Controller註解以後，再將類中的方法使用RequestMapping註解標註，那麼這個普通的java類就夠處理Web請求，示例代碼以下：

/**
 * 使用Controller註解標註LoginUI類
 */
@Controller
public class LoginUI {
    
    //使用RequestMapping註解指明forward1方法的訪問路徑  
    @RequestMapping("LoginUI/Login2")
    public View forward1(){
        //執行完forward1方法以後返回的視圖
        return new View("/login2.jsp");  
    }
    
    //使用RequestMapping註解指明forward2方法的訪問路徑  
    @RequestMapping("LoginUI/Login3")
    public View forward2(){
        //執行完forward2方法以後返回的視圖
        return new View("/login3.jsp");  
    } 
}

    spring經過java annotation就能夠註釋一個類爲action ，在方法上添加上一個java annotation 就能夠配置請求的路徑了，那麼這種機制是如何實現的呢，今天咱們使用"自定義註解+Servlet"來簡單模擬一下Spring MVC中的這種註解配置方式。

1、編寫註解

1.一、Controller註解

　　開發Controller註解，這個註解只有一個value屬性，默認值爲空字符串，代碼以下：

package me.gacl.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* @ClassName: Controller
* @Description: 自定義Controller註解
* @author: 孤傲蒼狼
* @date: 2014-11-16 下午6:16:40
*
*/ 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Controller {

    public String value() default "";
}

1.二、RequestMapping註解

　　開發RequestMapping註解，用於定義請求路徑，這個註解只有一個value屬性，默認值爲空字符串，代碼以下：

package me.gacl.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 定義請求路徑的java annotation
 */
@Target(ElementType.METHOD) 
@Retention(RetentionPolicy.RUNTIME)  
public @interface RequestMapping {

    public String value() default "";
}

    以上就是咱們自定義的兩個註解，註解的開發工做就算是完成了，有了註解以後，那麼就必須針對註解來編寫處理器，不然咱們開發的註解配置到類或者方法上面是不起做用的，這裏咱們使用Servlet來做爲註解的處理器。

2、編寫核心的註解處理器

2.一、開發AnnotationHandleServlet

　　這裏使用一個Servlet來做爲註解處理器，編寫一個AnnotationHandleServlet，代碼以下：

package me.gacl.web.controller;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Set;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import me.gacl.annotation.Controller;
import me.gacl.annotation.RequestMapping;
import me.gacl.util.BeanUtils;
import me.gacl.util.RequestMapingMap;
import me.gacl.util.ScanClassUtil;
import me.gacl.web.context.WebContext;
import me.gacl.web.view.DispatchActionConstant;
import me.gacl.web.view.View;

/**
 * <p>ClassName: AnnotationHandleServlet<p>
 * <p>Description: AnnotationHandleServlet做爲自定義註解的核心處理器以及負責調用目標業務方法處理用戶請求<p>
 * @author xudp
 * @version 1.0 V
 */
public class AnnotationHandleServlet extends HttpServlet {
    
    private String pareRequestURI(HttpServletRequest request){
        String path = request.getContextPath()+"/";
        String requestUri = request.getRequestURI();
        String midUrl = requestUri.replaceFirst(path, "");
        String lasturl = midUrl.substring(0, midUrl.lastIndexOf("."));
        return lasturl;
    }
    
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.excute(request, response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.excute(request, response);
    }
    
    private void excute(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        //將當前線程中HttpServletRequest對象存儲到ThreadLocal中，以便在Controller類中使用
        WebContext.requestHodler.set(request);
        //將當前線程中HttpServletResponse對象存儲到ThreadLocal中，以便在Controller類中使用
        WebContext.responseHodler.set(response);
        //解析url
        String lasturl = pareRequestURI(request);
        //獲取要使用的類
        Class<?> clazz = RequestMapingMap.getRequesetMap().get(lasturl);
        //建立類的實例
        Object classInstance = BeanUtils.instanceClass(clazz);
        //獲取類中定義的方法
        Method [] methods = BeanUtils.findDeclaredMethods(clazz);
        Method method = null;
        for(Method m:methods){//循環方法，找匹配的方法進行執行
            if(m.isAnnotationPresent(RequestMapping.class)){
                String anoPath = m.getAnnotation(RequestMapping.class).value();
                if(anoPath!=null && !"".equals(anoPath.trim()) && lasturl.equals(anoPath.trim())){
                    //找到要執行的目標方法
                    method = m;
                    break;
                }
            }
        }
        try {
            if(method!=null){
                //執行目標方法處理用戶請求
                Object retObject = method.invoke(classInstance);
                //若是方法有返回值，那麼就表示用戶須要返回視圖
                if (retObject!=null) {
                    View view = (View)retObject;
                    //判斷要使用的跳轉方式
                    if(view.getDispathAction().equals(DispatchActionConstant.FORWARD)){
                        //使用服務器端跳轉方式
                        request.getRequestDispatcher(view.getUrl()).forward(request, response);
                    }else if(view.getDispathAction().equals(DispatchActionConstant.REDIRECT)){
                        //使用客戶端跳轉方式
                        response.sendRedirect(request.getContextPath()+view.getUrl());
                    }else{
                        request.getRequestDispatcher(view.getUrl()).forward(request, response);
                    }
                }
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void init(ServletConfig config) throws ServletException {
        /**
         * 重寫了Servlet的init方法後必定要記得調用父類的init方法，
         * 不然在service/doGet/doPost方法中使用getServletContext()方法獲取ServletContext對象時
         * 就會出現java.lang.NullPointerException異常
         */
        super.init(config); 
        System.out.println("---初始化開始---");
        //獲取web.xml中配置的要掃描的包
        String basePackage = config.getInitParameter("basePackage");
        //若是配置了多個包，例如：<param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
        if (basePackage.indexOf(",")>0) {
            //按逗號進行分隔
            String[] packageNameArr = basePackage.split(",");
            for (String packageName : packageNameArr) {
                initRequestMapingMap(packageName);
            }
        }else {
            initRequestMapingMap(basePackage);
        }
        System.out.println("----初始化結束---");
    }
    
    /**
    * @Method: initRequestMapingMap
    * @Description:添加使用了Controller註解的Class到RequestMapingMap中
    * @Anthor:孤傲蒼狼
    * @param packageName
    */ 
    private void initRequestMapingMap(String packageName){
        Set<Class<?>> setClasses =  ScanClassUtil.getClasses(packageName);
        for (Class<?> clazz :setClasses) {
            if (clazz.isAnnotationPresent(Controller.class)) {
                Method [] methods = BeanUtils.findDeclaredMethods(clazz);
                for(Method m:methods){//循環方法，找匹配的方法進行執行
                    if(m.isAnnotationPresent(RequestMapping.class)){
                        String anoPath = m.getAnnotation(RequestMapping.class).value();
                        if(anoPath!=null && !"".equals(anoPath.trim())){
                            if (RequestMapingMap.getRequesetMap().containsKey(anoPath)) {
                                throw new RuntimeException("RequestMapping映射的地址不容許重複！");
                            }
                            RequestMapingMap.put(anoPath, clazz);
                        }
                    }
                }
            }
        }
    }
}

這裏說一下AnnotationHandleServlet的實現思路

　　一、AnnotationHandleServlet初始化(init)時掃描指定的包下面使用了Controller註解的類，以下圖所示：

　二、遍歷類中的方法，找到類中使用了RequestMapping註解標註的那些方法，獲取RequestMapping註解的value屬性值，value屬性值指明瞭該方法的訪問路徑，以RequestMapping註解的value屬性值做爲key，Class類做爲value將存儲到一個靜態Map集合中。以下圖所示：

    當用戶請求時(不管是get仍是post請求)，會調用封裝好的execute方法 ，execute會先獲取請求的url，而後解析該URL，根據解析好的URL從Map集合中取出要調用的目標類 ，再遍歷目標類中定義的全部方法，找到類中使用了RequestMapping註解的那些方法，判斷方法上面的RequestMapping註解的value屬性值是否和解析出來的URL路徑一致,若是一致，說明了這個就是要調用的目標方法，此時就能夠利用java反射機制先實例化目標類對象，而後再經過實例化對象調用要執行的方法處理用戶請求。服務器將如下圖的方式與客戶端進行交互

　　另外，方法處理完成以後須要給客戶端發送響應信息，好比告訴客戶端要跳轉到哪個頁面，採用的是服務器端跳轉仍是客戶端方式跳轉，或者發送一些數據到客戶端顯示，那麼該如何發送響應信息給客戶端呢，在此，咱們能夠設計一個View(視圖)類，對這些操做屬性進行封裝，其中包括跳轉的路徑 、展示到頁面的數據、跳轉方式。這就是AnnotationHandleServlet的實現思路。

2.二、在Web.xml文件中註冊AnnotationHandleServlet

　　在web.xml文件中配置AnnotationHandleServlet和須要掃描的包

<servlet>
    <servlet-name>AnnotationHandleServlet</servlet-name>
    <servlet-class>me.gacl.web.controller.AnnotationHandleServlet</servlet-class>
    <init-param>
         <description>配置要掃描包及其子包, 若是有多個包,以逗號分隔</description>
        <param-name>basePackage</param-name>
        <param-value>me.gacl.web.controller,me.gacl.web.UI</param-value>
        <!-- <param-value>me.gacl.web.controller</param-value> -->
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>AnnotationHandleServlet</servlet-name>
    <!-- 攔截全部以.do後綴結尾的請求 -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

3、相關代碼講解

3.一、BeanUtils

　　BeanUtils工具類主要是用來處理一些反射的操做

package me.gacl.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * 對java反射中操做的一些封裝
 */
public class BeanUtils {
    
    /**
     * 實例化一個class 
     * @param <T>
     * @param clazz Person.class
     * @return
     */
    public static <T> T instanceClass(Class<T> clazz){
        if(!clazz.isInterface()){
            try {
                return clazz.newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    
    /**
     * 經過構造函數實例化
     * @param <T>
     * @param ctor
     * @param args
     * @return
     * @throws IllegalArgumentException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    public static <T> T instanceClass(Constructor<T> ctor, Object... args)
            throws IllegalArgumentException, InstantiationException, 
            IllegalAccessException, InvocationTargetException{
        makeAccessible(ctor);
        return ctor.newInstance(args);//調用構造方法實例化
    }
    
    /**
     * 查找某個class的方法
     * @param clazz
     * @param methodName
     * @param paramTypes
     * @return
     * @throws SecurityException
     * @throws NoSuchMethodException
     */
    public static  Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes){
        try {
            return clazz.getMethod(methodName, paramTypes);
        } catch (NoSuchMethodException e) {
            return findDeclaredMethod(clazz, methodName, paramTypes);//返回共有的方法
        }
    }
    
    public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>[] paramTypes){
        try {
            return clazz.getDeclaredMethod(methodName, paramTypes);
        }
        catch (NoSuchMethodException ex) {
            if (clazz.getSuperclass() != null) {
                return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);
            }
            return null;
        }
    }
    
    public static Method [] findDeclaredMethods(Class<?> clazz){
            return clazz.getDeclaredMethods();
    }
    
    public static void makeAccessible(Constructor<?> ctor) {
        if ((!Modifier.isPublic(ctor.getModifiers()) 
                || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers()))
                && !ctor.isAccessible()) {
            ctor.setAccessible(true);//若是是私有的 設置爲true 使其能夠訪問
        }
    }
    
    public static Field[] findDeclaredFields(Class<?> clazz){
        return clazz.getDeclaredFields();
    }
}

3.二、RequestMapingMap

　　該類是用於存儲方法的訪問路徑，AnnotationHandleServlet初始化時會將類(使用Controller註解標註的那些類)中使用了RequestMapping註解標註的那些方法的訪問路徑存儲到RequestMapingMap中。

package me.gacl.util;

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

/**
* @ClassName: RequestMapingMap
* @Description: 存儲方法的訪問路徑
* @author: 孤傲蒼狼
* @date: 2014-11-16 下午6:31:43
*
*/ 
public class RequestMapingMap {

    /**
    * @Field: requesetMap
    *          用於存儲方法的訪問路徑
    */ 
    private static Map<String, Class<?>> requesetMap = new HashMap<String, Class<?>>();
    
    public static Class<?> getClassName(String path) {
        return requesetMap.get(path);
    }

    public static void put(String path, Class<?> className) {
        requesetMap.put(path, className);
    }

    public static Map<String, Class<?>> getRequesetMap() {
        return requesetMap;
    }
}

3.三、ScanClassUtil

　　掃描某個包下面的類的工具類

package me.gacl.util;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
* @ClassName: ScanClassUtil
* @Description: 掃描指定包或者jar包下面的class
* @author: 孤傲蒼狼
* @date: 2014-11-16 下午6:34:10
*
*/ 
public class ScanClassUtil {

    /**
     * 從包package中獲取全部的Class
     * 
     * @param pack
     * @return
     */
    public static Set<Class<?>> getClasses(String pack) {

        // 第一個class類的集合
        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
        // 是否循環迭代
        boolean recursive = true;
        // 獲取包的名字 並進行替換
        String packageName = pack;
        String packageDirName = packageName.replace('.', '/');
        // 定義一個枚舉的集合 並進行循環來處理這個目錄下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(
                    packageDirName);
            // 循環迭代下去
            while (dirs.hasMoreElements()) {
                // 獲取下一個元素
                URL url = dirs.nextElement();
                // 獲得協議的名稱
                String protocol = url.getProtocol();
                // 若是是以文件的形式保存在服務器上
                if ("file".equals(protocol)) {
                    System.err.println("file類型的掃描");
                    // 獲取包的物理路徑
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式掃描整個包下的文件 並添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath,
                            recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 若是是jar包文件
                    // 定義一個JarFile
                    System.err.println("jar類型的掃描");
                    JarFile jar;
                    try {
                        // 獲取jar
                        jar = ((JarURLConnection) url.openConnection())
                                .getJarFile();
                        // 今後jar包 獲得一個枚舉類
                        Enumeration<JarEntry> entries = jar.entries();
                        // 一樣的進行循環迭代
                        while (entries.hasMoreElements()) {
                            // 獲取jar裏的一個實體 能夠是目錄 和一些jar包裏的其餘文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 若是是以/開頭的
                            if (name.charAt(0) == '/') {
                                // 獲取後面的字符串
                                name = name.substring(1);
                            }
                            // 若是前半部分和定義的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 若是以"/"結尾 是一個包
                                if (idx != -1) {
                                    // 獲取包名 把"/"替換成"."
                                    packageName = name.substring(0, idx)
                                            .replace('/', '.');
                                }
                                // 若是能夠迭代下去 而且是一個包
                                if ((idx != -1) || recursive) {
                                    // 若是是一個.class文件 並且不是目錄
                                    if (name.endsWith(".class")
                                            && !entry.isDirectory()) {
                                        // 去掉後面的".class" 獲取真正的類名
                                        String className = name.substring(
                                                packageName.length() + 1, name
                                                        .length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class
                                                    .forName(packageName + '.'
                                                            + className));
                                        } catch (ClassNotFoundException e) {
                                            // log
                                            // .error("添加用戶自定義視圖類錯誤 找不到此類的.class文件");
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        // log.error("在掃描用戶定義視圖時從jar包獲取文件出錯");
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }
    
    /**
     * 以文件的形式來獲取包下的全部Class
     * 
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName,
            String packagePath, final boolean recursive, Set<Class<?>> classes) {
        // 獲取此包的目錄 創建一個File
        File dir = new File(packagePath);
        // 若是不存在或者 也不是目錄就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            // log.warn("用戶定義包名 " + packageName + " 下沒有任何文件");
            return;
        }
        // 若是存在 就獲取包下的全部文件 包括目錄
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定義過濾規則 若是能夠循環(包含子目錄) 或則是以.class結尾的文件(編譯好的java類文件)
            public boolean accept(File file) {
                return (recursive && file.isDirectory())
                        || (file.getName().endsWith(".class"));
            }
        });
        // 循環全部文件
        for (File file : dirfiles) {
            // 若是是目錄 則繼續掃描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "."
                        + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 若是是java類文件 去掉後面的.class 只留下類名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    //classes.add(Class.forName(packageName + '.' + className));
                     //通過回覆同窗的提醒，這裏用forName有一些很差，會觸發static方法，沒有使用classLoader的load乾淨
                    classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));  
                    } catch (ClassNotFoundException e) {
                    // log.error("添加用戶自定義視圖類錯誤 找不到此類的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }
}

3.四、WebContext

　　WebContext主要是用來存儲當前線程中的HttpServletRequest和HttpServletResponse，當別的地方須要使用HttpServletRequest和HttpServletResponse，就能夠經過requestHodler和responseHodler獲取，經過WebContext.java這個類 ，咱們能夠在做爲Controller的普通java類中獲取當前請求的request、response或者session相關請求類的實例變量，而且線程間互不干擾的，由於用到了ThreadLocal這個類。

package me.gacl.web.context;

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

/**
 * WebContext主要是用來存儲當前線程中的HttpServletRequest和HttpServletResponse
 * 當別的地方須要使用HttpServletRequest和HttpServletResponse，就能夠經過requestHodler和responseHodler獲取
 **/
public class WebContext {

    public static ThreadLocal<HttpServletRequest> requestHodler = new ThreadLocal<HttpServletRequest>();
    public static ThreadLocal<HttpServletResponse> responseHodler = new ThreadLocal<HttpServletResponse>();
   
    public HttpServletRequest getRequest(){
           return requestHodler.get();
    }
   
    public HttpSession getSession(){
           return requestHodler.get().getSession();
    }
   
    public ServletContext getServletContext(){
           return requestHodler.get().getSession().getServletContext();
    }
    
    public HttpServletResponse getResponse(){
        return responseHodler.get();
    }
}

3.五、View

　　一個視圖類，對一些客戶端響應操做進行封裝，其中包括跳轉的路徑 、展示到頁面的數據、跳轉方式

package me.gacl.web.view;

/**
 * 視圖模型
 **/
public class View {

    private String url;//跳轉路徑
    
    private String dispathAction = DispatchActionConstant.FORWARD;//跳轉方式

    public View(String url) {
        this.url = url;
    }
    
    public View(String url,String name,Object value) {
        this.url = url;
        ViewData view = new ViewData();
        view.put(name, value);
    }
    
    
    public View(String url,String name,String dispathAction ,Object value) {
        this.dispathAction = dispathAction;
        this.url = url;
        ViewData view = new ViewData();//請看後面的代碼
        view.put(name, value);
    }
    
    
    public String getUrl() {
        return url;
    }
    
    
    public void setUrl(String url) {
        this.url = url;
    }

    public String getDispathAction() {
        return dispathAction;
    }

    public void setDispathAction(String dispathAction) {
        this.dispathAction = dispathAction;
    }
}

3.六、ViewData

　　request範圍的數據存儲類，當須要發送數據到客戶端顯示時，就能夠將要顯示的數據存儲到ViewData類中。使用ViewData.put(String name,Object value)方法往request對象中存數據。

package me.gacl.web.view;

import javax.servlet.http.HttpServletRequest;

import me.gacl.web.context.WebContext;

/**
 * 須要發送到客戶端顯示的數據模型
 */
public class ViewData {
    
    private HttpServletRequest request;
    
    public ViewData() {
        initRequest();
    }

    private void initRequest(){
        //從requestHodler中獲取request對象
        this.request = WebContext.requestHodler.get();
    }
    
    public void put(String name,Object value){
        this.request.setAttribute(name, value);
    }
}

3.七、DispatchActionConstant

　　一個跳轉方式的常量類

package me.gacl.web.view;

/**
 * 跳轉常量
 */
public class DispatchActionConstant {

    public static String FORWARD = "forward";//服務器跳轉
    
    public static String REDIRECT = "redirect";//客戶端跳轉
}

4、Controller註解和RequestMapping註解測試

4.一、簡單測試

　　編寫一個LoginUI類，用於跳轉到具體的jsp頁面，代碼以下：

package me.gacl.web.UI;

import me.gacl.annotation.Controller;
import me.gacl.annotation.RequestMapping;
import me.gacl.web.view.View;
/**
 * 使用Controller註解標註LoginUI類
 */
@Controller
public class LoginUI {
    
    //使用RequestMapping註解指明forward1方法的訪問路徑  
    @RequestMapping("LoginUI/Login2")
    public View forward1(){
        //執行完forward1方法以後返回的視圖
        return new View("/login2.jsp");  
    }
    
    //使用RequestMapping註解指明forward2方法的訪問路徑  
    @RequestMapping("LoginUI/Login3")
    public View forward2(){
        //執行完forward2方法以後返回的視圖
        return new View("/login3.jsp");  
    } 
}

運行結果以下所示：

4.二、複雜測試

　　編寫用於處理用戶登陸請求的Controller，代碼以下：

package me.gacl.web.controller;

import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import me.gacl.annotation.Controller;
import me.gacl.annotation.RequestMapping;
import me.gacl.web.context.WebContext;
import me.gacl.web.view.View;
import me.gacl.web.view.ViewData;

/**
* 
* @ClassName: LoginServlet2
* @Description:處理用戶登陸的Servlet，
* LoginServlet如今就是一個普通的java類，不是一個真正的Servlet
* @author: 孤傲蒼狼
* @date: 2014-10-8 上午12:07:58
*
*/
@Controller //使用Controller註解標註LoginServlet2
public class LoginServlet2 {

    /**
    * @Method: loginHandle
    * @Description:處理以普通方式提交的請求
    * @Anthor:孤傲蒼狼
    *
    * @return View
    */
    //使用RequestMapping註解標註loginHandle方法，指明loginHandle方法的訪問路徑是login/handle
    @RequestMapping("login/handle")
    public View loginHandle(){
        //建立一個ViewData對象，用於存儲須要發送到客戶端的響應數據
        ViewData viewData = new ViewData();
        //經過WebContext類獲取當前線程中的HttpServletRequest對象
        HttpServletRequest request = WebContext.requestHodler.get();
        //接收提交上來的參數
        String username =request.getParameter("usename");
        String pwd = request.getParameter("pwd");
        if (username.equals("gacl") && pwd.equals("xdp")) {
            request.getSession().setAttribute("usename", username);
            //將響應數據存儲到ViewData對象中
            viewData.put("msg", "歡迎您！"+username);
            //返回一個View對象，指明要跳轉的視圖的路徑
            return new View("/index.jsp");
        }else {
            //將響應數據存儲到ViewData對象中
            viewData.put("msg", "登陸失敗，請檢查用戶名和密碼是否正確！");
            //返回一個View對象，指明要跳轉的視圖的路徑
            return new View("/login2.jsp");
        }
    }
    
    /**
    * @Method: ajaxLoginHandle
    * @Description: 處理以AJAX方式提交的請求
    * @Anthor:孤傲蒼狼
    *
    * @throws IOException
    */ 
    //使用RequestMapping註解標註ajaxLoginHandle方法，指明ajaxLoginHandle方法的訪問路徑是ajaxLogin/handle
    @RequestMapping("ajaxLogin/handle")
    public void ajaxLoginHandle() throws IOException{
        //經過WebContext類獲取當前線程中的HttpServletRequest對象
        HttpServletRequest request = WebContext.requestHodler.get();
        //接收提交上來的參數
        String username =request.getParameter("usename");
        String pwd = request.getParameter("pwd");
        //經過WebContext類獲取當前線程中的HttpServletResponse對象
        HttpServletResponse response = WebContext.responseHodler.get();
        if (username.equals("gacl") && pwd.equals("xdp")) {
            request.getSession().setAttribute("usename", username);
            response.getWriter().write("success");
        }else {
            response.getWriter().write("fail");
        }
    }
}

編寫用於測試的jsp頁面，代碼以下所示：

　　Login2.jsp登陸頁面

<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
  <head>
    <title>login2.jsp登陸頁面</title>
  </head>
  
  <body>
    <fieldset>
        <legend>用戶登陸</legend>
        <form action="${pageContext.request.contextPath}/login/handle.do" method="post">
            用戶名：<input type="text" value="${param.usename}" name="usename">
            <br/>
            密碼：<input type="text" value="${param.pwd}" name="pwd">
            <br/>
            <input type="submit" value="登陸"/>
        </form>
    </fieldset>
    <hr/>
    <label style="color: red;">${msg}</label>
  </body>
</html>

login3.jsp登陸頁面

<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML>
<html>
  <head>
    <title>login3登陸頁面</title>
    <script type="text/javascript" src="${pageContext.request.contextPath}/ajaxUtil.js"></script>
    <script type="text/javascript" src="${pageContext.request.contextPath}/js/Utils.js"></script>
    <script type="text/javascript">
    
        function login(){
             Ajax.request({
                 url : "${pageContext.request.contextPath}/ajaxLogin/handle.do",
                 data : {
                     "usename" : document.getElementById("usename").value,
                     "pwd" : document.getElementById("pwd").value
                 },
                 success : function(xhr) {
                     onData(xhr.responseText);
                 },
                 error : function(xhr) {
                     
                 }
             });
        }
        
        function onData(responseText){
            if(responseText=="success"){
                //window.location.href="index.jsp";//改變url地址
                /*
                window.location.replace("url")：將地址替換成新url，
                該方法經過指定URL替換當前緩存在歷史裏（客戶端）的項目，所以當使用replace方法以後，
                你不能經過「前進」和「後 退」來訪問已經被替換的URL，這個特色對於作一些過渡頁面很是有用！
                */
                location.replace(g_basePath+"/index.jsp");
            }else{
                alert("用戶名和密碼錯誤");
            }
        }
    </script>
  </head>
  
  <body>
    <fieldset>
        <legend>用戶登陸</legend>
        <form>
            用戶名：<input type="text" name="usename" id="usename">
            <br/>
            密碼：<input type="text" name="pwd" id="pwd">
            <br/>
            <input type="button" value="登陸" onclick="login()"/>
        </form>
    </fieldset>
  </body>
</html>

　index.jsp頁面代碼以下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML>
<html>
  <head>
    <title>首頁</title>
  </head>
  
  <body>
        登陸的用戶名：${usename}
    <br/>
    ${msg}
  </body>
</html>

jsp頁面中使用到的Utils.js代碼以下：

//當即執行的js
(function() {
    //獲取contextPath
    var contextPath = getContextPath();
    //獲取basePath
    var basePath = getBasePath();
    //將獲取到contextPath和basePath分別賦值給window對象的g_contextPath屬性和g_basePath屬性
    window.g_contextPath = contextPath;
    window.g_basePath = basePath;
})();

/**
 * @author 孤傲蒼狼
 * 得到項目根路徑，等價於jsp頁面中
 *  <%
        String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
 * 使用方法：getBasePath();
 * @returns 項目的根路徑
 *  
 */
function getBasePath() {
    var curWwwPath = window.document.location.href;
    var pathName = window.document.location.pathname;
    var pos = curWwwPath.indexOf(pathName);
    var localhostPath = curWwwPath.substring(0, pos);
    var projectName = pathName.substring(0, pathName.substr(1).indexOf('/') + 1);
    return (localhostPath + projectName);
}

/**
 * @author 孤傲蒼狼
 * 獲取Web應用的contextPath，等價於jsp頁面中
 *  <%
        String path = request.getContextPath();
    %>
 * 使用方法:getContextPath();
 * @returns /項目名稱(/EasyUIStudy_20141104)
 */
function getContextPath() {
    return window.document.location.pathname.substring(0, window.document.location.pathname.indexOf('\/', 1));
};

測試結果以下：

以上就是對Spring MVC的簡單模擬。

轉自：

http://www.cnblogs.com/xdp-gacl/p/4101727.html

轉載是爲了方便之後查看，請訪問原做者網站。