SpringMVC个人学习总结

已于 2022-07-27 22:01:39 修改
阅读量1.6k 收藏 4
点赞数
文章标签： java spring
于 2021-12-15 20:25:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Melekh_/article/details/121950144
版权
本文详细介绍了SpringMVC的学习过程，从回顾servlet开始，深入到SpringMVC的配置、运行原理、注解开发、Restful风格、重定向与转发、参数接收与回显、乱码处理、JSON数据交互、拦截器以及文件上传下载。内容涵盖从基础到进阶，适合Java Web开发者学习。
摘要由CSDN通过智能技术生成

目录

1、回顾servlet

2、初识SpringMVC

配置SpringMVC

3、SpringMVC运行原理

4、使用注解开发SpringMVC

5、Restful风格

6、重定向与转发

7、接收前端参数和参数回显

1.直接接收

2.当提交的域名称和处理方法的参数名不一致时

3.数据显示到前端

8、乱码问题

9、JSON

Controller返回JSON数据

FastJson

10、拦截器与文件上传

1、拦截器

2、文件上传和下载 

1、回顾servlet

        1.导入Maven依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

2.编写servlet类，处理用户请求

3.编写Hello.jsp,在WEB-INF下新建一个jsp文件夹，新建一个hello.jsp

4.编写一个form表单提交

6.在web.xml中配置servlet

6.配置Tomcat，并启动测试

2、初识SpringMVC

SpringMVC的特点：

        1、轻量级，简单易学

        2、高效，基于请求响应的MVC框架

        3、与Spring兼容性好，无缝结合

        4、约定大于配置

        5、功能强大：RESTful、数据验证、格式化、本地化、主体等

        6、简洁灵活

配置SpringMVC

1.新建一个Moudle，添加web支持

2.确定导入了SpringMVC依赖

3.配置web.xml，注册DispatcherServlet

    <!--配置DispatcherServlet：这个是SpringMVC的核心;请求发布器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定的spring的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--
    在SpringMVC中，/  &  /*
    /：只匹配所有请求，不会去匹配jsp页面
    /*：匹配所有请求，包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

4.编写springmvc的配置文件，名称为springmvc-servlet.xml,

5.添加处理映射器

6.添加处理适配器

7.添加视图解析器

<?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 class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器:模板引擎 Thymeleaf  Freemarker-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

8.编写操作业务Controller，要么实现Controller接口，要么增加注解，需要返回一个ModelAndView，装数据，封视图

9.将自己的类交给springIOC容器，注册Bean

10.写要跳转的jsp页面，显示ModelAndView存放的数据，以及我们的正常页面

11.配置tomcat启动测试

可能遇到的问题：访问出现404，排查步骤：

1. 查看控制台输出，看一下是不是缺少了什么jar包

2.如果jar包存在，显示无法输出，就在IDEA项目发布中，添加lib依赖

3.重启Tomcat

3、SpringMVC运行原理

1、用户发起请求，前端控制器DispatcherServlet接收请求并且拦截请求

2、前端控制器DispatcherServlet调用处理映射器HandlerMapping，映射器根据请求的url查找具体的Handler

3、HandlerExecution就是一个具体的Handler，作用为根据url查找控制器

4、HandlerExecution将解析后的信息返回给DispatcherServlet

5、DispatcherServlet再讲接收到的信息给处理适配器HandlerAdapter，按照特定的规则去执行Handler

6、将Handler交给具体的控制器Controller去执行

7、Controller把具体执行的信息返回给HandlerAdapter，例如ModelAndView

8、HandlerAdapter再把接收到的视图逻辑名或者模型返回给DispatcherServlet

9、DispatcherServlet调用视图解析器ViewResolver解析从适配器那里接收到的视图逻辑名

10、ViewResolver将解析的视图逻辑名返回给DispatcherServlet

11、DispatcherServlet根据接收到的视图逻辑名结果，调用具体的视图

12、最后将视图呈现给用户

4、使用注解开发SpringMVC

1.新建一个Model，添加web支持

2.导入依赖（父类实现了就可跳过这一步）

3.配置web.xml

        注意点：

                1、注意web.xml版本，要最新版

                2、检查项目结构中是否有lib文件，若没有则创建并导入jar包

注册DispatcherServlet

关联SpringMVC配置文件

启动级别为1

路径映射为/ 【不要用/*，会报404】

死代码，配置就用这个 

4.添加SpringMVC配置文件

让IOC的注解生效

静态资源过滤：html，js，css，图片，视频等

配置视图解析器

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.lqh.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />

    <mvc:annotation-driven />

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

 使用时候只用修改扫描的包的路径

5.创建一个controller类

@Controller是为了让Spring IOC容器初始化时自动扫描到；

 @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello

方法中声明Model类型的参数是为了把Action中的数据带到视图中；

方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp

6.创建视图层

7.配置Tomcat运行

使用springMVC必须配置的三大件：

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

5、Restful风格

概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应 添加、 删除、修改、查询。

实现

1.新建一个RestFulController

以前的方法

 

 RestFul风格则是在Spring MVC中可以使用  @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

 

使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等

增加一个方法

浏览器地址栏默认是Get请求，会报405

 修改为GET就正常了

一个是@PostMapping，一个是@GetMapping，结果走的是@GetMapping

 当前端声明了走post时   ps:a.jsp放在web文件路径下，不是WEB-INF文件路径 

提交后用post方法

依旧走get方法

这就是用了Restful以后为什么url地址相同，通过提交方式不一样，产生了不一样的结果 

6、重定向与转发

        通过SpringMVC来实现转发和重定向 - 无需视图解析器；

将视图解析器注释掉

设置绝对路径转发

forward转发

redirect重定向，/m1/t1直接跳转到index.jsp页面

 有视图解析器的时候,转发可直接实现

重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方 , 所以要注意路径问题.

可以重定向到另外一个请求实现 .

7、接收前端参数和参数回显

1.直接接收

编写实体类

接收前端参数

什么都不输入，页面为空，控制台输出为null

输入参数，控制台成功接收

2.当提交的域名称和处理方法的参数名不一致时

添加@RequestParam（"xxx"）注解

测试

 

3.数据显示到前端

第一种，通过ModelAneView

第二种，通过ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("name",name);
   System.out.println(name);
   return "hello";
}

第三种，通过Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("msg",name);
   System.out.println(name);
   return "test";
}

对比

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

8、乱码问题

编写一个form表单

 用post方法

测试

 

出现乱码

注意！！！！

在SpringMVC中，/  &  /*

/：只匹配所有请求，不会去匹配jsp页面
/*：匹配所有请求，包括jsp页面

以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置

    <!--配置springmvc中的乱码过滤-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

 

修改xml文件后重启服务器问题解决~

9、JSON

  • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。

  • 采用完全独立于编程语言的文本格式来存储和表示数据。

  • 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

  • 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

  • 对象表示为键值对，数据由逗号分隔

  • 花括号保存对象

  • 方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 "" 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

JSON 和 JavaScript 对象互转

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

Controller返回JSON数据

1.导jar包

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.13.0</version>
    </dependency>

2.配置SpringMVC的web.xml和springmvc-servlet.xml

3.编写一个实体类（使用注解需导入lombok的jar包）

4.编写Controller

注解@ResponseBody   添加以后它就不会走视图解析器，会直接返回一个字符串

发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；

通过@RequestMaping的produces属性来实现，修改下代码

    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")

 

乱码统一解决

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！

我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

返回json字符串统一解决

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody 。我们在前后端分离开发中，一般都使用 @RestController ，十分便捷

 输出多个对象

用list集合添加

 输出时间

自定义日期格式

 

 如果使用的比较多，将这些代码封装到一个工具类中，实现复用

 

 我们如果也想把第一个和第二个也简化一下应该怎么做？对工具类进行一下改动

 方法的重载，在同一个工具类中有一个同名的方法，当对括号内传参数量不同，调用不同的方法。这种编程的思想特别的重要，在各种源码里也会体现出来

这里的j2调用第一个就可以实现功能，将userList传进去即可实现

FastJson

 1.导入jar包

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.78</version>
    </dependency>

 

直接调用方法，传参进去即可！

fastjson 三个主要的类：

JSONObject  代表 json 对象

  • JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。

  • JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray   代表 json 对象数组

  • 内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

  • JSON类源码分析与使用

  • 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

这种工具类，我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！

10、拦截器与文件上传

1、拦截器

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

过滤器与拦截器的区别：拦截器是AOP思想的具体应用。

过滤器

  • servlet规范中的一部分，任何java web工程都可以使用

  • 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

  • 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

  • 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

我们怎么实现拦截器呢？

想要自定义拦截器，必须实现 HandlerInterceptor 接口。

创建新模块，配置web.xml文件，配置applicationContext.xml文件，编写一个拦截器

接下来在 applicationContext.xml中配置这个拦截器

    <!--拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--包括这个请求下面的所有请求-->
            <mvc:mapping path="/**"/>
            <bean class="com.lqh.config.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

编写一个controller测试

2、文件上传和下载 

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

对表单中的 enctype 属性做个详细的说明：

  • application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。

  • multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。

  • text/plain：除了把空格转换为 "+" 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

<form action="" enctype="multipart/form-data" method="post">
   <input type="file" name="file"/>
   <input type="submit">
</form>

一旦设置了enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

  • Servlet3.0规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成。

  • 而Spring MVC则提供了更简单的封装。

  • Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。

  • Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类：

  • CommonsMultipartResolver。因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。

1、导入文件上传的jar包，commons-fileupload ， Maven会自动帮我们导入他的依赖包 commons-io包；

<!--文件上传-->
<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>4.0.1</version>
</dependency>

2、配置bean：multipartResolver

<!--文件上传配置-->
<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
   <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
   <property name="defaultEncoding" value="utf-8"/>
   <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
   <property name="maxUploadSize" value="10485760"/>
   <property name="maxInMemorySize" value="40960"/>
</bean>

CommonsMultipartFile 的 常用方法：

  • String getOriginalFilename()：获取上传文件的原名

  • InputStream getInputStream()：获取文件流

  • void transferTo(File dest)：将上传文件保存到一个目录文件中

3、编写前端页面

<form action="/upload" enctype="multipart/form-data" method="post">
 <input type="file" name="file"/>
 <input type="submit" value="upload">
</form>

4、Controller

package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.*;

@Controller
public class FileController {
   //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
   //批量上传CommonsMultipartFile则为数组即可
   @RequestMapping("/upload")
   public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

       //获取文件名 : file.getOriginalFilename();
       String uploadFileName = file.getOriginalFilename();

       //如果文件名为空，直接回到首页！
       if ("".equals(uploadFileName)){
           return "redirect:/index.jsp";
      }
       System.out.println("上传文件名 : "+uploadFileName);

       //上传路径保存设置
       String path = request.getServletContext().getRealPath("/upload");
       //如果路径不存在，创建一个
       File realPath = new File(path);
       if (!realPath.exists()){
           realPath.mkdir();
      }
       System.out.println("上传文件保存地址："+realPath);

       InputStream is = file.getInputStream(); //文件输入流
       OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流

       //读取写出
       int len=0;
       byte[] buffer = new byte[1024];
       while ((len=is.read(buffer))!=-1){
           os.write(buffer,0,len);
           os.flush();
      }
       os.close();
       is.close();
       return "redirect:/index.jsp";
  }
}

采用file.Transto 来保存上传的文件

/*
* 采用file.Transto 来保存上传的文件
*/
@RequestMapping("/upload2")
public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

   //上传路径保存设置
   String path = request.getServletContext().getRealPath("/upload");
   File realPath = new File(path);
   if (!realPath.exists()){
       realPath.mkdir();
  }
   //上传文件地址
   System.out.println("上传文件保存地址："+realPath);

   //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
   file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

   return "redirect:/index.jsp";
}

文件下载步骤：

1、设置 response 响应头

2、读取文件 -- InputStream

3、写出文件 -- OutputStream

4、执行操作

5、关闭流 （先开后关）

代码实现：

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
   //要下载的图片地址
   String  path = request.getServletContext().getRealPath("/upload");
   String  fileName = "基础语法.jpg";

   //1、设置response 响应头
   response.reset(); //设置页面不缓存,清空buffer
   response.setCharacterEncoding("UTF-8"); //字符编码
   response.setContentType("multipart/form-data"); //二进制传输数据
   //设置响应头
   response.setHeader("Content-Disposition",
           "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));

   File file = new File(path,fileName);
   //2、 读取文件--输入流
   InputStream input=new FileInputStream(file);
   //3、 写出文件--输出流
   OutputStream out = response.getOutputStream();

   byte[] buff =new byte[1024];
   int index=0;
   //4、执行 写出操作
   while((index= input.read(buff))!= -1){
       out.write(buff, 0, index);
       out.flush();
  }
   out.close();
   input.close();
   return null;
}

前端

<a href="/download">点击下载</a>

文章部分内容转载自 狂神说 博客内容

终于，狂神说SSM及SpringBoot系列文章完更！！！_狂神说-CSDN博客_狂神springboot

Melekh_
关注
Spring MVC学习总结
qq_39828828的博客
08-18 415
开发工具与关键技术：Visual Studio 作者： 李哲定 撰写时间：2020年8月17日 通过这一段时间的学习，有针对的对上一次培训内容的不足及时的进行了补缺不差。让我对Spring MVC有了更进一步深刻的了解。 为满足学习的需求，之前只对Spring MVC框架做了初步的了解，是很肤浅的。只仅仅是了解到了，程序在Spring MVC框架下的执行的流程，具体细节从未做过深入的学习。 经过了这一段时间的学习，让我对Spring MVC的结构有了大概的认识，主要分为以下主要六个部件：Dispa.
spring+springmvc+mybatis总结
dongyu928的博客
05-21 454
1.Spring：轻量级开源框架，简化了企业级开发应用。Spring最核心的是bean。BeanFactory定义获取bean以及bean的各种属性。Spring底层原理使用反射机制。 Spring工作原理 2.Spring核心构成：内部最核心：IOC（控制反转）也叫依赖注入，由原来的new对象方式，改变为由容器自动产生。很好的实现了模块间的解耦问题，使的项目在后期的维护和扩展上更加方便。这其...
SpringMVC学习笔记（狂神说）
weixin_44190665的博客
04-11 672
SpringMVC学习笔记（狂神说）1、什么是SpringMVC1.1 回顾Servlet 1、什么是SpringMVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。 是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向偶合 MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。 1.1 回顾Servlet 1、新建一个Maven工程当做富工程，引入依赖。 <dependencie
SpringMVC学习总结
Mr.BoBo的博客
04-15 957
总结目录前言一、SpringMVC概述1.1 MVC架构1.2 SpringMVC是什么？1.3 Spring MVC架构执行流程二、SpringMVC入门2.1 创建Maven项目并引入约束2.2 在 `web.xml` 中配置前端控制器2.3 编写Controller类2.4 编写JSP页面2.5 编写 `applicationContext.xml`配置文件2.6 运行测试及总结三、常用注解...
SpringMVC学习总结（一）
偶滴博客
02-16 585
目录一、MVC简介二、SpringMVC简介1.概述2.执行原理三、SpringMVC简单实现1.xml配置文件 一、MVC简介 MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。MVC主要作用是降低了视图与业务逻辑间的双向偶合。 Model：包括Value Object（数据Dao） 和 服务层（行为Service），提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。 View：负责进行模型的展示，用户界面 Controller：接收请求
SpringMVC学习心得
weixin_50587646的博客
09-12 1830
文章目录一、回顾MVC1.什么是MVC二、1.2.总结 一、回顾MVC 1.什么是MVC model: dao和service view：视图 controller：servlet 二、 1. 2. 总结
SpringMVC学习.pdf
11-12
SpringMVC是Spring框架中的一个重要模块，是用于构建Web应用程序的全功能MVC（Model-View-Controller）架构实现。SpringMVC的核心目标是简化Web层的开发流程，即通过注解等现代编程方法，使开发人员能够专注于业务...
SpringMVC学习总结及心得
qq505639213的博客
03-31 6021
1.1 SpringMVC的介绍它是一款基于Spring框架、servlet、jsp的集成框架，可以应用于快速创建web项目。1.2 HTTP学习HTTP的个人理解，根据书籍对http的简介，我们可以知道http是由w3c组织维护的产品，而是一个产品就必须有服务端，所以我们可以认为它是一个共享的服务端，它负责游览器与我们的服务器建立连接，这个就是http的好处。而实质上，客户端并不会直接与我们服务...
2020SpringMVC课程总结报告.doc
12-23
三、个人课程学习成果特点总结 通过这门课程的学习，不仅掌握了SpringMVC的使用，还能独立进行项目的搭建和功能实现。对SpringMVC的核心组件有了深入理解，例如DispatcherServlet的作用、模型视图控制器的设计模式、...
个人学习总结：SpringMVC注解常用注解总结
man_zuo的博客
09-21 819
文章目录bean的自动创建和自动装配通过Java代码新建bean消除自动装配的歧义SpringMVC配置控制层 bean的自动创建和自动装配 @Component： 标注一个类，spring会自动用默认无参的构造方法自动创建一个bean，该bean的id默认为类名首字母小写，也可以用@Component(“xxx”)将bean的id设置成xxx @ComponentScan:标注一个类（一般该类都...
SpringMVC 学习总结
12-05
关于SpringMVC的基础知识点总结，SpringMVC参数绑定6种方式，使用不同的方式跳转页面，后台处理json格式的数据，SpringMVC框架简介，SpringMVC的入门案例等
SpringMVC的学习心得（实用的点都总结好啦（￣︶￣）↗　）
m0_46160373的博客
07-18 3498
SpringMVC的学习心得： MVC模型 MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写其中模型是指数据模型，用dao层获取数据，或是通过后端代码计算出来的数据，它代表的是整个数据类的东西。 视图呢是指前端页面。 控制器就是指控制数据注入到页面的一种类. SpringMVC和Struts2的优略分析 共同点： ​ 都是通过MVC写的 ​ 底层都离不开ServletAPI ​ 它们处理请求的机制都是一个核心控制器。
springmvc学习总结——1
yss的博客
08-16 1043
学完spring后，紧接着步入了springmvc的学习。学习完springmvc后就是整合spring、springmvc、mybatis。 学习springmvc之前我们先来看一下传统的MVC的设计模式： 1.用户想控制器（controller）发出请求。 2.控制器请求模型（model）进行业务处理，这些model包括Pojo,service,dao. 3.将调用模型得到的数据返回给...
SpringMVC学习基础总结
程序员战胜
03-14 1258
目录：一、MVC回顾二、Servlet回顾三、什么是SpringMVC四、SpringMVC执行原理五、使用注解开发SpringMVC六、RestFul风格七、接收请求参数和数据回显八、解决乱码问题决解json乱码问题九、Jackson、Fastjson的使用的使用 一、MVC回顾 Model(模型)： 数据模型，提供要展示的数据，分为数据Dao和服务层Servide，提供数据查询和模型数据的状态更新。 View(视图)： 负责进行模型的展示，也就是用户界面。 Controller(控制层)： 接受用户
Spring MVC详解(学习总结)
热门推荐
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
07-14 10万+
本篇文章对Spring MVC的常用知识点做了总结，画了思维导图，而且每个程序自己都亲自去测试过，文章也放了测试结果的图片，这篇博客主要是用了方便自己以后复习的，写得也比较详细，希望也可以帮助到大家......
SpringMVC总结
m0_60027772的博客
08-22 987
浏览器发送请求，若请求地址符合前端控制器url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取springmvc的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中的@requestMapping注解的value值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应的页面。.
Spring MVC学习心得
最新发布
m0_71292271的博客
11-25 436
ViewReslover视图解析器解析后返回具体的View给DispatcherServlet DispatcherServlet根据View和Model渲染视图响应给客户端。MVC是一种设计思想，将一个应用分成3个基本部分，分别代表着Web应用程序中的3种职责 Model（模型）：用于存储数据和完成业务逻辑处理 View（视图）：用于显示数据和向控制器提交数据请求 Controller（控制器）：根据视图请求调用Model完成业务处理，将处理后的结果交由View进行展示。至少加入以下JAR包。
SpringMVC学习教程：从入门到实践
"这篇文档是关于SpringMVC的个人学习笔记，主要涵盖了SpringMVC的基础配置和使用。" SpringMVC是Spring框架的一个模块，主要用于构建Web应用程序的模型-视图-控制器（MVC）架构。这篇个人学习笔记详细介绍了在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值