单体架构SSM之深入理解SpringMVC工作原理，像大牛一样手写SpringMVC

最新推荐文章于 2024-07-28 16:12:57 发布
最新推荐文章于 2024-07-28 16:12:57 发布
阅读量710 收藏 3
点赞数
文章标签： java spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45101064/article/details/104419003
版权

一、什么是SpringMVC？

SpringMVC是Spring的一个基于MVC三层架构模式的Web应用框架，通过把Model，View，Controller分离，把较为复杂的web应用分成逻辑清晰的几部分，是为了简化开发，减少出错。还是为了组内开发人员之间的配合。总之就是一种分层工作的办法。拥有spring的特性，例如依赖注入。其实简单的来说就是为Java程序提供一个“五星级酒店”，把请求看做是“出入人员”，进出都由最前面的“酒店前台”来控制（具体细节在下面介绍）。SpringMVC框架是以请求为驱动，围绕Servlet设计，将请求发给控制器，然后通过模型对象，分派器来展示请求结果视图。其中核心类是DispatcherServlet，它是一个Servlet，顶层是实现的Servlet接口。

二、SpringMVC工作原理详解

2.1、SpringMVC工作原理详解（图解）

image.png

2.2、SpringMVC工作原理详解（文解）

  1. 用户发送请求至前端控制器DispatcherServlet(也叫中央处理器）【酒店前台：用户来到酒店入住】
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器 【酒店前台等到用户选好房间由工作人员（HandlerMapping）带用户去看具体的房间（Handler）】
  3. 处理器映射器找到具体的处理器（可以根据xml配置、注解进行查找），生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet 【工作人员带用户找到具体房间看完之后，将用户信息及需求返回给前台】
  4. DispatcherServlet调用HandlerAdapter处理器适配器 【前台通知酒店服务人员】
  5. HandlerAdapter经过适配调用具体的处理器（Controller,也叫后端控制器）【服务人员根据前台给的信息找到具体房间，根据用户需求进行服务（烧好热水、打扫等）】
  6. Controller执行完成返回ModelAndView 【服务人员服务完房间之后把效果（ModelAndView）拍照】
  7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet【酒店工作人员把服务人员拍的照片带给前台】
  8. DisPatcherServlet将ModelAndView传给ViewReslover视图解析器 【前台把照片发给审核人员】
  9. ViewReslover解析后返回具体View 【审核人员按照用户需求筛选具体的照片并将审核过的照片发送给前台】
  10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）【前台根据审核人员返回的照片对用户进行介绍并安排用户入住】
  11. DispatcherServlet响应用户 【用户住完，找到前台退房，前台送走用户】

2.3、SpringMVC工作组件介绍

  1. 前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
    作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。
    用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。
  2. 处理器映射器HandlerMapping(不需要工程师开发),由框架提供
    作用：根据请求的url查找Handler
    HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
  3. 处理器适配器HandlerAdapter
    作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
    通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
  4. 处理器Handler(需要工程师开发)
    注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
    Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
    由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。
  5. 视图解析器View resolver(不需要工程师开发),由框架提供
    作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
    View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。
    一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。
  6. 视图View(需要工程师开发jsp…)
    View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）

2.4、核心架构的具体流程步骤如下:

1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
2、DispatcherServlet——>HandlerMapping， HandlerMapping 将会把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；
5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

下边两个组件通常情况下需要开发：
Handler：处理器，即后端控制器用controller表示。
View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。
MVC原理图
image.png

分析：
M-Model 模型（完成业务逻辑：有javaBean构成，service+dao+entity）
V-View 视图（做界面的展示 jsp，html……）
C-Controller 控制器（接收请求—>调用模型—>根据结果派发页面）

三、分析SpringMVC源码

在上面我们了解了，接下来我们分析咱们的springmvc框架，首先看下DispatcherServlet源码

package org.springframework.web.servlet;
 
@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {
 
	public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
	public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
	public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";
	public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
	public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
	public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
	public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";
	public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
	public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";
	public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";
	public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";
	public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";
	public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";
	public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";
	public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";
	public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";
	public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";
	public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";
	private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
	protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);
	private static final Properties defaultStrategies;
	static {
		try {
			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		}
		catch (IOException ex) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
		}
	}
 
	/** Detect all HandlerMappings or just expect "handlerMapping" bean? */
	private boolean detectAllHandlerMappings = true;
 
	/** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
	private boolean detectAllHandlerAdapters = true;
 
	/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
	private boolean detectAllHandlerExceptionResolvers = true;
 
	/** Detect all ViewResolvers or just expect "viewResolver" bean? */
	private boolean detectAllViewResolvers = true;
 
	/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
	private boolean throwExceptionIfNoHandlerFound = false;
 
	/** Perform cleanup of request attributes after include request? */
	private boolean cleanupAfterInclude = true;
 
	/** MultipartResolver used by this servlet */
	private MultipartResolver multipartResolver;
 
	/** LocaleResolver used by this servlet */
	private LocaleResolver localeResolver;
 
	/** ThemeResolver used by this servlet */
	private ThemeResolver themeResolver;
 
	/** List of HandlerMappings used by this servlet */
	private List<HandlerMapping> handlerMappings;
 
	/** List of HandlerAdapters used by this servlet */
	private List<HandlerAdapter> handlerAdapters;
 
	/** List of HandlerExceptionResolvers used by this servlet */
	private List<HandlerExceptionResolver> handlerExceptionResolvers;
 
	/** RequestToViewNameTranslator used by this servlet */
	private RequestToViewNameTranslator viewNameTranslator;
 
	private FlashMapManager flashMapManager;
 
	/** List of ViewResolvers used by this servlet */
	private List<ViewResolver> viewResolvers;
 
	public DispatcherServlet() {
		super();
	}
 
	public DispatcherServlet(WebApplicationContext webApplicationContext) {
		super(webApplicationContext);
	}
	@Override
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}
 
	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
	}
}

DispatcherServlet类中的属性beans：
HandlerMapping： 用于handlers映射请求和一系列的对于拦截器的前处理和后处理，大部分用@Controller注解。
HandlerAdapter： 帮助DispatcherServlet处理映射请求处理程序的适配器，而不用考虑实际调用的是 哪个处理程序。
HandlerExceptionResolver： 处理映射异常。
ViewResolver： 根据实际配置解析实际的View类型。
LocaleResolver： 解决客户正在使用的区域设置以及可能的时区，以便能够提供国际化视野。
ThemeResolver： 解决Web应用程序可以使用的主题，例如提供个性化布局。
MultipartResolver： 解析多部分请求，以支持从HTML表单上传文件。
FlashMapManager： 存储并检索可用于将一个请求属性传递到另一个请求的input和output的FlashMap，通常用于重定向。
在Web MVC框架中，每个DispatcherServlet都拥自己的WebApplicationContext，它继承了ApplicationContext。WebApplicationContext包含了其上下文和Servlet实例之间共享的所有的基础框架beans。

HandlerMapping：
image.png

HandlerMapping接口处理请求的映射
HandlerMapping接口的实现类：
SimpleUrlHandlerMapping类通过配置文件把URL映射到Controller类。
DefaultAnnotationHandlerMapping类通过注解把URL映射到Controller类。

HandlerAdapter：
image.png
HandlerAdapter接口-处理请求映射：
**AnnotationMethodHandlerAdapter：**通过注解，把请求URL映射到Controller类的方法上。

HandlerExceptionResolver：
image.png
HandlerExceptionResolver：
HandlerExceptionResolver接口-异常处理接口
SimpleMappingExceptionResolver通过配置文件进行异常处理。
AnnotationMethodHandlerExceptionResolver：通过注解进行异常处理。

ViewResolver：
image.png
ViewResolver接口解析View视图。
UrlBasedViewResolver： 通过配置文件，把一个视图名交给到一个View来处理。

其实通过上面的分析我们可以发现，springMVC的核心就是DispatcherServlet，由DispatcherServlet去调用各类组件，而DispatcherServlet其实本质上就是一个Servlet（所有WEB层框架本质上都离不开Servlet，就好比ORM框架离不开JDBC），所以说我下面写一个迷你版的来加深大家对SpringMVC的理解。

四、像大佬一样手写一个迷你版

4.1、分析SpringMVC在日常中的使用

配置springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 通过context:component-scan元素扫描指定包下的控制器-->
    <!-- 扫描com.xxx.xxx及子子孙孙包下的控制器(扫描范围过大，耗时)-->
    <context:component-scan base-package="com.xxx.xxx"/>
    
    <!-- ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- viewClass需要在pom中引入两个包：standard.jar and jstl.jar -->
        <property name="viewClass"
                  value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

分析：在这个文件中最重要的其实是配置扫包和视图解析器，而这俩个操作都是在程序启动时配置的。

配置web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!-- Spring MVC servlet -->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--此参数可以不配置，默认值为：/WEB-INF/springmvc-servlet.xml-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/springmvc-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <!--web.xml 3.0的新特性，是否支持异步-->
    <!--<async-supported>true</async-supported>-->
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

分析：在web.xml中配置DispatcherServlet，而tomcat启动时会先去加载web.xml，加载到web.xml时因为当中配置了DispatcherServlet，所以此时回去加载DispatcherServlet，而DispatcherServlet在上面的讲解中会发现它除了是组件调用器时，还是springmvc的初始化构建器。

protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

4.2、手写实操

定义DispatcherServlet继承HttpServlet：

public class DispacherServlet extends HttpServlet {

    /***
     * 1. 定义一个处理器来接收用户的请求
     * 2. 配置扫描包路径
     * 3. 定义注解
     * 4. 处理用户请求
     *         遍历Controller类，找到所有RequestMapper注解的类或者方法保存起来，下次用户访问时直接去容器中找
     */

    Map<String, InvocationHandler> HandlerMap;

    @Override
    public void init() throws ServletException {
        System.out.println("项目启动了.....");
        //扫描包路径  原本是xml配置中读取的
        String packagePath = "com.sixstar.mvc.controller";
        //根据注解扫描包
        Set<Class<?>> ControllerClassSet = ClassUtil.scanPackageByAnnotation(packagePath, Controller.class);
        System.out.println("ControllerClassSet:" + ControllerClassSet.size());
        HandlerMapping handlerMapping = new HandlerMapping();
        HandlerMap = handlerMapping.urlMapping(ControllerClassSet);
        System.out.println("HandlerMap的长度：" + HandlerMap.size());
    }

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

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //得到客户端请求路径
        StringBuffer requestURL = req.getRequestURL();
        System.out.println("客户端请求路径：" + requestURL);
        //判断客户端请求路径中是否包含项目名称，包含的话使用空字符替换掉
        String path = new String(requestURL).replace("http://" + req.getServerName() + ":" + req.getServerPort(), "");
        System.out.println("客户端请求RequestMapping映射路径：" + path);
        //去容器中使用path查找对应的InvocationHandler，得到对应的Class和Method
        InvocationHandler handler = HandlerMap.get(path);
        Object object = handler.getObject();
        Method method = handler.getMethod();
        //判断该方法上是否添加了ResponseBody注解  true:返回json格式  false：跳转页面
        boolean f = method.isAnnotationPresent(ResponseBody.class);
        System.out.println("方法上是否添加了ResponseBody注解：" + f);
        if (f){
            try {
                //通过反射的方式调用方法
                Object invoke = method.invoke(object);
                //将执行后返回的结果通过Response以json的格式写给客户端
                resp.getWriter().print(invoke.toString()); //使用阿里巴巴的json转换包转换成json返回，此处使用toString代替
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } else{
            String URL = "http://" + req.getServerName() + ":" + req.getServerPort() + "/" + req.getContextPath();
            System.out.println("URL:" + URL);
            //使用自定义的前后缀拼接，然后使用response或者request跳转
            String prefix = "";
            String suffix = ".jsp";
            try {
                Object invoke = method.invoke(object);
                if(invoke instanceof ModelAndView){

                } else{
                    String str = (String)invoke;
                    if(str.indexOf("forward:") != -1){
                        System.out.println("转发");
                        req.getRequestDispatcher("index.jsp").forward(req,resp);
                    }
                    if(str.indexOf("redirect:") != -1){
                        resp.sendRedirect(URL + prefix + str.replace("redirect:","") + suffix);
                    }
                    if(str.indexOf("forward:") == -1 && str.indexOf("redirect:") == -1){
                        resp.sendRedirect(URL + prefix + str + suffix);
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        }
    }
}

在web.xml加载DispacherServlet

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <servlet>
    <servlet-name>dispacherServlet</servlet-name>
    <servlet-class>com.mvc.DispacherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispacherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

自定义注解
Controller：

@Retention(RetentionPolicy.RUNTIME) //注解的生命周期：运行时期有效
@Target(ElementType.TYPE) //注解的生效范围：生效于类上面
public @interface Controller {
    //@interface 元注解：JDK封装的专门用来实现自定义注解的注解
}

RequestMapping：

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期：运行时期有效
public @interface RequestMapping {
    String value() default ""; //允许该注解可以填String类型的参数，默认为空
}

ResponseBody：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期：运行时期有效
public @interface ResponseBody {
}

HandlerMapping：

public class HandlerMapping {
    public Map<String,InvocationHandler> urlMapping(Set<Class<?>> ControllerClassSet){
        //初始化MAP集合
        HashMap<String, InvocationHandler> HandlerHashMap = new HashMap<>();
        //遍历Controller集合
        for (Class<?> aClass : ControllerClassSet) {
            //获取aClass类上的RequestMapping注解的值
            String requestMappingClassValue = AnnotationUtil.getAnnotationValue(aClass, RequestMapping.class);
            System.out.println("requestMappingClassValue:" + requestMappingClassValue);
            Method[] declaredMethods = aClass.getDeclaredMethods();
            System.out.println("该controller类中方法数量为：" + declaredMethods.length);
            if (declaredMethods != null && declaredMethods.length != 0) {
                for (Method declaredMethod : declaredMethods) {
                    boolean flag = declaredMethod.isAnnotationPresent(RequestMapping.class);
                    if (flag){
                        //获取方法上RequestMapping注解的值
                        String requestMappingMethodAnnotationValue = AnnotationUtil.getAnnotationValue(declaredMethod, RequestMapping.class);
                        //判断得到的值是否为空
                        String requestMappingMethodValue = requestMappingMethodAnnotationValue == null || requestMappingMethodAnnotationValue.equals("") || requestMappingMethodAnnotationValue.equals("null") ? "" : requestMappingMethodAnnotationValue;
                        System.out.println("requestMappingMethodValue:" + requestMappingMethodValue);
                        //将得到的值封装成InvocationHandler对象
                        try {
                            InvocationHandler invocationHandler = new InvocationHandler(aClass.newInstance(), declaredMethod);
                            HandlerHashMap.put(requestMappingClassValue + requestMappingMethodValue, invocationHandler);
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        
        return HandlerHashMap;
    }
}

InvocationHandler：

public class InvocationHandler {

    private Object object;
    private Method method;

    public InvocationHandler(){}

    public InvocationHandler(Object object, Method method) {
        this.object = object;
        this.method = method;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    @Override
    public String toString() {
        return "InvocationHandler{" +
                "object=" + object +
                ", method=" + method +
                '}';
    }
}

测试：

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/get")
    @ResponseBody
    public User get(){
        return new User(1,"竹子爱熊猫","男",18);
    }

    @RequestMapping("/test")
    @ResponseBody
    public String test(){
        return "test";
    }

    @RequestMapping("/edit")
    public String toEdit(){
        return "redirect:edit";
    }

    public String TEST(){
        return null;
    }

}

五、总结

最后谈谈我自己对于springMVC工作流程的理解，其实在咱们把一个JavaWeb程序打成war包丢入Tomcat后，当我们启动Tomcat，它就会先去加载web.xml文件，而加载web.xml配置文件时会碰到DispacherServlet需要被加载，当加载DispacherServlet时其实就是把SpringMVC的组件初始化和所有Controller的URL资源全部映射到一个容器中存储，然后当请求经过DispacherServlet时，DispacherServlet就去装URL的容器里面找到这个请求的URL资源，找到之后再调用组件去执行具体的Controller，当执行完毕之后结果又会回到DispacherServlet，此时DispacherServlet又会去调用相关组件处理执行后的结果，最后才将渲染后的结果响应。

六、面试中注意的点

如果在面试中遇到了面试官问你SpringMVC的工作原理（流程），如果按照最开始我们分析的那一套走下来其实面试官也清楚，你可以对于这个框架的理解程度不够，可能是在面试前刷了一下面试题靠临时记忆来面试的，这在面试中其实没有给你带来任何加分点和给面试官看到亮点，因为对于他来说，每天都有人来面试，同一个这样的问题他可能问过很多人，而你们的答案都是相同的，面试官也不是傻子。所以如果要想去真正的应对面试靠刷面试题还是不够，更多的还是要看自己对于技术的理解程度，还有你的思维逻辑，对于WEB框架其实本质是Servlet，而一般的流程就是“发送请求 – 相关处理 – 响应数据”。

竹子爱熊猫
关注
阿里P8大牛手写： Linux+网络编程 手册，搞到手之后面试简直如虎添翼(1)
2401_84002730的博客
05-04 958
为了让 代码运行得更快，单纯地依赖更快的硬件已经无法满足要求。程序员需要编写并发代码，以便充分发 挥多核处理器的强大功能，并且使程序的性能得到提升。进程间通信：管道在Linux系统中，有时候需要多个进程相互协作，共同完成某项任务。进程之间或线程之间有时候需要传递消息，有时候需要同步来协调彼此的工作。进程间通信：System V IPC这三种IPC机制的差别很大，之所以将它们放在一起讨论，一个重要的原因是这三种机制是一同被 开发出来的进程间通信：POSIX IPC。
java架构师进阶之路
henhenha的博客
03-30 3836
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
基于JAVA EE技术，采用MVC模式SSM框架开发一个销售管理系统。
03-18
综合运用前面章节相关概念与原理，设计和开发一个企业信息管理系统，通过本实验项目的练习，有助于学生对Spring、MyBatis、Spring MVC技术的了解和认识，提高项目开发实践能力。主要内容为对项目进行需求分析，规划，框架设计，编码，布署，发布等。 基于JAVA EE技术，采用MVC模式开发一个销售管理系统。 某公司销售管理系统 公司销售管理系统主要实现管理与客户之间销售合同的签订、履行、及相关销售数据的统计。 公司与客户之间签订销售合同后，销售管理员会根据客户每次已付款的采购清单以及商品的库存情况生成发货单（为简单起见一张发货单对应一种商品的发货），用于仓库管理员给客户发货。仓库管理员发货后需要对发货单进行确认，并记录相关物流信息。如果一个合同所涉及的所有商品均已发货完毕，则该合同履行完毕。如果商品的库存量不够或发货后库存为0，则生成进货单，用于仓库管理员进货。仓库管理员进货后需要记录进货信息，并修改对应商品的库存。 除了上述功能以外，销售管理员可以对合同基本信息进行管理，包括合同的录入、修改及查询，一个合同在履行前可以修改基本信息，在履行中则不能修改；可以管理客户信息，包括客户信息的新增、修改及查询；可以管理销售人员信息，包括新增、修改及查询。仓库管理员可以对库存商品的基本信息进行管理，包括新增商品，商品信息修改，商品下架以及查询。 查询统计（选做） 销售管理员可以对合同进行多条件查询，以及关联查询（即在查询合同时同时查出客户以及销售人员信息）；可以对客户进行多条件查询，以及关联查询（同时查询合同）；可以对销售人员进行多条件查询，以及关联查询（同时查询合同）；仓库管理员可以对库存商品进行多条件查询；销售管理员可以按客户、销售人员、以及商品种类完成销售情况的统计。
SpringMVC工作原理
caomiao2006的专栏
08-29 751
上面的是springMVC的工作原理图： 1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet. 2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数C
【Spring MVC】基本原理和工作流程
最新发布
u013675821的博客
07-28 1508
负责接收并分派请求，是整个框架的核心。：负责将请求映射到处理器（Controller）。Controller：处理业务逻辑并返回模型数据和视图信息。：对请求处理器进行适配，以便于调用。：将逻辑视图名解析为具体的视图实现。View：负责渲染模型数据，将结果返回给客户端。通过以上示例，我们可以看到 Spring MVC 的核心工作流程和组件如何协作完成一个完整的请求处理过程。在开发过程中，我们可以根据需要扩展和定制各个组件，以适应具体的业务需求。
spring mvc 工作原理
weixin_30823227的博客
07-11 59
Spring的MVC框架主要由DispatcherServlet、处理器映射、处理器、视图解析器、视图组成。 整个处理过程从一个HTTP请求开始：1）DispatcherServlet接收到请求后，根据对应配置文件中配置的处理器映射，找到对应的处理器映射项（HandlerMapping），根据配置的映射规则，找到对应的处理器（Handler）。2）调用相应处理器中的处理方法，处理该请求，处理器处...
Spring MVC框架原理
Jmark
08-27 1032
一.原理图与执行流程 Spring的MVC框架主要由DispatcherServlet、处理器映射、处理器、视图解析器、视图组成。 Spring MVC的原理框图: 整个处理过程从一个HTTP请求开始： 1）DispatcherServlet接收到请求后，根据对应配置文件中配置的处理器映射，找到对应的处理器映射项（HandlerMapping），根据配置
Java SSM 笔记（一）重置版
qq_25928447的博客
02-16 6617
**前置课程要求：**请各位小伙伴先完成《JavaWeb》篇、《Java 9-17新特性》篇视频教程之后，再来观看此教程。**建议：**对Java开发还不是很熟悉的同学，最好先花费半个月到一个月时间大量地去编写小项目，不推荐一口气学完，后面的内容相比前面的内容几乎是降维打击，一口气学完很容易忘记之前所学的基础知识，尤其是JavaSE阶段的内容。不同于2021版本SSM教程，本期视频为重制版本，视频学习的Spring框架版本为：6.0恭喜各位顺利进入到SSM（Spring+SpringMVC+Mybatis）
java写安卓app实例，原理+实战+视频+源码
m0_56830725的博客
07-10 1509
1.笔试常见的问题？ 面试常见的问题上面给的面试题链接基本都有。我只提几点： 写SQL：写SQL很常考察group by、内连接和外连接。 手写代码：手写代码一般考单例、排序、线程、消费者生产者。我建议排序算法除了冒泡排序，最好还能手写一种其他的排序代码。试想：如果一般面试者都写的冒泡排序，而你写的是快速排序/堆排序，肯定能给面试官留下不错的印象。 2.面试流程？ 让你自我介绍 问Java基础知识 问项目 情景问题，例如：你的一个功能上了生产环境后，服务器压力骤增，该怎么排查。 你有什么想问面试官的
2022版史上最牛Java学习路线图（视频教程+配套资料）
程序员日常
07-29 1806
0基础如何学习java？Java要学习哪些是核心内容？自学Java到什么程度可找工作？正在迷茫的你不必在东瞅西逛，自学Java看这一篇就够了！​PS。
华为架构师8年经验谈：从单体架构到微服务的服务化演进之路（李林锋 DBAplus社群）
09-10
华为架构师8年经验谈：从单体架构到微服务的服务化演进之路 本次分享的大纲如下： 传统应用开发面临的挑战 服务化实践 服务化不是银弹 服务化架构的演进方向
SSM 单体应用架构搭建 — Spring+Spring MVC+MyBatis
Smilelfq的专栏
09-06 402
注：这里使用 Maven 项目管理工具构建项目 Intellij IDEA 新建项目 打开 Intellij IDEA，点击Create New Project 选择 Maven 构建项目 选择 JDK 版本（此处不阐述 JDK 安装的详细步骤，不会的小伙伴戳JDK 安装教程） 勾选项目模板 选择maven-archetype-webapp模板（Java Web 模板...
SpringMVC-工作原理
好记性不如烂笔头
02-25 196
一个完整请求的流转过程： 用户：发送请求 前端控制器(DispatcherServlet)：接收用户请求，并通过处理器映射器查找对应的处理器 处理器映射器(HandlerMapping)：查找对应的处理器，返回给前端控制器 处理器适配器(HandlerAdapter )：根据前端控制器提供的处理器对象来调用处理器 处理器(Handler)：即Controller，执行具体业务，并返回模...
springMVC-工作原理
sinat_27143551的博客
06-06 260
Spring的MVC框架主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成。原理图：SpringMVC接口解释DispatcherServlet接口：Spring提供的前端控制器，所有的请求都有经过它来统一分发。在DispatcherServlet将请求分发给Spring Controller之前，需要借助于Spring提供的HandlerMapping...
Spring SpringMVC 工作原理
siriusol的博客
04-10 151
参考链接： https://snailclimb.gitee.io/javaguide/#/docs/system-design/framework/spring/SpringInterviewQuestions 前言 Model1 时代 : 。在 Model1 模式下，整个 Web 应用几乎全部用 JSP 页面组成，只用少量的 JavaBean 来处理数据库连接、访问等操作。这个模式下 JSP...
SpringMVC工作原理（1）
千林的博客
07-13 2633
    大家好，今天和大家分享SpringMVC的相关知识，主要是对SpringMVC的工作原理做一些分析。    SpringMVC的工作流程如下：    接下来我们先来对其中的组件以及相应的功能来做简单介绍：    组件：1.DispatcherServletDispatcherServlet是我们所说的前端控制器，由框架进行提供，作用是接收请求，返回相应结果，同时负责调度其他组件进行工作，是...
【SSM】SSM之SpringMVC框架：SpringMVC的工作原理
景谦Nice的博客
03-01 399
客户端发送的请求被DispatcherServlet捕获后其流程如下： 其大致流程如下： 1、用户发送请求至前端控制器DispatcherServlet。 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3、处理器映射器如果没有找到具体的处理器： 如果配置了<mvc:default-servlethandler/>，就调用默...
《Spring MVC》 第十一章 单体架构任务调度
Java 技术专栏，从入门到精通，熟悉企业级开发
05-08 230
在Spring MVC项目基础上使用Spring task，开发定时任务调度功能。
深入理解SpringMVC：Java SSM框架的实战指南
Java的SSM框架，即Spring-Struts-MVC...因此，对于想要深入理解Spring MVC并应用于实际项目的开发者来说，学习这门技术是至关重要的，特别是跟随动力节点王鹤老师的课程，能够确保对SpringMVC有全面而深入的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值