手写SpringMVC框架（简易版）

最新推荐文章于 2021-07-19 15:48:22 发布
最新推荐文章于 2021-07-19 15:48:22 发布
阅读量236 收藏
点赞数
分类专栏： spring

 版权声明：本文为博主原创文章，未经博主允许不得转载。    https://blog.csdn.net/yaluoshan/article/details/80768258
SpringMVC简介
SpringMVC是当前最优秀的MVC框架，自从Spring 2.5版本发布后，由于支持注解配置，易用性有了大幅度的提高。Spring 3.0更加完善，实现了对Struts 2的超越。现在越来越多的开发团队选择了Spring MVC。 
- Spring为展现层提供的基于MVC设计理念的优秀的Web框架，是目前最主流的MVC框架之一 
- Spring3.0后全面超越Struts2，成为最优秀的MVC框架 
- Spring MVC通过一套MVC注解，让POJO成为处理请求的控制器，而无须实现任何接口。 
- 支持REST风格的URL请求 
- 采用了松散耦合可插拔组件结构，比其他MVC框架更具扩展性和灵活性

SpringMVC运行流程
 
执行过程如图所示： 
⑴用户发送请求至前端控制器DispatcherServlet。 
⑵ DispatcherServlet收到请求调用HandlerMapping处理器映射器。 
⑶ 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 
⑷ DispatcherServlet通过HandlerAdapter处理器适配器调用处理器。 
⑸ 执行处理器(Controller，也叫后端控制器)。 
⑹ Controller执行完成返回ModelAndView。 
⑺ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。 
⑻ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。 
⑼ ViewReslover解析后返回具体View。 
⑽ DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。 
⑾ DispatcherServlet响应用户。 
从上面可以看出，DispatcherServlet有接收请求，响应结果，转发等作用。有了DispatcherServlet之后，可以减少组件之间的耦合度。

SpringMVC九大组件
HandlerMapping
是用来查找Handler的。在SpringMVC中会有很多请求，每个请求都需要一个Handler处理，具体接收到一个请求之后使用哪个Handler进行处理，这就是HandlerMapping需要做的事。

HandlerAdapter
从名字上看，它就是一个适配器。因为SpringMVC中的Handler可以是任意的形式，只要能处理请求就ok，但是Servlet需要的处理方法的结构却是固定的，都是以request和response为参数的方法。如何让固定的Servlet处理方法调用灵活的Handler来进行处理呢？这就是HandlerAdapter要做的事情。 
小结：Handler是用来干活的工具；HandlerMapping用于根据需要干的活找到相应的工具；HandlerAdapter是使用工具干活的人。

HandlerExceptionResolver
其它组件都是用来干活的。在干活的过程中难免会出现问题，出问题后需要有一个专门的角色对异常情况进行处理，在SpringMVC中就是HandlerExceptionResolver。具体来说，此组件的作用是根据异常设置ModelAndView，之后再交给render方法进行渲染。

ViewResolver
ViewResolver用来将String类型的视图名和Locale解析为View类型的视图。View是用来渲染页面的，也就是将程序返回的参数填入模板里，生成html（也可能是其它类型）文件。这里就有两个关键问题：使用哪个模板？用什么技术（规则）填入参数？这其实是ViewResolver主要要做的工作，ViewResolver需要找到渲染所用的模板和所用的技术（也就是视图的类型）进行渲染，具体的渲染过程则交由不同的视图自己完成。

RequestToViewNameTranslator
ViewName是根据ViewName查找View，但有的Handler处理完后并没有设置View也没有设置ViewName，这时就需要从request获取ViewName了，如何从request中获取ViewName就是RequestToViewNameTranslator要做的事情了。RequestToViewNameTranslator在Spring MVC容器里只可以配置一个，所以所有request到ViewName的转换规则都要在一个Translator里面全部实现。

LocaleResolver
解析视图需要两个参数：一是视图名，另一个是Locale。视图名是处理器返回的，Locale是从哪里来的？这就是LocaleResolver要做的事情。LocaleResolver用于从request解析出Locale，Locale就是zh-cn之类，表示一个区域，有了这个就可以对不同区域的用户显示不同的结果。SpringMVC主要有两个地方用到了Locale：一是ViewResolver视图解析的时候；二是用到国际化资源或者主题的时候。

ThemeResolver
用于解析主题。SpringMVC中一个主题对应一个properties文件，里面存放着跟当前主题相关的所有资源、如图片、css样式等。SpringMVC的主题也支持国际化，同一个主题不同区域也可以显示不同的风格。SpringMVC中跟主题相关的类有 ThemeResolver、ThemeSource和Theme。主题是通过一系列资源来具体体现的，要得到一个主题的资源，首先要得到资源的名称，这是ThemeResolver的工作。然后通过主题名称找到对应的主题（可以理解为一个配置）文件，这是ThemeSource的工作。最后从主题中获取资源就可以了。

MultipartResolver
用于处理上传请求。处理方法是将普通的request包装成MultipartHttpServletRequest，后者可以直接调用getFile方法获取File，如果上传多个文件，还可以调用getFileMap得到FileName->File结构的Map。此组件中一共有三个方法，作用分别是判断是不是上传请求，将request包装成MultipartHttpServletRequest、处理完后清理上传过程中产生的临时资源。

FlashMapManager
用来管理FlashMap的，FlashMap主要用在redirect中传递参数。

SpringMVC工程结构与代码
该项目最终的工程文件及目录如下： 
 
1、新建一个Maven项目,可以设置勾选自动生成web.xml，也可以自己手动添加，在pom.xml中导入javax.servlet-api，仅需要导入这一个包就可以啦。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.edu.whu</groupId>
    <artifactId>SpringMVCByHand</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

2、在生成的web.xml中配置一个MyDispatcherServlet,用于拦截符合“/”的请求，配置一个myapplication.properties文件，用于配置需要扫描的包名。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
    <servlet>
        <servlet-name>MyMVC</servlet-name>
        <servlet-class>cn.edu.whu.MVCByHand.servlet.MyDispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>myapplication.properties</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>MyMVC</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

如在myapplication.properties文件中，配置的包名为：

scanPackage=cn.edu.whu.MVCByHand
1
3、创建自己的注解@MyController，@MyService，@MyRequesMapping，@RequestParam,@MyAutowired等。

//@MyAutowired注解代码：  
package cn.edu.whu.MVCByHand.annotation;
import java.lang.annotation.*;

/**
 * Description：自定义注解@MyAutoWired实现自动注入
 * Author：CXJ
 * Date： 2018-06-16 20:33
 * Remark：
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAutowired {
    String value() default "";
}

//@MyController注解代码：
package cn.edu.whu.MVCByHand.annotation;
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyController {
    String value() default "";
}


//@MyRequestMapping注解代码：
package cn.edu.whu.MVCByHand.annotation;
import java.lang.annotation.*;

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyRequestMapping {
    String value();
}


//@MyRequestParam注解代码
package cn.edu.whu.MVCByHand.annotation;
import java.lang.annotation.*;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyRequestParam {
    String value();
}


//@MyService注解代码
package cn.edu.whu.MVCByHand.annotation;
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyService {
    String value() default "";
}

4、创建MyDispatcherServlet这个类，继承HttpServlet，重写init()、doGet()、doPost()，以及实现自动注入、请求匹配等代码：

package cn.edu.whu.MVCByHand.servlet;

import cn.edu.whu.MVCByHand.annotation.MyAutowired;
import cn.edu.whu.MVCByHand.annotation.MyController;
import cn.edu.whu.MVCByHand.annotation.MyRequestMapping;
import cn.edu.whu.MVCByHand.annotation.MyService;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.*;
import java.util.logging.Logger;

/**
 * Description：MVC框架的请求分发中转
 * Author：CXJ
 * Date： 2018-06-16 18:12
 * Remark：继承HttpServlet，重写init方法、doGet、doPost方法
 */
public class MyDispatcherServlet extends HttpServlet {

    private Logger log=Logger.getLogger("init");

    private Properties properties = new Properties();

    private List<String> classNames = new ArrayList<>();

    private Map<String, Object> ioc = new HashMap<>();
//handlerMapping的类型可以自定义为Handler
    private Map<String, Method> handlerMapping = new  HashMap<>();

    private Map<String, Object> controllerMap  =new HashMap<>();

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init();
        log.info("初始化MyDispatcherServlet");
        //1.加载配置文件，填充properties字段；
        doLoadConfig(config.getInitParameter("contextConfigLocation"));

        //2.根据properties，初始化所有相关联的类,扫描用户设定的包下面所有的类
        doScanner(properties.getProperty("scanPackage"));

        //3.拿到扫描到的类,通过反射机制,实例化,并且放到ioc容器中(k-v  beanName-bean) beanName默认是首字母小写
        doInstance();

        // 4.自动化注入依赖
        doAutowired();

        //5.初始化HandlerMapping(将url和method对应上)
        initHandlerMapping();

        doAutowired2();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 注释掉父类实现，不然会报错：405 HTTP method GET is not supported by this URL
        //super.doPost(req, resp);
        log.info("执行MyDispatcherServlet的doPost()");
        try {
            //处理请求
            doDispatch(req,resp);
        } catch (Exception e) {
            resp.getWriter().write("500!! Server Exception");
        }
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 注释掉父类实现，不然会报错：405 HTTP method GET is not supported by this URL
        //super.doGet(req, resp);
        log.info("执行MyDispatcherServlet的doGet()");
        try {
            //处理请求
            doDispatch(req,resp);
        } catch (Exception e) {
            resp.getWriter().write("500!! Server Exception");
        }
    }

    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws Exception {
        if(handlerMapping.isEmpty()){
            return;
        }
        String url =req.getRequestURI();
        String contextPath = req.getContextPath();
        url=url.replace(contextPath, "").replaceAll("/+", "/");
        // 去掉url前面的斜杠"/"，所有的@MyRequestMapping可以不用写斜杠"/"
        if(url.lastIndexOf('/')!=0){
            url=url.substring(1);
        }
        if(!this.handlerMapping.containsKey(url)){
            resp.getWriter().write("404 NOT FOUND!");
            log.info("404 NOT FOUND!");
            return;
        }
        Method method =this.handlerMapping.get(url);
        //获取方法的参数列表
        Class<?>[] parameterTypes = method.getParameterTypes();

        //获取请求的参数
        Map<String, String[]> parameterMap = req.getParameterMap();
        //保存参数值
        Object [] paramValues= new Object[parameterTypes.length];
        //方法的参数列表
        for (int i = 0; i<parameterTypes.length; i++){
            //根据参数名称，做某些处理
            String requestParam = parameterTypes[i].getSimpleName();
            if (requestParam.equals("HttpServletRequest")){
                //参数类型已明确，这边强转类型
                paramValues[i]=req;
                continue;
            }
            if (requestParam.equals("HttpServletResponse")){
                paramValues[i]=resp;
                continue;
            }
            if(requestParam.equals("String")){
                for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
                    String value =Arrays.toString(param.getValue()).replaceAll("\\[|\\]", "").replaceAll(",\\s", ",");
                    paramValues[i]=value;
                }
            }
        }
        //利用反射机制来调用
        try {
            //第一个参数是method所对应的实例 在ioc容器中
            //method.invoke(this.controllerMap.get(url), paramValues);
            method.invoke(this.controllerMap.get(url), paramValues);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Description:  根据配置文件位置，读取配置文件中的配置信息，将其填充到properties字段
     * Params:
      * @param location: 配置文件的位置
     * return: void
     * Author: CXJ
     * Date: 2018/6/16 19:07
     */
    private void  doLoadConfig(String location){

        //把web.xml中的contextConfigLocation对应value值的文件加载到流里面
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(location);
        try {
            //用Properties文件加载文件里的内容
            log.info("读取"+location+"里面的文件");
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关流
            if(null!=resourceAsStream){
                try {
                    resourceAsStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * Description:  将指定包下扫描得到的类，添加到classNames字段中；
     * Params:
      * @param packageName: 需要扫描的包名
     * return: void
     * Author: CXJ
     * Date: 2018/6/16 19:05
     */
    private void doScanner(String packageName) {

        URL url  =this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/"));
        File dir = new File(url.getFile());
        for (File file : dir.listFiles()) {
            if(file.isDirectory()){
                //递归读取包
                doScanner(packageName+"."+file.getName());
            }else{
                String className =packageName +"." +file.getName().replace(".class", "");
                classNames.add(className);
            }
        }
    }

    /**
     * Description:  将classNames中的类实例化，经key-value：类名（小写）-类对象放入ioc字段中
     * Params:
      * @param :
     * return: void
     * Author: CXJ
     * Date: 2018/6/16 19:09
     */
    private void doInstance() {

        if (classNames.isEmpty()) {
            return;
        }
        for (String className : classNames) {
            try {
                //把类搞出来,反射来实例化(只有加@MyController需要实例化)
                Class<?> clazz =Class.forName(className);
                if(clazz.isAnnotationPresent(MyController.class)){
                    ioc.put(toLowerFirstWord(clazz.getSimpleName()),clazz.newInstance());
                }else if(clazz.isAnnotationPresent(MyService.class)){
                    MyService myService=clazz.getAnnotation(MyService.class);
                    String beanName=myService.value();
                    if ("".equals(beanName.trim())){
                        beanName=toLowerFirstWord(clazz.getSimpleName());
                    }

                    Object instance= clazz.newInstance();
                    ioc.put(beanName,instance);
                    Class[] interfaces=clazz.getInterfaces();
                    for (Class<?> i:interfaces){
                        ioc.put(i.getName(),instance);
                    }
                }
                else{
                    continue;
                }
            } catch (Exception e) {
                e.printStackTrace();
                continue;
            }
        }
    }

    /**
     * Description:自动化的依赖注入
     * Params:
      * @param :
     * return: void
     * Author: CXJ
     * Date: 2018/6/16 20:40
     */
    private void doAutowired(){

        if (ioc.isEmpty()){
            return;
        }
        for (Map.Entry<String,Object> entry:ioc.entrySet()){
            //包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
            Field[] fields=entry.getValue().getClass().getDeclaredFields();
            for (Field field:fields){
                if (!field.isAnnotationPresent(MyAutowired.class)){
                    continue;
                }
                MyAutowired autowired= field.getAnnotation(MyAutowired.class);
                String beanName=autowired.value().trim();
                if ("".equals(beanName)){
                    beanName=field.getType().getName();
                }
                field.setAccessible(true);
                try {
                    field.set(entry.getValue(),ioc.get(beanName));
                }catch (Exception e){
                    e.printStackTrace();
                    continue;
                }

            }
        }
    }

    private void doAutowired2(){

        if (controllerMap.isEmpty()){
            return;
        }
        for (Map.Entry<String,Object> entry:controllerMap.entrySet()){
            //包括私有的方法，在spring中没有隐私，@MyAutowired可以注入public、private字段
            Field[] fields=entry.getValue().getClass().getDeclaredFields();
            for (Field field:fields){
                if (!field.isAnnotationPresent(MyAutowired.class)){
                    continue;
                }
                MyAutowired autowired= field.getAnnotation(MyAutowired.class);
                String beanName=autowired.value().trim();
                if ("".equals(beanName)){
                    beanName=field.getType().getName();
                }
                field.setAccessible(true);
                try {
                    field.set(entry.getValue(),ioc.get(beanName));
                }catch (Exception e){
                    e.printStackTrace();
                    continue;
                }

            }
        }
    }

    /**
     * Description:  初始化HandlerMapping(将url和method对应上)
     * Params:
      * @param :
     * return: void
     * Author: CXJ
     * Date: 2018/6/16 19:12
     */
    private void initHandlerMapping(){

        if(ioc.isEmpty()){
            return;
        }
        try {
            for (Map.Entry<String, Object> entry: ioc.entrySet()) {
                Class<? extends Object> clazz = entry.getValue().getClass();
                if(!clazz.isAnnotationPresent(MyController.class)){
                    continue;
                }

                //拼url时,是controller头的url拼上方法上的url
                String baseUrl ="";
                if(clazz.isAnnotationPresent(MyRequestMapping.class)){
                    MyRequestMapping annotation = clazz.getAnnotation(MyRequestMapping.class);
                    baseUrl=annotation.value();
                }
                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if(!method.isAnnotationPresent(MyRequestMapping.class)){
                        continue;
                    }
                    MyRequestMapping annotation = method.getAnnotation(MyRequestMapping.class);
                    String url = annotation.value();

                    url =(baseUrl+"/"+url).replaceAll("/+", "/");
                    handlerMapping.put(url,method);
                    controllerMap.put(url,clazz.newInstance());
                    System.out.println(url+","+method);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * Description:  将字符串中的首字母小写
     * Params:
      * @param name:
     * return: java.lang.String
     * Author: CXJ
     * Date: 2018/6/16 19:13
     */
    private String toLowerFirstWord(String name){

        char[] charArray = name.toCharArray();
        charArray[0] += 32;
        return String.valueOf(charArray);
    }

}

5、新建TestService接口及其实现类TestServiceImpl,可以将TestService注入到后面的Controller中使用。

package cn.edu.whu.MVCByHand.service;

import cn.edu.whu.MVCByHand.annotation.MyService;

/**
 * Description：
 * Author：CXJ
 * Date： 2018-06-16 20:44
 * Remark：
 */

public interface TestService {
    void printParam(String param);
}

package cn.edu.whu.MVCByHand.service;

import cn.edu.whu.MVCByHand.annotation.MyService;


/**
 * Description：
 * Author：CXJ
 * Date： 2018-06-16 20:45
 * Remark：
 */

@MyService
public class TestServiceImpl implements TestService {

    @Override
    public void printParam(String param) {
        System.out.println("接收到的参数为： "+param);
    }
}

6、然后使用自己的@MyController等注解实现一个Controller类

import cn.edu.whu.MVCByHand.service.TestService;
import cn.edu.whu.MVCByHand.service.TestServiceImpl;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * Description：
 * Author：CXJ
 * Date： 2018-06-16 18:39
 * Remark：
 */

@MyController()
@MyRequestMapping("test1")
public class Test1Controller {

    @MyAutowired
    private TestService testService;

    @MyRequestMapping("test")
    public void myTest(HttpServletRequest request, HttpServletResponse response,
                      @MyRequestParam("param") String param){
        try {
            response.getWriter().write( "Test1Controller:the param you send is :"+param);
            testService.printParam(param);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package cn.edu.whu.MVCByHand.controller;

import cn.edu.whu.MVCByHand.annotation.MyController;
import cn.edu.whu.MVCByHand.annotation.MyRequestMapping;
import cn.edu.whu.MVCByHand.annotation.MyRequestParam;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * Description：
 * Author：CXJ
 * Date： 2018-06-16 18:39
 * Remark：
 */
@MyController
@MyRequestMapping("test2")
public class Test2Controller {

    @MyRequestMapping("test")
    public void myTest(HttpServletRequest request, HttpServletResponse response,
                      @MyRequestParam("param") String param){
        try {
            response.getWriter().write( "Test2Controller:the param you send is :"+param);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7、至此，一个简单的MVC框架就实现了，调试一下，发现已经成功注入了TestService。输入路径与参数，测试一下是否能正常响应，结果显示，完全没问题啊。 

SpringMVC实现过程
1、新建一个Maven工程,工程结构如图，新建MyDispatcherServlet类，在web.xml中配置DispatcherServlet，作为整个应用的入口。 

2、MyDispatcherServlet类继承自HttpServlet，重写init(),doGet(),doPost()方法，如图： 

3、实现@MyController，@MyService，@MyRequesMapping，@RequestParam等注解,实现注解后，可即时使用注解，如图： 
 
4、在DispatcherServlet的init()中，加载配置文件，获取扫描包的路径，如图，本例扫描到配置文件中的包名为cn.edu.whu.MVCByHand.controller。 
 
5、根据包名，扫描所有的类名，拿到扫描到的类,通过反射机制,实例化,并且放到ioc容器中（采用key-value数据结构），如图，本例中扫描到controller包中的Test1Controller与Test2Controller类，并将其实例化后，填入到ioc容器中。 
 
 
6、初始化HandlerMapping（采用key-value数据结构），结合@MyController、@MyRequesMapping，将url和method对应上，如图，本例中，绑定路径’test1/test’与Test1Controller中的myTest()。 

7、实现doDispatcher()方法，根据请求的url与参数，找到对应的方法（如路径不存在，请求到错误页面），利用反射机制调用该方法,重写DispatcharServlet的doGet()，doPost(),根据请求类型，调用doDispatcher()方法。 
8、至此，简单的SpringMVC就实现了，做一个测试，如图： 
 
 
9、 重新调试一下，发现已经成功注入了TestService。输入路径与参数，测试一下是否能正常响应，结果显示，完全没问题啊。 

曹洪双
关注
专栏目录
我的架构梦：（八）手写SpringMVC框架
riemann_的博客
06-11 675
手写SpringMVC框架一、SpringMVC的请求处理流程二、Spring MVC 高级技术三、手写 SpringMVC 框架 手写SpringMVC框架之前呢，我觉得有必要先了解SpringMVC的请求处理流程以及高级特性。 一、SpringMVC的请求处理流程 1、请求处理流程 流程说明： 第一步：用户发送请求至前端控制器DispatcherServlet。 第二步：DispatcherServlet收到请求调用HandlerMapping处理器映射器。 第三步：处理器映射器根据请求Url找到具体
手写实现SpringMVC
qq_43843037的博客
12-01 581
SpringMVC流程图 用户发送请求至前端控制器DispatcherServlet。 DispatcherServlet收到请求调用HandlerMapping处理器映射器。 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 DispatcherServlet调用HandlerAdapter处理器适配器。 HandlerAdapter经过适配调用具体的处理器(Controlle
Spring MVC框架一个实例的手动实现
aoningxun2220的博客
08-10 201
文件结构： SpringMVC05 // 应用程序名 ----index.html // 欢迎文件，主目录下的文件可以被URL直接访问到 ----WEB-INF // 这个目录下的文件将被保护起来不能直接被URL访问 --------web.xml // 应用的配置文件 --------classes // 放置Java类文件 --------conf...
手写 springmvc
01-16
java spring springmvc 手写 博客位置： http://knight-black-bob.iteye.com/blog/2407872
手写springmvc
weixin_42304484的博客
01-01 301
手写springmvc的思路 springmvc的核心也是一个servlet即DispatcherServlet，这个servlet会配在web.xml里面，注意它的url-pattern配置的是/*，即拦截了所有请求。 其原理就是当浏览器发送请求的时候，都会被springmvc的这个servlet拦截到，然后springmvc会将这个请求的url进行一些处理，处理后去匹配对应的controller中对应的method（requestMaping中填写的请求路径）。匹配之后就通过反射调用方法，完成业务逻辑。
手写springmvc 简易版
10-28
在这个“手写springmvc简易版”项目中，我们有机会深入理解Spring MVC的核心概念和工作原理。下面将详细介绍这个简易版Spring MVC实现中的关键知识点。 1. **DispatcherServlet**：作为Spring MVC的前端控制器，...
阿里P7大牛一对一教你如何手写SpringMVC框架
10-10
本文将从SpringMVC框架的基本概念出发，深入解析其工作原理，并逐步指导如何实现一个简易版本的手写SpringMVC框架。 ### 一、SpringMVC框架概述 #### 1.1 SpringMVC简介 SpringMVC是Spring框架的一部分，主要用于...
SmartMvc:深入解析SpringMVC核心原理：从手写简易版MVC框架开始(SmartMvc)
05-29
所以自己想和小伙伴一起从手写简易版的SpringMVC框架出发， 理出SpringMVC的主线并深入理解SpringMVC的原理 别忘记Star哟 项目结构 SmartMvc ├── docs -- 开发文档 ├── smart-mvc -- 实现mvc功能的核心代码 ├...
手写springMVC
nelson的博客
08-22 420
先让大家看一下我的目录结构 第一步： 先创建一个Maven项目，引入servlet-api依赖,因为springMVC底层就是用到servlet的 &lt;dependency&gt; &lt;groupId&gt;javax.servlet&lt;/groupId&gt; &lt;artifactId&gt;servlet-api&lt;/artifactId&g...
手写简单Spring MVC
11-02
手写简易SpringMVC 附测试demo
简易的手写springmvc
08-04
本工程模仿了简易的springMVC的实现， 包含了controller、service、requestParam、autowired、requestMapping注解类的创建 IOC容器的创建及组装原理实现 简易的request请求
手写 Spring MVC篇
@Bean
07-19 251
上面的四篇文章介绍并写完了SpringBean的生命周期，现在开始来写Spring MVC Spring MVC我们只写一层 C层 即 Controller 控制层（没有父子容器） 众所周知 Spring MVC有一个中央处理器 叫 DispatcherServlet，实现了HttpServlet 是一个Servlet 既然是一个Servlet 肯定是要遵循Servlet的规范。 我们通常知道的服务器一般有tomcat 和 jetty等等 ，这两个容器也实现了Servlet的规范。 在容器运行完.
手写SpringMVC
鸟哥哥的专栏
05-27 1092
Spring Web MVC 是一个一开始就包含在Spring家族里的原生的基于Servlet API的web框架。其正式名称“Spring Web MVC”来自其源模块Spring-webmvc的名称，但它更广为人知的名称是“Spring MVC”。 Spring MVC 是一个模型 - 视图 - 控制器（MVC）的Web框架，核心是前端控制器DispatcherServlet，它负责发送每个...
手写一个简单的SpringMVC框架
qq_37113604的博客
08-25 1010
可能大家经常使用Spring系列框架，使用Spring的注解进行开发，但是仅限于使用，对框架底层的原理并不是很清晰，今天就来实现一个简单的SpringMVC框架，在此之前需要先了解下java的几个元注解，Spring中的注解基本上都是基于这些元注解进行开发的，大家可以看下我的这篇博客，里面详细介绍了java的几种元注解，以及各自的含义。https://blog.csdn.net/qq_371136...
自己手写一个Spring MVC框架
DONGYUXIA15810857916的博客
08-02 594
想要了解Spring MVC框架的原理，探究框架是如何设计的，不错的学习方式是阅读源码，然后自己手写一个框架。本文带领大家简化的手写一个Spring MVC框架。 Spring框架对于Java后端程序员来说再熟悉不过了，以前只知道它用的反射实现的，但了解之后才知道有很多巧妙的设计在里面。 如果不看Spring的源码，你将会失去一次和大师学习的机会：它的代码规范，设计思想很值得学习。我们程序员大...
简化版的SpringMVC框架的实现思路
weixin_34275734的博客
08-06 164
在SpringMVC基本统一Java web开发技术栈的环境下, 这是一个有点过时的话题了. SpringMVC的特点主要在于注解型的RequestMapping和参数机制非常灵活, 另外得益于Spring本身的bean控制, 可以很方便的在各个环境引入其他对象. 最近整理了一下几年前的工作, 把项目的底层代码剥出来. 这是一个类似于SpringMVC的底层框架, 数据端使用的是DBUtils, ...
SpringMVC框架理解与测试
"SSM框架测试题包含了SpringMVC、Spring和MyBatis相关的测试题目，主要考察对SSM框架的理解和应用。" 在SpringMVC框架中，我们需要理解几个核心概念和工作流程： 1. **DispatcherServlet**：它是SpringMVC的前端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值