SpringMVC

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量129 收藏 2
点赞数
分类专栏： 笔记 文章标签： servlet java mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53323393/article/details/125957714
版权

SpringMVC

1、什么是MVC

  • MVC是模型（Model）、视图（View）、控制器（Controller）的简写，是一种软件设计的规范。

  • 将业务逻辑，数据显示分离的方法来组织代码

  • MVC主要作用是降低视图与业务逻辑间的双向耦合

  • MVC是一种架构模式

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），现在都分离开：Value Object（数据Dao）和服务层（行为Service），包括数据和业务。

前端 数据传输 实体类 三者所需实体类不同会将pojo进一步细分（vo，dto）

View（视图）：负责进行模型的展示。用户界面

Controller（控制器）：接收用户请求，委托给模型处理（状态改变），处理完毕后把返回的模型数据返回给视图。控制器做了个调度员的工作

典型的MVC就是JSP+servlet+javabean的模式

1.1、Model1时代

主要分为两层，视图层和模型层

在这里插入图片描述

在JSP页面做逻辑判断调用业务逻辑方法

JSP职责不单一，不便于维护

1.2、Model2时代

主要分为三层，视图 控制 模型

在这里插入图片描述

面试题：项目的架构是演进的

  1. 用户发起请求
  2. Servlet接收请求数据，并调用业务逻辑方法
  3. 业务处理完成，返回更新后的数据给servlet
  4. servlet转向到JSP，由JSP来渲染页面
  5. 响应给前端更新后的页面

职责分析：

controller：控制器

  1. 获取表单数据
  2. 调用业务逻辑
  3. 转向指定页面

Model：模型

  1. 业务逻辑
  2. 保存数据状态

View：视图

  1. 显示页面

2、什么是SpringMVC

Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。

2.1、中心控制器

SpringMVC以DispatcherServlet为核心，负责协调和组织不同组件以完成请求处理并返回响应的工作，实现了MVC模式。

Spring MVC框架以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet实际是一个Servlet(它继承自HttpServlet基类)。

在这里插入图片描述

DispatcherServlet的作用是将请求分发到不同的处理器

在这里插入图片描述

3、SpringMVC配置流程

  1. 新建Moulde，添加web支持
  2. 导入SpringMVC的依赖
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.15</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

    </dependencies>
  • 由于Maven可能存在资源过滤的问题，我们将配置完善
<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
       <resource>
           <directory>src/main/resources</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
   </resources>
</build>
  1. 配置web.xml
  • 注册DispatcherServlet
  • 关联springmvc配置文件
  • 匹配请求
<?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">

    <!--注册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>
  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"
       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"/>

    <!--视图解析器: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>

</beans>
  1. 编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图；

package com.kuang.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

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

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
       //ModelAndView 模型和视图
       ModelAndView mv = new ModelAndView();

       //封装对象，放在ModelAndView中。Model
       mv.addObject("msg","HelloSpringMVC!");
       //封装要跳转的视图，放在ModelAndView中
       mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
       return mv;
  }
   
}

  1. 在springmvc配置文件（springmvc-servlet.xml）中将操作业务的Controller类交给SpringIOC容器，注册bean。

    （BeanNameUrlHandlerMapping这个处理器需要写bean）

<!--Handler-->
<bean id="/hello" class="com.kuang.controller.HelloController"/>
  1. 编写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>sunshine</title>
</head>
<body>
${msg}
</body>
</html>
  1. 可能遇到的问题：访问出现404，步骤：

  • 查看是否缺少jar包

  • 在IDEA的项目发布中添加lib目录，将依赖导入。

3.1、注解版

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"
       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.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包，让包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.xiong.controller"/>

    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
    支持MVC注解驱动
        在Spring中一般采用@RequestMapping注解来完成映射关系
        要想使用@RequestMapping注解生效
        必须向上下文注册DefaultAnnotationHandlerMapping
        和AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理
        而annotation-driven配置帮我们自动完成上述两个实例的注入
    -->
    <mvc:annotation-driven/>


    <!--视图解析器: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>

</beans>

编写Controller

@Controller
 @RequestMapping("/controller")
public class HelloController{

    @RequestMapping("/hello")
    public String Hello(Model model){
        //封装数据
        model.addAttribute("msg","HelloSpringMVCAnnotation");
        //通过视图解析器处理
        return "hello";
    }

}
  • @Controller是为了让Spring IOC容器初始化时自动扫描到；
  • @RequestMapping是为了映射请求路径，这里类和方法上都存在映射路径，所以访问时应该为/controller/hello;
  • 方法中声明Model类型的参数是为了把Action中的数据带到视图中;

4、SpringMVC执行原理

  1. DispatcherServlet 表示前置控制器，是整个SpringMVC的控制中心
  • 用户发出请求，DispatcherServlet接收并拦截请求
    • url: https://loaclhost:8080/SprongMVC/hello
    • 将url分为三部分：
      • https://localhost:8080服务器域名
      • SpringMVC部署在服务器上的站点
      • hello表示控制器

根据url将请求位于服务器localhost:8080上的SpringMVC站点的hello控制器

  1. DispatcherServlet 调用处理器映射HandlerMapping
    • HandlerMapping根据url请求寻找对应的Handler
  2. HandlerExecution 表示具体的Handler
    • 主要作用式根据url查找对应的控制器
  3. HandlerExecution 将信息解析后传递给DispatcherServlet
    • 如，传递解析控制器映射
  4. HandlerAdapter 处理器适配器，按照特定的规则执行Handler
  5. Handler让特定的Controller执行
  6. Controller将具体的执行信息（MouldAndView）返回给HandlerAdapter
  7. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet
  8. DispatcherServlet调用视图解析器（ViewResolver）来解析HandlerAdapter传递的视图逻辑名
  9. 视图解析器将解析后的视图逻辑名传回给DispatcherServlet
  10. DispatcherServlet根据解析的视图结果调用具体的视图
  11. 最终将对应视图呈现给用户

在这里插入图片描述

2.1、总结

  1. 用户发起请求通过前端控制器（DispatcherServlet ）
  2. 根据请求找到映射器（HandlerMapping），将映射器返回（HandlerExecution ）
  3. 根据映射器适配映射器（HandlerAdapter），适配到的映射器就是一个controller，之后由具体的controller执行，返回一个MouldAndView
  4. 通过MouldAndView配置具体的视图解析器（ViewResolver）

5、RestFul风格

通过不同的请求方式实现不同的效果

@Controller
public class RestFulController {

    //http://localhost:8080/add?a=1&b=2
    @RequestMapping("/add")
    public String test1(int a,int b, Model model){

        int result = a+b;
        model.addAttribute("msg","结果为"+result);

        return "test";
    }


    //RestFUL风格
    //http://localhost:8080/add/1/2
    //@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.DELETE)
    @GetMapping("/add/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable int b, Model model){

        int result = a+b;
        model.addAttribute("msg","结果为"+result);

        return "test";
    }

    @PostMapping("/add/{a}/{b}")
    public String test3(@PathVariable int a,@PathVariable int b, Model model){

        int result = a+b;
        model.addAttribute("msg","结果为"+result);

        return "test";
    }
}

6、SpringMVC结果跳转方式

6.1、ModelAndView

设置ModelAndView对象，根据view名称，视图解析器跳转到指定页面。- - - 需要视图解析器

页面：（视图解析器前缀）+ viewName +（视图解析器后缀）

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg","HelloSpringMVC");

        modelAndView.setViewName("hello");

        return modelAndView;
    }
}

6.2、SpringMVC

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

@Controller
public class ModuleTest {

    @RequestMapping("/m1/t1")
    public String test1(Model model){

        model.addAttribute("msg","HelloModuleTest");
        //转发
        return "forward:/WEB-INF/jsp/test.jsp";
    }

    @RequestMapping("/m1/t2")
    public String test2(Model model){

        model.addAttribute("msg","HelloModuleTest");
        //重定向
        return "redirect:/WEB-INF/jsp/test.jsp";
    }
}

7、数据处理

7.1、处理提交数据

  1. 提交的域名和处理方法参数名一致
//http://localhost:8080/user/t1?name=sunshine
    @RequestMapping("/user/t1")
    public String test1(String name, Model model){
        //接收前端参数
        System.out.println(name);
        //结果返回前端
        model.addAttribute("msg",name);
        return "test";
    }
  1. 提交的域名和处理方法参数名不一致
//http://localhost:8080/user/t1?username=sunshine
    @RequestMapping("/user/t1")
    public String test1(@RequestParam("username") String name, Model model){
        //接收前端参数
        System.out.println(name);

        //结果返回前端
        model.addAttribute("msg",name);

        return "test";
    }
  1. 提交的是一个对象
//http://localhost:8080/user/t2?id=1&name=sun&age=12
    //前端接收一个对象
    @RequestMapping("/user/t2")
    public String test2(User user){
        //接收前端参数
        System.out.println(user);

        return "test";
    }

7.2、数据显示

  1. 通过ModelAndView，将数据显示到前端
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg","HelloSpringMVC");

        modelAndView.setViewName("hello");

        return modelAndView;
    }
}
  1. 通过ModelMap，将数据显示到前端
@RequestMapping("/t2")
    public String Test2(ModelMap modelMap){
  modelMap.addAttribute("msg","HelloControllerTest03");
        return "test";
    }
  1. 通过Model，将数据显示到前端
@RequestMapping("/t1")
    public String Test1(Model model){
  model.addAttribute("msg","HelloControllerTest03");
        return "test";
    }

区别：

Model：方法少，适合存储数据，简化了对Model对象的理解和操作；

ModelMap：继承了LinkedHashMap，故拥有LinkedHashMap的全部功能；

ModelAndView：在可以存储数据的同时，可以设置返回的逻辑视图；

8、乱码问题

  • 使用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>
</web-app>
  • 使用自定义过滤器
  1. 修改tomcat配置文件 ：设置编码！
<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />
  1. 自定义过滤器
package com.xiong.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 对request包装增强
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
  }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
  }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否编码的标记
   private boolean hasEncode;
   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
   public MyRequest(HttpServletRequest request) {
       super(request);// super必须写
       this.request = request;
  }

   // 对需要增强方法 进行覆盖
   @Override
   public Map getParameterMap() {
       // 先获得请求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post请求
           try {
               // 处理post乱码
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
          } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
          }
      } else if (method.equalsIgnoreCase("get")) {
           // get请求
           Map<String, String[]> parameterMap = request.getParameterMap();
           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 处理get乱码
                               values[i] = new String(values[i]
                                      .getBytes("ISO-8859-1"), "utf-8");
                          } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                          }
                      }
                  }
              }
               hasEncode = true;
          }
           return parameterMap;
      }
       return super.getParameterMap();
  }

   //取一个值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回参数的第一个值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

9、JSON

9.1、什么是JSON

  • Json是一种轻量级的数据交换格式；

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

  • 易于编写，易于机器解析，提高网络传输的效率；

9.2、Controller返回JSON数据

  1. 导入json依赖
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.0</version>
</dependency>
  1. 原生代码
@RequestMapping("/j1")
@ResponseBody//他不会走视图解析器，会直接返回字符串
/*
在类上使用@RestController
	会使其下面所有方法均返回字符串
*/
 
public String json1(){
    User user = new User("sun",3,"男");
    return user.toString();
}
  1. 使用Jackson解析工具
//这里可以使用produces参数来解决乱码问题
@RequestMapping(value = "/j2",produces = "application/json;charset=utf-8")
@ResponseBody
public String json2() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    User user = new User("sun",3,"男");

    String s = mapper.writeValueAsString(user);

    return s;
}

josn乱码统一解决

<!--JSON乱码问题配置-->
<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>

10、拦截器

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

过滤器：

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

拦截器：

  • 拦截器只是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
  • 拦截器只会拦截访问的控制器方法，若访问静态资源（jsp/html/css）是不会拦截的

10.1、自定义拦截器

  1. 拦截器必须实现 HandlerInterceptor 接口
public class MyInterceptor implements HandlerInterceptor {


    //return true; 执行下一个拦截器
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("处理前");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("处理后");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("清理");
    }
}
  1. 在配置文件中配置拦截器
<mvc:interceptors>
    <mvc:interceptor>
        <!--/** 包括这个请求下面的所有请求-->
        <mvc:mapping path="/**"/>
        <bean class="com.xiong.config.MyInterceptor"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <!--/** 包括这个请求下面的所有请求-->
        <mvc:mapping path="/user/**"/>
        <bean class="com.xiong.config.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

11、文件上传和下载

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

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

  • application/x-www=form-urlencoded：默认方式，只处理表单域中的value属性值，采用这种编码方式的表单会将表单域中的值处理成URL编码方式；
  • multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求的参数中，不会对字符编码；
  • text/plain：除了将空格转化为 “+” 号外，其他字符都不会做编码处理，这种方式适用直接通过表单发送邮件；
  1. 导入相关依赖
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
  1. 配置bean：multipartResolver

这个bean的id必须为：multipartResolver，否则文件上传会报400的错误

<context:component-scan base-package="com.xiong.controller"/>

<!--静态资源过滤-->
<mvc:default-servlet-handler/>

<!--JSON乱码问题配置-->
<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>

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


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

CommonsMultipartResolver的常用方法：

  • String getOriginaIFilename();获取上传文件名
  • InputStream getInputStream();和获取文件流
  • void transferTo(File dest);将上传文件保存到一个目录中
  1. 编写前端页面
  <form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
    <input type="file" name="file">
    <input type="submit" value="upload">
  </form>
  1. 编写Controller层
package com.xiong.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";
    }



    @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";
    }
}

ileOutputStream(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";
}



@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";
}

}
阳光就在天上
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC篇
qq_46423017的博客
10-28 1303
1、SpringMVC的工作流程（重点） 2、SpringMVC的主要组件 3、什么是SpringMVC？简单介绍下你对SpringMVC的理解 4、SpringMVC的优点 5、SpringMVC常用的注解 6、SpringMVC怎么设定重定向和转发的 7、SpringMVC和Struts2的区别有哪些？ 8、如何解决POST请求中文乱码问题? 9、GET请求乱码怎么解决 10、springMVC里面拦截器是怎么写？ 11、SpringMvc的控制器是不是单例模式，如果是，有什么问题，怎么解决？
springMVC介绍
qq_45796208的博客
01-16 2526
springMVC简介 springMVC又 叫Spring web mvc。是Spring框架中的一部分，是Spring3.0后发布的。 SpringMVC框架的优点 1、基于MVC架构模式：MVC架构模式 2、容易理解上手快，使用简单：可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的框架，jar包很小，不依赖特定的接口和类。 3、作为Spring的一部分，能够使用Spring框架的IOC容器和Aop编程。方便整合Strtus、MyBatis、Hibernate、JPA等
SpringMVC常见面试题总结（超详细回答）
热门推荐
张维鹏的博客
07-08 57万+
1、什么是Spring MVC ？简单介绍下你对springMVC的理解? SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。 2、SpringMVC的流程？ （1）用户发送请...
SpringMVC框架介绍
You’re a wanderer just like me
09-19 14万+
史上最全最强SpringMVC详细示例实战教程 SpringMVC学习笔记---- 一、SpringMVC基础入门，创建一个HelloWorld程序 1.首先，导入SpringMVC需要的jar包。 2.添加Web.xml配置文件中关于SpringMVC的配置 springmvc org.springframework.web.servlet.Dispatche...
SpringMvc
qq_45009608的博客
06-08 697
SpringMVC是一种基于Java实现MVC模型的轻量级Web框架（代替JavaWeb的表现层Servlet) 优点1.创建Maven项目 2.补全目录结构 3.导入jar包 将pom.xml中多余的内容删除掉，再添加SpringMVC需要的依赖 4.创建配置类 5.创建Controller类 6.使用配置类替换web.xml 将web.xml删除，换成ServletContainersInitConfig web.xml是管理servlet的 7.配置Tomcat环境 注意事项 Spri
SpringMVC简介
sssxlxwbwz的博客
03-26 2137
一、MVC简介 MVC是一种软件架构地思想，将软件按照模型(Model)、视图(View)、控制器(Control)来划分。
SpringMVC的数据请求
楠黎倾风的博客
12-27 3万+
SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。//将日期字符串转换成日期对象 返回 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");try {} }}
springmvc详解
刘豪豪的博客
07-19 2070
说完spring，那么来说下springmvc，还是什么是springmvc？ springmvc是spring框架的一个模块，基于 MVC 的一个框架，springmvc和spring无需通过中间整合层进行整合。 springmvc是一个基于mvc的web框架。 springmvc 表现层：方便前后端数据的传输 Spring MVC 拥有控制器，作用跟Struts类似，接收外部请求，解析参数传给服务层 MVC是指，C控制层，M模块层，V显示层这样的设计理念，而SSM框架里面SPRING MVC本身就是MV
【SpringMVC】| SpringMVC 入门
m0_61933976的博客
04-25 3296
【SpringMVC】| SpringMVC 入门
SpringMVC demo 完整源码实例下载
05-02
SpringMVC是一款强大的Java web开发框架，用于构建高效、可维护的Web应用程序。在这个"SpringMVC demo 完整源码实例下载"中，我们能够深入理解并学习SpringMVC的核心概念和实际应用。 首先，SpringMVC是Spring框架...
springmvc思维导图
07-25
springmvc的概念、springmvc的运行原理（前端控制器、处理器映射器、处理器适配器、处理器、视图解析器）、同步请求的方式（ModelAndView、String、无返回值、默认的绑定值）、异步请求的注解、请求参数的封装（简单...
springMVC学习
03-11
SpringMVC 学习指南 SpringMVC 是 Spring 框架中的一个 web 组件，它提供了丰富的功能来构建稳健的 web 应用。 SpringMVC 的核心思想是基于每个逻辑和功能是高可配置的架构和设计的。下面是 SpringMVC 的学习指南：...
SpringMVC实战
04-04
SpringMVC是Spring框架的一部分，专门用于构建Web应用程序。它是一个模型-视图-控制器（MVC）架构的实现，提供了强大的数据绑定、验证、国际化等功能，极大地简化了Java Web开发。下面我们将深入探讨SpringMVC的核心...
java学习----递归
qq_56798493的博客
07-13 162
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 787
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 626
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 866
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
SpringMVC详解与快速入门
"SpringMVC学习笔记" SpringMVC是一个基于Java的轻量级Web框架，遵循MVC（Model-View-Controller）设计模式，用于构建高效、可维护的Web应用程序。作为Spring Framework的一部分，它已经集成到Spring Web Flow中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值