SpringMVC学习笔记

已于 2022-04-02 21:56:04 修改
阅读量127 收藏
点赞数
文章标签： java mvc spring
于 2022-04-02 21:34:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DongShanAAA/article/details/123929440
版权

SpringMVC

本文根据黑马SpringMVC教程所作

SpringMVC开发步骤

具体流程图
在这里插入图片描述

① 导入SpringMVC相关坐标
② 配置SpringMVC核心控制器DispathcerServlet
③ 创建Controller类和视图页面
④ 使用注解配置Controller类中业务方法的映射地址
⑤ 配置SpringMVC核心文件 spring-mvc.xml
⑥ 客户端发起请求测试

引例：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转。

导入Spring和SpringMVC的坐标

<!--Spring坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>X.X.X</version>
</dependency>
<!--SpringMVC坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>X.X.X</version>
</dependency>

在web.xml配置SpringMVC的核心控制器

<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern><!--拦截所有访问-->
</servlet-mapping>

创建Controller和业务方法

@Controller
@RequestMapping("/CBA")
public class ABCController {

    /*
        @RequestMapping

    作用：用于建立请求 URL 和处理请求方法之间的对应关系
        1.类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
        2.方法上，请求 URL 的第二级访问目录，与类上的使用 @ReqquestMapping标注的一级目录一起组成访问虚拟路径
        //访问地址为：http://localhost:8080/CBA/ABC
    属性：
    1.value：用于指定请求的URL。它和path属性的作用是一样的
    2.method：用于指定请求的方式（post.....
    3.params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
        例如：
        params = {"accountName"}，表示请求参数必须有accountName
        例子:http://localhost:8080/CBA/ABC?accountName=Judy

        params = {"key!0"}，表示请求参数中key不能是0
        例子:http://localhost:8080/CBA/ABC?key=0 (不给你进入)
    
    */
    @RequestMapping("/ABC")
    public String ABCmethod(){
    System.out.println("ABCmethod running.....");
        return "index";//访问index.jsp
    }
}


<!-- index.jsp -->
    <html>
    <body>
        <h1>Hello SpringMVC</h1>
    </body>
    </html>

创建spring-mvc.xml

<!--    mvc命名空间引入     -->
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:context="http://www.springframework.org/schema/context"
        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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用注解扫描-->
    <context:component-scan base-package="A.B.controller"/>


    <!--我们可以通过属性注入的方式修改视图的的前后缀-->
    <!--配置视图解析器-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/views/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
    </beans>

SpringMVC 组件解析

SpringMVC的执行流程

在这里插入图片描述

① 用户发送请求至前端控制器DispatcherServlet。
② DispatcherServlet收到请求调用HandlerMapping处理器映射器。
③ 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
④ DispatcherServlet调用HandlerAdapter处理器适配器。
⑤ HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
⑥ Controller执行完成返回ModelAndView。
⑦ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
⑧ DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
⑨ ViewReslover解析后返回具体View。
⑩ DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。

组件解析

  1. 前端控制器：DispatcherServlet
    用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。

  2. 处理器映射器：HandlerMapping
    HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

  3. 处理器适配器：HandlerAdapter
    通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

  4. 处理器：Handler
    它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理。

  5. 视图解析器：View Resolver
    View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

视图解析器源码：
REDIRECT_URL_PREFIX = “redirect:” --重定向前缀
FORWARD_URL_PREFIX = “forward:” --转发前缀（默认值）
prefix = “”; --视图名称前缀
suffix = “”; --视图名称后缀

  1. 视图：View
    SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程
    序员根据业务需求开发具体的页面

SpringMVC的请求与响应

SpringMVC的数据响应方式

页面跳转
  • 直接返回字符串
@RequestMapping("/ABC")
    public String method(){ 
    return "index";
    //如若想用重定向 ，则 return "redirect:index";
}

<property name="prefix" value="/WEB-INF/views/" />
<property name=“suffix” value=".jsp" />

最终结果：（默认为转发）
地址为：/WEB-INF/views/index.jsp

  • 通过ModelAndView对象返回
@RequestMapping("/ABC2")
public ModelAndView method2(){
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("redirect:index.jsp");
    return modelAndView;
}
//----------------------------------------------------
@RequestMapping("/ABC3")
public ModelAndView method3(){
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("forward:/WEB-INF/views/index.jsp");
    //向request域存储数据
    modelAndView.addObject("name","Judy");
    return modelAndView;
}
回写数据
  • 直接返回字符串
//直接返回字符串
@RequestMapping("/ABC4")
@ResponseBody
/*通过@ResponseBody注解告知SpringMVC框架，
    方法返回的字符串不是跳转是直接在http响应体中返回。*/
public String method4() throws IOException {
    return "judy";
}
  • 返回对象或集合
<!--返回json格式-->
<!--使用<mvc:annotation-driven>默认底层就会集成jackson进行对象或集合的json格式字符串的转换。-->
<!--mvc的注解驱动-->
<mvc:annotation-driven/>

@RequestMapping("/ABC5")
@ResponseBody
public User method5() throws IOException {
    User user = new User();
    user.setUsername("judy");
    user.setAge(18);
    return user;
}

SpringMVC 获得请求数据

SpringMVC可以接收如下类型的参数：

  • 基本类型参数
  • POJO类型参数
  • 数组类型参数
  • 集合类型参数
//获得基本类型参数
// http://localhost:8080//ABC6?username=judy&age=18
@RequestMapping("/ABC6")
@ResponseBody
public void method6(String username,int age) throws IOException {
System.out.println(username);
System.out.println(age);
}

//获得POJO类型参数
//Controller中的业务方法的POJO参数的属性名与请求参数的name一致，
//参数值会自动映射匹配。
// http://localhost:8080//ABC7?username=judy&age=18
public class User {
    private String username;
    private int age;
    //getter/setter…
}
@RequestMapping("/ABC7")
@ResponseBody
public void method7(User user) throws IOException {
    System.out.println(user);
}
//获得数组类型参数
//Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。
// http://localhost:8080//ABC8?strs=111&strs=222&strs=333

@RequestMapping("/ABC8")
@ResponseBody
public void method8(String[] strs) throws IOException {
    System.out.println(Arrays.asList(strs));
}

/当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装。/

<!--
    指定放行静态资源,不然不能加载jquery文件，因为是SpringMVC的前端控制器
DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作
-->
<!--所以我们要在spring-mvc.xml配置文件中指定放行的资源-->
<mvc:resources mapping="/js/**" location="/js/"/> 
<mvc:default-servlet-handler/>

<!--当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。 -->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>


<script>
//模拟数据
    var userList = new Array();
        userList.push({username: "judy1",age: "20"});
        userList.push({username: "judy2",age: "20"});
        $.ajax({
            type: "POST",
            url: "//ABC9",
            data: JSON.stringify(userList),
            contentType : 'application/json;charset=utf-8'
        });
</script>

@RequestMapping("/ABC9")
@ResponseBody
public void method9(@RequestBody List<User> userList) throws IOException {
    System.out.println(userList);
}

参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定。

<form action="${pageContext.request.contextPath}/ABC10" method="post">
<input type="text" name="name123"><br>
<input type="submit" value="提交"><br>
</form>

@RequestMapping("/ABC10")
@ResponseBody
public void method10(@RequestParam(value="name123",required = false,defaultValue = "judy") String username) throws IOException {
    /*
    value：与请求参数名称
    required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
    defaultValue：当没有指定请求参数时，则使用指定的默认值赋值

    */
    System.out.println(username);
}

自定义类型转换器

自定义类型转换器的开发步骤：
① 定义转换器类实现Converter接口
② 在配置文件中声明转换器
③ 在中引用转换器

//定义转换器类实现Converter接口
public class DateConverter implements Converter<String,Date>{
    @Override
    public Date convert(String source) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date = format.parse(source);
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

<!--在配置文件中声明转换器-->
<bean id="converterService" 
    class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="converter.DateConverter"/>
        </list>
    </property>
</bean>

<!--在<annotation-driven>中引用转换器-->
<mvc:annotation-driven conversion-service="converterService"/>

获得Servlet相关API

@RequestMapping("/ABC")
@ResponseBody
public void method(HttpServletRequest request,HttpServletResponse 
response,HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

获得请求头

@RequestMapping("/ABC")
@ResponseBody
public void method(@RequestHeader(value = "User-Agent",required = false) String headerValue){
    /*
    @RequestHeader可以获得请求头信息
    value：请求头的名称
    required：是否必须携带此请求头
    */
    System.out.println(headerValue);
}

@RequestMapping("/ABC")
@ResponseBody
public void method(@CookieValue(value = "JSESSIONID",required = false) String jsessionid){
    /*
    @CookieValue可以获得指定Cookie的值
    value：指定cookie的名称
    required：是否必须携带此cookie
    */
    System.out.println(jsessionid);
}

文件上传

表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”

<form action="${pageContext.request.contextPath}/quick20" method="post" 
    enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件1：<input type="file" name="file"><br>
    <!--多文件上传
    文件1：<input type="file" name="uploadFiles"><br>
    文件2：<input type="file" name="uploadFiles"><br>
    文件3：<input type="file" name="uploadFiles"><br>
    -->
    
    <input type="submit" value="提交"><br>
</form>

<!--配置文件上传解析器-->
<bean id="multipartResolver" 
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--上传文件总大小-->
    <property name="maxUploadSize" value="5242800"/>
    <!--上传单个文件的大小-->
    <property name="maxUploadSizePerFile" value="5242800"/>
    <!--上传文件的编码类型-->
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

//编写文件上传代码
@RequestMapping("/ABC")
@ResponseBody
public void Method(String name,MultipartFile uploadFile/*MultipartFile[] uploadFiles*/) throws IOException {
    //多文件上传将方法参数MultipartFile类型修改为MultipartFile[]即可
    //然后用增强for循环进行下面的操作

    //获得文件名称
    String originalFilename = uploadFile.getOriginalFilename();
    //保存文件
    uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
}

SpringMVC拦截器

Spring MVC 的拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。

区别过滤器(Filter)拦截器(Interceptor)
使用范围是 servlet 规范中的一部分，任何JavaWeb工程都可以使用是 SpringMVC 框架自己的，只有使用了SpringMVC 框架的工程才能用
拦截范围在 url-pattern 中配置了/*之后,可以对所有要访问的资源拦截在<mvc:mapping path=“”/>中配置了/**之后，也可以多所有资源进行拦截，但是可以通过<mvc:exclude-mapping path=“”/>标签排除不需要拦截的资源

自定义拦截器
① 创建拦截器类实现HandlerInterceptor接口
② 配置拦截器
③ 测试拦截器的拦截效果

//创建拦截器类实现HandlerInterceptor接口
public class MyHandlerInterceptor1 implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse 
        response, Object handler) {
        System.out.println("preHandle running...");
        return true;
    }
    public void postHandle(HttpServletRequest request, HttpServletResponse 
        response, Object handler, ModelAndView modelAndView) {
        System.out.println("postHandle running...");
    }
    public void afterCompletion(HttpServletRequest request, HttpServletResponse 
        response, Object handler, Exception ex) {
        System.out.println("afterCompletion running...");
    }
}                                                   

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="interceptor.MyHandlerInterceptor1"/>
    </mvc:interceptor>
</mvc:interceptors>

拦截器方法说明:

方法名说明
preHandle()方法将在请求处理之前进行调用，该方法的返回值是布尔值Boolean类型的，当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行；当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法
postHandle()该方法是在当前请求进行处理之后被调用，前提是preHandle 方法的返回值为true 时才能被调用，且它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作
afterCompletion()该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行，前提是preHandle 方法的返回值为true 时才能被调用

SpringMVC异常处理机制

系统的Dao、Service、Controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如图所示
在这里插入图片描述

方式1：使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver

<!--SpringMVC已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置-->
<!--配置简单映射异常处理器-->
<bean>
    class=“org.springframework.web.servlet.handler.SimpleMappingExceptionResolver”>
    <property name=“defaultErrorView” value=“error”/> <!--默认错误视图-->
    <property name=“exceptionMappings”>
        <map>           <!--异常类型-->             <!--错误视图-->
            <entry key="exception.MyException" value="error"/>
            <entry key="java.lang.ClassCastException" value="error"/>
        </map>
    </property>
</bean>

方式2：实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器

自定义异常处理步骤
① 创建异常处理器类实现HandlerExceptionResolver
② 配置异常处理器
③ 编写异常页面
④ 测试异常跳转

//创建异常处理器类实现HandlerExceptionResolver
public class MyExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, 
    HttpServletResponse response, Object handler, Exception ex) {
        //处理异常的代码实现
        //创建ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("exceptionPage");
        return modelAndView;
    }
}

<!--配置异常处理器-->
<bean id="exceptionResolver" 
class="exception.MyExceptionResolver"/>

<!--编写异常页面-->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>    
</head>
<body>
    这是一个最终异常的显示页面
</body>
</html>

END

\Judy\
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringMvc详解，SpringMVC入门到精通，看这一篇就够了
诺浅的专栏
04-20 5111
一、Spring mvc是什么？ Spring mvc和Struts2都属于表现层的框架,它是Spring框架的一部分 二、Spring mvc运行流程（架构） 1、用户发送请求至前端控制器DispatcherServlet 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3、处理器映射器根据请求url找到具体的处理器，生成处理器对象...
spring mvc DispatcherServlet 接收请求到响应数据的过程
Mr_rain的专栏
03-31 2736
经常做项目使用spring mvc，可是你了解过spring mvc是如何处理HttpServletRequest的么，从接收请求到响应数据，中间过程是怎么样的，这篇文章里面有详细描述。
SpringMVC的工作流程
caijian_的博客
08-16 3971
1. 用户发送请求至前端控制器DispatcherServlet 2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3. 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 4. DispatcherServlet通过HandlerAdapter处理器适配器调用处
Spring MVC 原理 - DispatcherServlet调用完整过程（上）
热门推荐
偶尔记一下 - mybatis.io
03-10 1万+
进入web.xml中配置的Spring拦截（调度）器：   调用堆栈信息： 开始拦截，这一步主要是根据request获取handler（该handler可以配置）： （接上面方法）这段代码中的if(isGet…主要解决浏览器的缓存问题，如果没有过修改，则返回（浏览器可能会用缓存响应）。 调用方法handler： 进入h
Servlet处理用户请求和响应(二)
凯耐的博客
09-15 3884
(一)浏览器访问Servlet过程示意图1.Servlet主要作用就是处理客户端请求和响应。浏览器每一次请求Servlet,服务器Tomcat在调用Service()方法之前，都会创建两个对象，分别是HttpServletRequest对象和HttpServletResponse对象。3.HttpServletResponse的作用：封装HTTP响应消息。(二)HttpServletRequest对
SpringMvc学习笔记
最新发布
06-24 1078
​ Spring MVC中的拦截器（Interceptor）类似于Servlet中的过滤器（Filter），它主要用于拦截用户请求并作相应的处理。例如通过拦截器可以进行权限验证、判断用户是否登录等。​ 拦截器依赖于web框架，在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。
springMVC学习笔记
mingshengda的博客
03-18 383
一、概述 springMVC:是基于spring的一个框架，实际上是一个模块，专门做web开发的。理解为是servlet的升级。 web开发的底层就是servlet，框架是在servlet基础之上，加入一些功能，让你做web开发更方便。 springMVC就是一个spring，spring是一个容器，ioc能管理对象。 springMVC能创建对象，放到容器（springMVC容器）中。springMVC放置的是控制器对象。 我们要做的是使用@controller创建控制器对象，把对象放到springMVC
springmvc学习笔记
10-28
springmvc学习笔记
SpringMVC学习笔记.zip
04-12
SpringMVC是Java web开发中一个非常重要的框架，它基于模型-视图-控制器（Model-View-Controller）设计模式...这份“SpringMVC学习笔记”包括了从基础到进阶的全面内容，旨在帮助读者从零开始掌握SpringMVC的各个方面。
狂神说Java-SpringMVC学习笔记
05-17
狂神说Java——SpringMVC学习笔记 内容概要： 1、了解什么是SpringMVC 2、RestFul和控制器 3、转发和重定向 4、数据处理 5、JSON 6、SSM项目整合 7、Ajax 8、拦截器+文件上传下载 能学到什么：详细了解SpringMVC基础...
springmvc学习笔记.zip
08-10
这个“springmvc学习笔记.zip”文件很可能包含了关于如何理解和使用SpringMVC的详细教程或个人学习记录。以下是一些核心知识点的详细说明： 1. **MVC架构**：MVC是一种设计模式，将应用程序分为三个主要组件：模型...
DispatcherServlet的处理流程
weixin_30432007的博客
11-09 502
前言 上一篇介绍了SpringMVC的启动过程，DispatcherServlet作为一个前端控制器，分发处理http请求 1.DispatcherServlet流程图 具体流程： 1.用户发请求-->DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制。 2.Dispa...
2023年SpringMVC学习笔记.doc
11-07
SpringMVC核心架构流程与知识点详解 SpringMVC是基于Java的Web应用程序框架，它提供了一个基于模型-视图-控制器（MVC）架构的Web应用程序开发模式。下面是SpringMVC的核心架构流程和知识点详解： ...
springmvc学习笔记-springmvc注解开发.zip
05-10
在"springmvc学习笔记--springmvc注解开发.zip"这个压缩包中，我们可以深入探讨Spring MVC的注解驱动开发方式，这是一种简洁且高效的开发模式。 1. **Spring MVC基础**： Spring MVC的核心组件包括...
springmvc学习笔记-前端控制器、上传、异常、开发心得小结等.zip
05-10
本学习笔记将涵盖前端控制器、文件上传、异常处理以及开发过程中的心得小结。 1. **前端控制器（DispatcherServlet）** 前端控制器是SpringMVC的核心组件，负责接收所有HTTP请求，然后根据请求的类型和映射规则...
"SpringMVC学习笔记：学习路线、源码提取与配置详解
SpringMVC学习笔记，学习路线，详细；SpringMVC详细学习笔记主要包括源码的提取，实例代码的提取，maven的配置，web.xml的配置，以及注解代替配置文件的类的书写方法。本文将对这些内容进行详细介绍。 第1章....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值