让你五分钟彻底理解Spring MVC

目录
  • 概述
  • MVC 架构模式
    • 传统 MVC 架构模式
    • Java Web MVC 架构模式
    • Spring MVC 架构模式
  • Hello,Spring MVC
    • Spring MVC 依赖引入
    • DispatcherServlet 声明
    • Spring 上下文配置
      • Spring 上下文配置文件内容
      • HandlerMapping 配置
      • 处理器配置
      • ViewResolver 配置
  • DispatcherServlet 组件默认配置
  • 基于注解的 Spring WebMVC
  • DispatcherServlet 请求处理流程
  • 结束语

概述

Sping MVC 正式的名字为 Spring Web MVC,是 Spring Framework 框架中的其中一个模块,基于 Servlet API 构建,同时使用 MVC 的架构模式,主要用以简化传统的 Servlet + JSP 进行 web 开发的工作。

MVC 架构模式

Spring MVC 基于 MVC 模式,因此理解 Spring MVC 需要先对 MVC 模式有所了解。

传统 MVC 架构模式

MVC 即 Model-View-Controller 是软件开发中一种常用的架构模式,将软件系统分为三层:模型(Model)、视图(View)、控制器(Controller),各部分根据职责进行分离,使程序的结构更为直观,增加了程序的可扩展性、可维护性、可复用性。可以用如下的图形来表示三者之间的关系。

  • 模型(Model):模型封装了数据及对数据的操作,可以直接对数据库进行访问,不依赖视图和控制器,也就是说模型并不关注数据如何展示,只负责提供数据。GUI 程序模型中数据的变化一般会通过观察者模式通知视图,而在 web 中则不会这样。
  • 视图(View):视图从模型中拉取数据,只负责展示,没有具体的程序逻辑。
  • 控制器(Controller):控制器用于控制程序的流程,将模型中的数据展示到视图中。

Java Web MVC 架构模式

上世纪 90 年代,随着互联网的发展,基于浏览器的 B/S 模式随之流行,最初浏览器向服务器请求的都是一些静态的资源,如 HTML,CSS 等,为了支持根据用户的请求动态的获取资源,Java 提出了 Servlet 规范。

此时 Servlet 可以说是一个大杂烩,浏览器接收的 HTML 都是通过 Servelt 一行一行的输出,比较繁琐,并且写后端代码的程序员还要熟悉前端技术,为了解决这个问题,sun 公司又借鉴 ASP 提出了 JSP。

JSP 和 HTML 相似,只是在 JSP 文件中可以嵌入 Java 代码,减少了直接使用 Servlet 产生的大量冗余代码。此时 JSP 同时充当模型、视图、控制器的角色,为了解决前后端代码仍然揉在一起的问题,Java Web MVC 模式后来被提出,JavaBean 充当模型、JSP 充当视图,Servlet 充当控制器,流程如下图所示。

浏览器的请求先经过 Servlet,Servlet 控制整个流程,使用 JavaBean 查询并存储数据,然后携带 JavaBean 中的数据到 JSP 页面中,这个就是 Java 中早期的 Web MVC 架构模式了。

Spring MVC 架构模式

Spring MVC 架构模式对 Java Web 中的 MVC 架构模式加以扩展,将控制器拆分为前端控制器 DispatcherServlet 和后端控制器 Controller,将 Model 拆分成业务层(Service) 和数据访问层(Respository),并且支持不同的视图,如 JSP、FreeMarker 等,设计更为灵活,请求处理流程如下。

浏览器的请求先经过 DispatcherServlet,DispatcherServlet 负责分发请求,因此 DispatcherServlet 又被称为前端控制器。DispatcherServlet 其后的 Controller 又被称为后端控制器,Controller 可以选择性的调用 Service、Repository 实现业务逻辑,DispatcherServlet 拿到 Controller 提供的模型和视图后,进行渲染并返回给浏览器。当然了,这里只是为了方便理解 Spring MVC 描述的大概流程,具体流程会在后文介绍。

Hello,Spring MVC

虽然现在 SpringBoot 已经成为主流,但是我仍然想从单纯的 Spring MVC 讲起,因为 SpringBoot 也只是在 Spring Framework 其上添加了一些自动化的配置,这些自动化的配置会让我们忽略背后的技术原理。

几年的 Spring 的教程中都会提出使用 Spring MVC 首先需要去 Spring 官网下载一大堆的依赖,而现在有了 maven 之后再也不必关系这些乱七八糟的依赖及其依赖关系。如果你不了解 maven,建议先去了解 maven 后再回头看下面的内容。

Spring MVC 依赖引入

新建 maven 项目,并引入 Spring MVC 的依赖,注意这里引入的版本号是 5.2.6,Spring Framework 5 开始对 JDK 版本的要求是 1.8 及以上。完整的 pom 内容如下。

<?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>com.zzuhkp</groupId>
    <artifactId>mvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <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>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <finalName>mvc-demo</finalName>
    </build>
</project>

DispatcherServlet 声明

传统的 Java Web 项目使用 Servlet 处理请求,Spring MVC 遵循了 Servlet 规范,提供了一个名称为 DispatcherServlet 的 Servlet 类,使用 Spring MVC 需要先声明这个 Servlet。

DispatcherServlet 整合了 IOC 容器,所有处理 Web 请求的组件都存至 IOC 容器中,然后使用这些 bean 处理控制整个请求过程。

有两种声明 DispatcherServlet 的方式,第一种方式是直接在类路径下的/WEB-INF/web.xml文件中配置。

<?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_4_0.xsd"
    version="4.0">

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

第二种方式基于 Servlet 3.0 提出的 ServletContainerInitializer 接口,Servlet 容器会从类路径中查找实现了这个接口的类,并在启动时回调这个接口中的方法,Spring MVC 已经将这个接口实现为 SpringServletContainerInitializer,在其内部调用了 WebApplicationInitializer 接口完成初始化,因此实现 WebApplicationInitializer 接口再添加 DispatcherServlet 也可以,和上述 xml 等效的 java 代码如下。

public class MvcXmlInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        XmlWebApplicationContext context = new XmlWebApplicationContext();
        DispatcherServlet dispatcher = new DispatcherServlet(context);
        Dynamic dynamic = servletContext.addServlet("dispatcher", dispatcher);
        dynamic.addMapping("/");
        dynamic.setLoadOnStartup(1);
    }
}

除了上述用户自定义的 WebApplicationInitializer,Spring 还自定义了一个支持注解配置的抽象实现类 AbstractAnnotationConfigDispatcherServletInitializer,这个类会自动向 Servlet 上下文中注册 DispatcherServlet,实现这个类然后指定配置类即可。

public class MvcAnnotationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null;
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{MvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

这里我们使用 web.xml 配置进行演示,我们配置的 DispatcherServlet 声明的映射路径是/,因此,所有的请求都会到达 DispatcherServlet,然后再分派给不同的处理器处理。

Spring 上下文配置

Spring MVC 使用 IOC 容器存储处理请求的组件,包括处理器在内的所有自定义的与 Web 请求有关的组件都需要添加到 Spring 的配置中。

Spring 上下文配置文件指定

DispatcherServlet 初始化时默认使用的容器是 XmlWebApplicationContext,虽然 Spring 预留了扩展点用于修改容器类型,非必要情况下还是建议不要修改,这个容器默认情况下会使用类路径下/WEB-INF/{servlet-name}-servlet.xml文件作为容器的配置文件,我们声明的 DispatcherServlet 名为 dispatcher,因此我们创建/WEB-INF/dispatcher-servlet.xml文件作为容器的配置。另外还可以使用 Servlet 的初始化参数 configLocation 指定 Spring 容器配置文件路径。

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

Spring 上下文配置文件内容

Spring 配置文件内容如下。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="/hellohandler" class="com.zzuhkp.mvc.handler.HelloSpringMVCHttpRequestHandler"/>

</beans>

这里声明了一个类型为 HelloSpringMVCHttpRequestHandler 的 bean,其 id 为请求路径/hellohandler,这个类的定义如下。

public class HelloSpringMVCHttpRequestHandler implements HttpRequestHandler {

    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        response.getWriter().write("Hello,HelloSpringMVCHttpRequestHandler");
    }

}

这样配置的目的是希望当/hellohandler请求到达时,能够使用我们提供的 HelloSpringMVCHttpRequestHandler 处理请求。

到了这里,将项目发布到 Tomcat,我这里使用的 Tomcat 版本号是 9.0.54,可以看到效果如下。

HandlerMapping 配置

那为什么将处理器的 bean id 配置为请求路径就可以使用这个处理器进行处理呢?Spring MVC 为了灵活的查找处理器内部使用了 HandlerMapping 将请求映射到处理器,Spring 默认情况下会使用BeanNameUrlHandlerMapping映射请求,这个映射器将请求路径作为 id 查找处理器。除了默认情况下使用的这个映射器,我们还可以配置 SimpleUrlHandlerMapping 映射器,和上述等效的 Spring 配置如下。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="hellohandler" class="com.zzuhkp.mvc.handler.HelloSpringMVCHttpRequestHandler"/>

    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="urlMap">
            <map>
                <entry key="/hellohandler" value-ref="hellohandler"/>
            </map>
        </property>
    </bean>

</beans>

处理器配置

看到这里,细心的小伙伴可能会有疑问,说好的 DispatcherServlet 将请求分派给 Controller 呢?这里暂时不用着急,Controller 其实是 Spring MVC 的处理器类型之一,这里的 HttpRequestHandler 同样是 Spring MVC 的处理器。

Spring 对多种处理器进行了支持,具体则是使用 HandlerAdapter 对处理器进行适配,Spring MVC 内部已经默认了一些适配器,HttpRequestHandler 的适配器是 HttpRequestHandlerAdapter,Controller 的适配器 SimpleControllerHandlerAdapter 也是 Spring MVC 默认支持的。

默认的 HandlerAdapter 已经足够支持日常所需,一般不会自定义 HandlerAdapter。

下面尝试使用 Controller 作为处理器处理请求,定义实现 Controller 接口的 HelloSpringMVCController 类如下。

public class HelloSpringMVCController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/WEB-INF/view/welcome.jsp");
        modelAndView.addObject("hello", "HelloSpringMVCController");
        return modelAndView;
    }
}

然后在 Spring 配置文件中添加这个类作为 bean。

<bean id="/hellocontroller" class="com.zzuhkp.mvc.handler.HelloSpringMVCController"/>

到了这里,终于可以看到 Controller 了,Controller 处理请求,返回了一个类型为 ModelAndView 的对象。

ModelAndView 包含模型和视图,这里向模型中添加了属性 hello,并且指定了/WEB-INF/view/welcome.jsp 文件作为视图名,这个文件内容如下。

<html>
<body>
<h2>Hello,${requestScope.hello}</h2>
</body>
</html>

启动 Tomcat 访问 /hellocontroller 效果如下。

成功将模型中的数据展示到视图。

ViewResolver 配置

为了支持不同的视图,如 JSP、FreeMarker 等,ModelAndView 中的视图名称被设计成虚拟的,具体的视图由视图解析器 ViewResolver 进行解析,默认情况下使用的视图解析器是 InternalResourceViewResolver ,这个视图解析器基于 URL 解析视图。同时也可以向应用上下文中配置自己的视图解析器。添加自定义的 InternalResourceViewResolver 到 Spring 配置文件。

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view"/>
        <property name="suffix" value=".jsp"/>
    </bean>

然后设置视图名时就可以忽略路径前缀/WEB-INF/view和后缀.jsp,配置前缀后缀后上述示例中 HelloSpringMVCController 就可以将视图名从 /WEB-INF/view/welcome.jsp 简化为 welcome

DispatcherServlet 组件默认配置

上述示例中使用了不少 DispatcherServlet 使用的组件,Spring MVC 默认情况下已经提供了一些,如果需要自定义,则将自定义的组件添加到上下文配置中接口,十分方便,那么 Spring 默认情况下使用了哪些组件处理请求呢?

spring-webmvc 模块类路径下 org/springframework/web/servlet/DispatcherServlet.properties 文件定义了这些默认的配置,具体如下。

基于注解的 Spring WebMVC

基于配置文件的 Spring Web MVC 项目在前些年确实比较流行,然而现在注解已经成为 Spring 开发的主流。下面通过纯注解的方式对上面的示例进行改造。

pom 文件不需要进行变化,首先要提供 Spring 配置类。

@ComponentScan("com.zzuhkp.mvc")
public class MvcConfig {

}

这里只添加了组件扫描能力,Spring 会将给定包下标注了 @Component 的类作为 bean 进行处理。然后将将这个类设置为配置类即可,这里可以参见使用上述提供的 DispatcherServlet 第二种声明方式。

然后提供基于注解的控制器。

@Controller
public class HelloSpringMVCAnnotationController {

    @GetMapping("/helloAnnotationController")
    public String helloMVC(@RequestParam("hello") String hello, Model model) {
        model.addAttribute("hello", hello);
        return "/WEB-INF/view/welcome.jsp";
    }

}

基于注解的控制器不需要实现特定的接口,直接在类上添加 @Controller 注解即可,这里定义了一个处理 /helloAnnotationController 路径 GET 请求方式的方法,并且接收 hello 参数,存放至 model 中,然后返回了视图名。这里直接复用了上面示例中的视图。最终效果如下。

基于注解的控制器是 Spring MVC 中设计最为灵活的地方,这里可以先考虑下,Spring 是怎么适配用户自定义的控制器的?控制器方法中的参数如何赋值呢?如何将控制器方法的返回值解析为视图?Spring 如何支持 RESTFUL 风格的接口的?后面会写几篇文章继续分析。

DispatcherServlet 请求处理流程

DispatcherServlet 请求处理流程已经穿插在前面的示例中介绍,直接看前面的描述可能不是很直观,这里总结了一张图来梳理整个流程。

整个流程串联起来如下。

  1. DispatcherServlet 处理浏览器发起的请求。
  2. DispatcherServlet 根据用户或默认的配置使用 HandlerMapping 查找可处理请求的处理器。
  3. DispatcherServlet 拿到 HandlerMapping 返回的处理器链 HandlerExecutionChain。整个处理器链包含拦截器和处理。
  4. DispatcherServlet 将处理器适配为 HandlerAdapter。
  5. DispatcherServlet 使用拦截器进行请求前置处理。
  6. DispatcherServlet 使用处理器进行请求处理。
  7. DispatcherServlet 使用拦截器进行请求后置处理。
  8. DispatcherServlet 从拦截器或处理器中提取到模型及视图 ModelAndView。
  9. DispatcherServlet 使用视图解析器 ViewResolver 解析视图出视图 View。
  10. DispatcherServlet 渲染视图,响应请求。

结束语

本文先介绍 MVC 架构模式,然后通过示例的方式对 Spring MVC 的使用方式及执行流程进行介绍,最后还使用一个流程图总结。

Spring MVC 中所有的扩展都基于 DispatcherServlet 处理请求的这个流程,可以说理解了这个流程图就理解了 Spring MVC 的原理,后面将会对这个流程进行细化,继续介绍 Spring MVC 的其他内容。

到此这篇关于理解Spring MVC的文章就介绍到这了,更多相关理解Spring MVC内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • springMVC几种页面跳转方式小结

    前面已经了解了Controller的几种配置方式 今天主要写一下响应界面跳转的几种方式 1.在注解的方式中 1.1通过HttpServletResponse的API直接输出(不需要配置渲染器) controller类的主要代码 @Controller public class RequestController{ @RequestMapping("/resp") public void handleRequest(HttpServletRequest req, HttpServletR

  • Spring MVC 框架搭建配置方法及详解

    现在主流的Web MVC框架除了Struts这个主力 外,其次就是Spring MVC了,因此这也是作为一名程序员需要掌握的主流框架,框架选择多了,应对多变的需求和业务时,可实行的方案自然就多了.不过要想灵活运用Spring MVC来应对大多数的Web开发,就必须要掌握它的配置及原理. 一.Spring MVC环境搭建:(Spring 2.5.6 + Hibernate 3.2.0) 1. jar包引入 Spring 2.5.6:spring.jar.spring-webmvc.jar.comm

  • SpringMVC之简单的增删改查示例(SSM整合)

    虽然已经在做关于SpringMVC的项目.但是还没有写一些比较系统的博客.今天就先来说一说最简单的增删改查吧.这个例子是基于SpringMVC+Spring+Mybatis实现的. 环境配置 主要是几项配置:springmvc的配置,spring的配置,MyBatis的配置,jdbc的配置,和web.xml配置 springmvc.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=&qu

  • Java简单实现SpringMVC+MyBatis分页插件

    1.封装分页Page类 package com.framework.common.page.impl; import java.io.Serializable; import com.framework.common.page.IPage; /** * * * */ public abstract class BasePage implements IPage, Serializable { /** * */ private static final long serialVersionUID

  • 一步步教你整合SSM框架(Spring MVC+Spring+MyBatis)详细教程

    前言 SSM(Spring+SpringMVC+Mybatis)是目前较为主流的企业级架构方案,不知道大家有没有留意,在我们看招聘信息的时候,经常会看到这一点,需要具备SSH框架的技能:而且在大部分教学课堂中,也会把SSH作为最核心的教学内容. 但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配合注解的方式,编程非常快捷,而且通过restful风格定义url,让地址看起来非常优雅. 另外,MyBatis也可以替换Hibernate,正因为MyBatis的半自动特点,我们程

  • 让你五分钟彻底理解Spring MVC

    目录 概述 MVC 架构模式 传统 MVC 架构模式 Java Web MVC 架构模式 Spring MVC 架构模式 Hello,Spring MVC Spring MVC 依赖引入 DispatcherServlet 声明 Spring 上下文配置 Spring 上下文配置文件内容 HandlerMapping 配置 处理器配置 ViewResolver 配置 DispatcherServlet 组件默认配置 基于注解的 Spring WebMVC DispatcherServlet 请求

  • 深入理解Spring MVC的数据转换

    本文主要给大家介绍了关于Spring MVC数据转换的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 数据绑定 SpringMVC负责将request中的信息以一定的方式转换并绑定到处理方法的参数上.整个过程的处理核心是由DataBinder完成.转换流程如下: 1.DataBinder从ServletRequest中获取参数信息: 2.DataBinder获取处理方法的参数: 3.DataBinder调用ConversionService组件数据类型转换和数据格式化

  • 深入理解Spring MVC概要与环境配置

    一.MVC概要 MVC是模型(Model).视图(View).控制器(Controller)的简写,是一种软件设计规范,用一种将业务逻辑.数据.显示分离的方法组织代码,MVC主要作用是降低了视图与业务逻辑间的双向偶合.MVC不是一种设计模式,MVC是一种架构模式.当然不同的MVC存在差异. 在web早期的开发中,通常采用的都是Model1.Model1中,如图所示主要分为两层,视图层和模型层.Model2把一个项目分成三部分,包括视图.控制.模型.这样不仅提高的代码的复用率与项目的扩展性,且大大

  • Spring MVC学习之DispatcherServlet请求处理详析

    前言 要深入理解spring mvc的工作流程,就需要先了解spring mvc的架构: 从上图可以看到 前端控制器DispatcherServlet在其中起着主导作用,理解了DispatcherServlet 就完全可以说弄清楚了spring mvc. DispatcherServlet作为Spring用于处理web请求注册的唯一一个Servlet,所有的请求都是经由DispatcherServlet进行分发处理的.本文主要讲解DispatcherServlet是如何对请求进行分发,处理,并且

  • 五分钟手撸一个Spring容器(萌芽版)

    目录 从什么是IOC开始? 工厂和Spring容器 订单:Bean定义 获取订单:资源加载 订单分配:Bean注册 生产车间:对象工厂 生产销售:测试 大家好,我是老三,Spring是我们最常用的开源框架,经过多年发展,Spring已经发展成枝繁叶茂的大树,让我们难以窥其全貌. 这节,我们回归Spring的本质,五分钟手撸一个Spring容器,揭开Spring神秘的面纱! 从什么是IOC开始? Spring——春天,Java编程世界的春天是由一位音乐家——Rod Johnson带来的. Rod

  • Spring MVC的web.xml配置详解

    spring是目前最流行的框架.创建java web项目时,我们首先会遇到的配置文件就是web.xml,这是javaweb为我们封装的逻辑,不在今天的研究中.下面我们将简单讲讲web.xml中的配置. 一.一个空的web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns:xsi="http://www.w3.org/2001/

  • 基于Spring MVC 简介及入门小例子(推荐)

    一.什么是 Spring MVC Spring MVC 属于 SpringFrameWork 的后续产品,已经融合在 Spring Web Flow 里面,是一个强大灵活的 Web 框架.Spring MVC 提供了一个 DispatcherServlet 作为前端控制器来分配请求.通过策略接口,Spring 框架是高度可配置的.Spring MVC 还包含多种视图技术,如 Java Server Pages(JSP).Velocity.Tiles.iText 和 POI 等.Spring MV

  • 详解Spring MVC CORS 跨域

    介绍 跨域CORS,全称是"跨域资源共享"(Cross-origin resource sharing) 当页面发出跨域请求时: 1.简单请求(先简单理解为正常的get/post吧): 浏览器将请求的地址添加到header的Origin里面发送请求.接下来就看后台如何处理了. 2.非简单请求(姑且简单理解成Content-Type:"application/json"吧): 浏览器会先发个预检请求(preflight),也就是OPTIONS请求.服务器返回是否许可访

  • 五分钟带你了解Java的接口数据校验

    本篇文章给大家分享平时开发中总结的一点小技巧!在工作中写过Java程序的朋友都知道,目前使用Java开发服务最主流的方式就是通过Spring MVC定义一个Controller层接口,并将接口请求或返回参数分别定义在一个Java实体类中,这样Spring MVC在接收到Http请求(POST/GET)后,就会自动将请求报文自动映射成一个Java对象.这样的代码通常是这样写的: @RestController public class OrderController { @Autowired pr

  • 五分钟教你手写 SpringBoot 本地事务管理实现

    白菜Java自习室 涵盖核心知识 1. SpringBoot 事务 一直在用 SpringBoot 中的 @Transactional 来做事务管理,但是很少没想过 SpringBoot 是如何实现事务管理的,今天从源码入手,看看 @Transactional 是如何实现事务的,最后我们结合源码的理解,自己动手写一个类似的注解来实现事务管理,帮助我们加深理解. 1.1. 事务的隔离级别 事务为什么需要隔离级别呢?这是因为在并发事务情况下,如果没有隔离级别会导致如下问题: 脏读 (Dirty Re

随机推荐