小学生都能学会的springmvc入门基础

最新推荐文章于 2024-01-08 19:10:10 发布
最新推荐文章于 2024-01-08 19:10:10 发布
阅读量421 收藏 4
点赞数 7
分类专栏： SSM 文章标签： spring java springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ares___/article/details/117168552
版权

小学生都能学会的springmvc！

一、什么是springmvc？？

MVC模型大家都知道吧？ 模型(Model)，视图(View)，控制器(Controller)的简写，是一种软件设计规范。

  • **Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
  • **View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
  • **Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

1.springmvc概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

Spring MVC的特点：

  1. 轻量级，简单易学
  2. 高效 , 基于请求响应的MVC框架
  3. 与Spring兼容性好，无缝结合
  4. 约定优于配置
  5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
  6. 简洁灵活

2.springmvc的执行原理

在这里插入图片描述

二、springmvc的第一个程序

了解了springmvc的执行原理后，我们来看看如何用springmvc快速开发我们的程序，以及相关的配置。

1.配置版(古老方案，了解原理)

  1. 创建web项目，导入springmvc相关依赖

  2. 看执行原理首先我们需要一个中央控制器，这是一个servelet，所以我们需要在web.xml文件中注册DispatcherServlet；

    <servlet>
       <servlet-name>springmvc</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
       </init-param>
       <!--启动级别-1-->
       <load-on-startup>1</load-on-startup>
   </servlet>

 <!--/ 匹配所有的请求；（不包括.jsp）-->
   <!--/* 匹配所有的请求；（包括.jsp）-->
   <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

  3. 然后我们发现有处理器映射器和处理器适配器，这两个在springmvc配置文件中配置。

    添加 处理映射器
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
添加 处理器映射器和适配器

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

  4. 下一步就是 视图解析器，例如我们jsp，thymeleaf等视图层需要被此解析。

    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
<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（接口版）

    public class HelloController implements Controller {
    @RequestMapping("hello") //通过/hello的请求会被此controller处理，这个需要配置注解驱动
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //创建对象
        ModelAndView mv =new ModelAndView();
        //addObject方法，把对象封装进去
       mv.addObject("msg","hello");
       //setViewName，指定要跳转的视图名称
       mv.setViewName("index");
        return mv;
    }
}

  6. 编写视图层（此处用jsp做例子）

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>Kuangshen</title>
</head>
<body>
${msg}
</body>
</html>

  7. 测试，localhost:8080/hello ,页面显示hello

2.注解版(常用)

基本跟上面配置相同

  • web.xml 中基本需要配置的有：

    1.注册中央处理器
2.关联springmvc配置文件
3.启动界别
4.映射路径
5.过滤器（避免乱码） 
<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>

  • springmvc.xml 中基本需要配置的有：

    1.包扫描（扫描注解用）
2.<mvc:annotation-driven /> 处理器映射器适配器最优解（注解驱动）
3.视图解析器
4.过滤静态资源
5.拦截器
6....

  • Controller的不同点（采用@controller注解）

    @Controller  相当于在配置文件中注册了bean
public class HelloController  {
    @RequestMapping("hello") 
    //方法中声明Model类型的参数是为了把Action中的数据带到视图中；
    public String hello(Model model){
        //向模型中添加属性msg 与 值，可以在jsp中取出并渲染
        model.addAttribute("msg","hello");
        return "index"; //return一个视图名，交给视图解析器
    }
   
}

3.总结

这仅仅是springmvc基本的一个程序需要，下面会有更多相关内容，不过springmvc的流程大致应该可以理解了吧。数据处理交互，后来会有详细介绍。

@Controller注解类型用于声明Spring类的实例是一个控制器

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

三、RestFul 风格

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

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

资源操作：使用POST(增)、DELETE(删)、PUT(改)、GET(查)，使用不同方法对资源进行操作。

1.传统方式操作资源：

​ 通过不同参数实现不同效果，方法单一

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

​	http://127.0.0.1/item/saveItem.action 新增,POST

​	http://127.0.0.1/item/updateItem.action 更新,POST

​	http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

2.RestFul风格操作资源：

可以根据不同方法来实现不同效果，例如一样的请求地址可以实现功能不一样

	http://127.0.0.1/item/1 查询,GET

	http://127.0.0.1/item 新增,POST

	http://127.0.0.1/item 更新,PUT

	http://127.0.0.1/item/1 删除,DELETE

3.@PathVariable

这个注解的作用是，让方法的值对应绑定到一个url变量上。

例如我们在url上传两个数字，并相加；

@Controller
public class RestFulController {

   //映射访问路径
   @RequestMapping("/rest/{p1}/{p2}")
   public String index(@PathVariable int p1, @PathVariable int p2, Model model){
       
       int result = p1+p2;
       //Spring MVC会自动实例化一个Model对象用于向视图中传值
       model.addAttribute("msg", "结果："+result);
       //返回视图位置
       return "test";
       
  }
   
}

我们访问的url ： locahost:8080/rest/1/2

界面显示： 结果：3

那么我们使用@PathVariable的好处是什么？？

  • 使路径变得更加简洁；
  • 获得参数更加方便，框架会自动进行类型转换。
  • 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/rest/1/a，则路径与方法不匹配，而不会是参数转换失败。

4.method属性

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

例如下面个注解的功能相同

@RequestMapping(value = "/hello",method = {RequestMethod.GET})

@GetMapping("hello")

通过不同的方法，是resful风格能实现相同请求地址，实现功能不一样的原因。

四、数据处理及跳转

springmvc参数接受处理？结果跳转处理？

1.结果跳转的方式

1.1 ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳转到指定页面

1.2 springmvc 实现

没有视图解析器：
    
@Controller
public class ResultSpringMVC {
   @RequestMapping("/rsm/t1")
   public String test1(){
       //转发
       return "/index.jsp";
  }

   @RequestMapping("/rsm/t2")
   public String test2(){
       //转发二
       return "forward:/index.jsp";
  }

   @RequestMapping("/rsm/t3")
   public String test3(){
       //重定向
       return "redirect:/index.jsp";
  }

有视图解析器：
重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方, 所以注意路径问题.
@Controller
public class ResultSpringMVC2 {
   @RequestMapping("/rsm2/t1")
   public String test1(){
       //转发
       return "test";
  }

   @RequestMapping("/rsm2/t2")
   public String test2(){
       //重定向
       return "redirect:/index.jsp";
       //return "redirect:hello.do"; //hello.do为另一个请求/
  }

2.数据处理

2.1 提交的域名称和处理方法的参数名一致

http://localhost:8080/hello?name=zhangsan

@RequestMapping("/hello")
public String hello(String name){
   System.out.println(name);
   return "hello";
}

输出结果：zhangsan

2.2 提交域名称与处理方法参数名不一致(@RequestParam)

 http://localhost:8080/hello?username=lisi

//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
   System.out.println(name);
   return "hello";
}

输出结果：lisi

2.3 提交的是一个对象

http://localhost:8080/mvc04/user?name=liuyifei&id=1&age=25

//User实体类
public class User {
   private int id;
   private String name;
   private int age;
   //构造
   //get/set
   //tostring()
}

//处理方法
@RequestMapping("/user")
public String user(User user){
   System.out.println(user);
   return "hello";
}

后台输出：User { id=1, name=‘liuyifei’, age=25 }

注意：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

3.数据显示到前端

3.1 通过ModelAndView

public class ControllerTest1 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

3.2 通过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";
}

3.3 通过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";
}

3.4 对比

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

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

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

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

五、JSON交互

什么是JSON？

  • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
  • 采用完全独立于编程语言的文本格式来存储和表示数据。
  • 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
  • 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

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

  • 对象表示为键值对，数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组

例如：

{"name": "小梦"}
{"age": "18"}
{"sex": "男"}

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

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

1.JSON与JS 对象互转

要实现从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"}'

测试：

<script type="text/javascript">
   //编写一个js的对象
   var user = {
       name:"王泽",
       age:20,
       sex:"男"
  };
   //将js对象转换成json字符串
   var str = JSON.stringify(user);
   console.log(str);
   
   //将json字符串转换为js对象
   var user2 = JSON.parse(str);
   console.log(user2.age,user2.name,user2.sex);

</script>

控制台结果：
{"name":"王泽","age":20,"sex":"男"}
20 "王泽" "男"

2.Controller与Json(本案例仅介绍jackson)

  1. 添加依赖

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

  2. 编写实体类

    @Data//需要lombok
@AllArgsConstructor
@NoArgsConstructor
public class User {

   private String name;
   private int age;
   private String sex;
   
}

  3. 编写controller

    @Controller
public class UserController {

   @RequestMapping("/json1",produces = "application/json;charset=utf-8")
   @ResponseBody //有这个注解就不走视图解析器了
   public String json1() throws JsonProcessingException {
       //创建一个jackson的对象映射器，用来解析数据
       ObjectMapper mapper = new ObjectMapper();
       //创建一个对象
       User user = new User("王泽", 3, "男");
       //将我们的对象解析成为json格式
       String str = mapper.writeValueAsString(user);
       //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
       return str;
  }

}

    结果：

    {"name":"王泽""age":3,"sex":"男"}

JSON乱码统一解决

@RestController = @Controller+@ResponseBody

可以通过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>

3.输出集合与对象

输出集合

@RequestMapping("/json2")
public String json2() throws JsonProcessingException {

   //创建一个jackson的对象映射器，用来解析数据
   ObjectMapper mapper = new ObjectMapper();
   //创建一个对象
   User user1 = new User("张三", 3, "男");
   User user2 = new User("李四", 3, "男");
   User user3 = new User("王五", 3, "男");
   User user4 = new User("萨斯给", 3, "男");
   List<User> list = new ArrayList<User>();
   list.add(user1);
   list.add(user2);
   list.add(user3);
   list.add(user4);

   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(list);
   return str;
}

输出对象

@RequestMapping("/json3")
public String json3() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   //创建时间一个对象，java.util.Date
   Date date = new Date();
   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(date);
   return str;
}

运行结果是一串数字，因为我们没有定义时间格式

定义格式：

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   //不使用时间戳的方式
   mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
   //自定义日期格式对象
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   //指定日期格式
   mapper.setDateFormat(sdf);

   Date date = new Date();
   String str = mapper.writeValueAsString(date);

   return str;
}

4.自定义工具类(源码思想)

上面的时间格式，如果我们经常使用上面的方式就显得很麻烦，我们可以自定义工具类，来简化代码，直接调用工具类即可

  • 工具类编写

    package com.kuang.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
   
    //一个参数，默认格式
   public static String getJson(Object object) {
       return getJson(object,"yyyy-MM-dd HH:mm:ss");
  }

    //两个参数，需要指定
   public static String getJson(Object object,String dateFormat) {
       ObjectMapper mapper = new ObjectMapper();
       //不使用时间差的方式
       mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
       //自定义日期格式对象
       SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
       //指定日期格式
       mapper.setDateFormat(sdf);
       try {
           return mapper.writeValueAsString(object);
      } catch (JsonProcessingException e) {
           e.printStackTrace();
      }
       return null;
  }
}

  • 使用

    @RequestMapping("/json5")
public String json5() throws JsonProcessingException {
   Date date = new Date();
   String json = JsonUtils.getJson(date);
   return json;
}

六、拦截器+文件上传下载

1.拦截器

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

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

过滤器

  • servlet规范中的一部分，任何java web工程都可以使用
  • 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

  • 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
  • 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

自定义拦截器

那如何实现拦截器呢？

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

1、建立web项目

2、配置web.xml 和 springmvc-servlet.xml 文件

3、编写一个拦截器

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {

   //在请求处理的方法之前执行
   //如果返回true执行下一个拦截器
   //如果返回false就不执行下一个拦截器
   public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
       System.out.println("------------处理前------------");
       return true;
  }

   //在请求处理方法执行之后执行
   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
       System.out.println("------------处理后------------");
  }

   //在dispatcherServlet处理后执行,做清理工作.
   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
       System.out.println("------------清理------------");
  }
}

4.在springmvc配置文件中配置

<!--关于拦截器的配置-->
<mvc:interceptors>
   <mvc:interceptor>
       <!--/** 包括路径及其子路径-->
       <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
       <!--/admin/** 拦截的是/admin/下的所有-->
       <mvc:mapping path="/**"/>
       <!--bean配置的就是拦截器-->
       <bean class="com.kuang.interceptor.MyInterceptor"/>
   </mvc:interceptor>
</mvc:interceptors>

5.编写一个controller，接受请求

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

//测试拦截器的控制器
@Controller
public class InterceptorController {

   @RequestMapping("/interceptor")
   @ResponseBody
   public String testFunction() {
       System.out.println("控制器中的方法执行了");
       return "hello";
  }
}

6.jsp

<a href="${pageContext.request.contextPath}/interceptor">拦截器测试</a>

7.测试

2.拦截器实战（认证用户）

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

public class LoginInterceptor implements HandlerInterceptor {

   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
       // 如果是登陆页面则放行
       System.out.println("uri: " + request.getRequestURI());
       if (request.getRequestURI().contains("login")) {
           return true;
      }

       HttpSession session = request.getSession();

       // 如果用户已登陆也放行
       if(session.getAttribute("user") != null) {
           return true;
      }

       // 用户没有登陆跳转到登陆页面
       request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
       return false;
  }

   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

  }
   
   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

  }
}

3.文件上传和下载

准备工作

文件上传是项目开发中最常见的功能之一 ,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

【注意！！！这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误！在这里栽过坑,教训！】

<!--文件上传配置-->
<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";
  }
}

5、测试上传文件，OK！

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

1、编写Controller

/*
* 采用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";
}

2、前端表单提交地址修改

3、访问提交测试，OK！

文件下载

文件下载步骤：

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>

测试，文件下载OK，大家可以和我们之前学习的JavaWeb原生的方式对比一下，就可以知道这个便捷多了!

结构化思维wz
关注
  • 7
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
狂神说springmvc笔记.zip
02-18
狂神说springmvc笔记.zip
狂神JAVA笔记--入门篇
weixin_48577398的博客
04-13 2001
写在前面 1，讲解视频 狂神的JAVA视频课！！！！强推 2，配套笔记 配套笔记我会持续在CSDN上进行更新 一，JAVA预科阶段 1-1，论博客的重要性 1.需要总结和思考。有时候我们一直再赶路，却忘了放慢脚步 2.提升文笔组织能力 3.提升学习总结能力 4.提升逻辑思维能力 5.帮助他人，结交朋友 冰冻三尺非一日之寒，写博客也是，短期内可能看不到效果，但是长期坚持，对自己的提升很有帮助 狂神说 Markdown语法：标题：#，字体：适当的快捷键，分割线：—/***，图片：[外链图片转存失败
狂神javaweb笔记（学习笔记）
weixin_56555958的博客
02-07 533
在java中，动态web资源开发的奇数童虫为javawebweb应用程序：可以提供浏览器访问的程序；web应用程序编写完毕后，若想提供给外界访问：需要一个服务器来统一管理；页面会动态展示：web展示的效果因人而异：千人千面。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R4niJ8Sv-1675761451041)(javaweb.assets/image-20221105153123616.png)]缺点：优点：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直
狂神SpringMVC学习笔记
博客
03-01 454
Spring MVC框架就是一种MVC框架。其前端控制器是DispatcherServlet主要用于控制流程；应用控制器为Handler Mapping-处理器映射器进行处理器管理和View Resolver-视图解析器进行视图的解析；页面控制器/动作跳转处理器为Controller接口；支持本地化解析、文件上传等；提供了十分灵活的数据校验、格式化和数据绑定机制；采用约定优于配置的契约式编程方式。
狂神说SpringMVC 最全学习笔记
m0_60811835的博客
02-04 258
**Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返
SpringMvc入门
01-16
SpringMVC入门文档，可做快速入门了解，有助于理解整体架构，如果工作需要只是简单了解使用，则足够，如果事要深入学习，建议去看视频之类的学习路径
springMVC入门教程
12-07
适合新手自学入门，Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构， 可以选择是使用内置的 Spring Web 框架还是 Struts 这样的 Web 框架。
springMvc_SpringMvc入门_
09-30
springMvc框架入门 可以接收浏览器请求 回调页面展示
springMVC快速入门基础代码
06-20
这个是基于ideaj2017springmvc还有hibernet的基本代码，增删改查显示等等
SpringMVC基础
05-15
SpringMVC基础
SpringMVC狂神说最全笔记
01-29
根据SpringMVC狂神说公众号做的笔记，把他做成了md方便大家阅读
狂神说笔记大全.rar
11-25
狂神的笔记
狂神说全部笔记内容.zip
08-26
笔记自我备份笔记自我备份笔记自我备份笔记自我备份
【狂神说Java】Java基础详细笔记(全)
Martin-share的博客
01-06 6270
狂神说Java之Java基础-程序运行机制-基础语法-流程控制-方法-数组-面向对象-异常
狂神JavaWeb课程笔记
qq_41607196的博客
05-10 2226
笔记注释 该笔记主要目的是接触和了解javaweb的基本概念，狂神的课程后面的项目没有细看，项目部分的笔记参考了网络的一些帖子。 值得一提 的是本人在学习javaweb时用的是idea社区版，在一些部分和狂神课程中的操作不同，解决了一些版本不同存在的坑，一些操作差异本文也都给出了演示，并且实现了相同的功能。 本笔记主要为了记录自己的学习文档，存在很多不足，也欢迎大家一起交流，但是新手起步，清温柔以待。 1.web的基本概念 1.1前言 web开发： web，网页的意思 静态web html、css
学习笔记（狂神SpringBoot全部笔记含--源码--及员工管理系统整合数据库版）
福波斯_阿波罗
12-31 3926
学习笔记（狂神SpringBoot全部笔记及员工管理系统整合数据库版）
狂神说SpringMVC课堂笔记
sebeefe的博客
03-10 178
文章目录 SpringMVC 1、回顾MVC 1.1、什么是MVC 1.2、Model1时代 1.3、Model2时代 1.4、回顾Servlet 2、什么是SpringMVC 2.1、概述 2.2、中心控制器 2.3、SpringMVC执行原理 3、第一个MVC程序 3.1、配置版 3.2、注解版 小结 4、RestFul和控制器 4.1、控制器Controller 4.2、实现Controller接口 使用注解@Controller RequestMapping Res
遇见狂神说 Spring MVC 学习笔记（完整笔记+代码）
最新发布
记录一名在读研究生的学习笔记、感悟、开发产物
01-08 719
狂神课程 Spring MVC 完整学习笔记（附详细代码和操作）
SpringMVC狂神完整笔记
weixin_43841182的博客
07-28 752
狂神说SpringMVC视频链接： B站视频 狂神公众号链接： 公众号 1. 什么是SpringMVC 1.1 回顾MVC 1.1.1 什么是MVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。 是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向偶合。 MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。 **Model（模型）：**数据模型，提供要展示的数据，因此包含数据和行为，可
springMVC入门编写
05-04
SpringMVC是一个基于Java的Web框架，可以帮助我们快速地构建Web应用程序。下面是一个简单的SpringMVC入门示例，让你了解如何编写一个...以上就是一个简单的SpringMVC入门示例，希望能帮助你快速入门SpringMVC框架。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

结构化思维wz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值