Spring MVC框架学习笔记总结(二)

xupengboo

已于 2022-03-03 19:58:44 修改

阅读量920

点赞数

分类专栏： Java 文章标签： mvc spring springmvc java ssm

于 2022-02-21 14:35:38 首次发布

本文链接：https://blog.csdn.net/IT_Holmes/article/details/123031498

版权

Java 专栏收录该内容

61 篇文章 123 订阅

订阅专栏

文章目录

1. SpringMVC的控制器controller配置
2. 什么是RestFul风格？
3. RestFul 风格(几乎所有网站都在使用)
4. SpringMVC的结果跳转方式
5. 后台接受请求参数
- 5.1 请求参数的获取和返回
- 5.2 接受一个对象形式的请求参数
6. 数据回显(数据显示到前端)
7. SpringMVC 乱码问题解决

1. SpringMVC的控制器controller配置

1.1 什么是控制器Controller？

这里的控制器我们就可以一个控制器就是一个servlet。

控制器的作用就是负责解析用户的请求并将其转换为一个模型，返回给视图解析器。

控制器通常是接口定义或注解定义两种方法实现。

1.2 控制器接口实现(麻烦，不推荐)

第一步：实现Controller接口类。
在这里插入图片描述

ControllerTest01实现了Controller接口，那么ControllerTest01就是一个控制器：

package com.itholmes.controller;

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

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

public class ControllerTest01 implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();
        //往mv中添加对象。
        mv.addObject("msg","controller_interface");
        //设置view的名字，就对应了WEB-INF/jsp/test.jsp页面。
        mv.setViewName("test");
        return mv;
    }
}

第二步：去Spring配置文件中注册请求的bean，name对应请求路径，class对应处理请求的类。

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

    <context:component-scan base-package="com.itholmes.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--注意：/WEB-INF/jsp/ 后面必须要有 / 不然报404的！！-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--对于接口实现，上面除了视图解析器，其他三个都不需要显示的来配置出来。-->
    <bean name="/t" class="com.itholmes.controller.ControllerTest01"/>

</beans>

第三步：配置tomcat运行测试。
在这里插入图片描述

接口实现的缺点：

实现接口Controller定义控制器是较老的办法。
一个严重的缺点就是一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller，定义起来非常麻烦。

1.3 控制器注解@Controller实现(推荐使用！)

下面的四个注解，作用几乎是共同的，用来被扫描(Spring的扫描机制)，只不过对应不同的架构层而已：
在这里插入图片描述

@Controller注解类型：用于声明Spring类的实例是一个控制器。
在这里插入图片描述

创建一个使用ControllerTest02使用注解来实现的控制器：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/*
    被@Controller注解的类代表这个类会被spring接管。
    如果，该类方法的返回值是String，并且由具体页面可以跳转，那么就会被视图解析器解析。
 */
@Controller
public class ControllerTest02 {

    @RequestMapping("/t1")
    //这里也可以用ModelAndView对象来传，只不过Model是专门用来传数据的，一般都是用Model来操作。
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest02");
        return "test";//return返回的内容就会被视图解析器来拼接解析。
    }

    @RequestMapping("/t2")
    //这里也可以用ModelAndView对象来传，只不过Model是专门用来传数据的，一般都是用Model来操作。
    public String test2(Model model){
        model.addAttribute("msg","ControllerTest02");
        return "test";//return返回的内容就会被视图解析器来拼接解析。
    }

    @RequestMapping("/t3")
    //这里也可以用ModelAndView对象来传，只不过Model是专门用来传数据的，一般都是用Model来操作。
    public String test3(Model model){
        model.addAttribute("msg","ControllerTest02");
        return "test";//return返回的内容就会被视图解析器来拼接解析。
    }
	
	//这样我们无论访问t1,t2,t3最终访问都是test.jsp，这就和接口实现的控制器的缺点形成对比，如果是接口实现的控制器，就得写三个实现controller接口的控制器。

}

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

    <context:component-scan base-package="com.itholmes.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--注意：/WEB-INF/jsp/ 后面必须要有 / 不然报404的！！-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

完成上面，就可以发布tomcat进行测试了。

1.4 @RequestMapping详解

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

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("ControllerTest03")
public class ControllerTest03 {

    @RequestMapping("t1")
    public String test01(Model model){
        model.addAttribute("msg","test01");
        return "test";
    }

    @RequestMapping("t2")
    public String test02(Model model){
        model.addAttribute("msg","test02");
        return "test";
    }

}

就跟上面代码一样访问的路径就变成了下图方式：
在这里插入图片描述

2. 什么是RestFul风格？

在这里插入图片描述

RestFul就是通过不同的请求方式来实现不同的效果：
在这里插入图片描述

3. RestFul 风格(几乎所有网站都在使用)

3.1 一般通过？和 & 再url拼接参数

写一个控制器类，RestFulController类：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {

    @RequestMapping("/add")
    public String test1(int a, int b, Model model){
        int res = a+b;
        model.addAttribute("msg","结果为："+res);
        return "test";
    }

}

然后我们访问/add路径，发现报错，因为没有传参数。
在这里插入图片描述
我们可以通过传统方式来传参数：

3.2 RestFul风格代码实现

接下来我们通过RestFul风格来实现：

@PathVariable注解：让方法参数的值对应绑定到一个URI模板变量上。
这样前端先将url传过来，例如：/add/10/20 ，然后@PathVariable注解回按照后台定义的格式/add/{参数1}/{参数2}来给参数1和参数2赋值。

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {

    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","result:"+res);
        return "test";
    }

}

这样RestFul风格就体现出来了。
在这里插入图片描述
我们在通过传统方式传参就会报404了。

注意事项：当我们发送的参数类型和后台类型不对应时，就会报400的错误。
在这里插入图片描述

3.3 RequestMapping源码中的RequestMethod的作用

用RequestMethod的method，我们可以指定要用什么类型方法来接收。
在这里插入图片描述
而这个RequestMethod源码里就是一个枚举类。

因此我们可以设定只接收什么类型，就像下面代码我只接受delete类型：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RestFulController {
	//RequestMapping的原来来对应的赋值。
	//下面就仅仅对应了delete，也就只接受delete类型的方法。
    @RequestMapping(value="/add/{a}/{b}",method = RequestMethod.DELETE)
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","result:"+res);
        return "test";
    }

}

在这里插入图片描述

自然如果我们改成GET类型就能接受了：
在这里插入图片描述

3.4 @GetMapping注解等类型注解

对于类型设置的注解，我们可以直接使用@GetMapping注解:

@GetMapping("/add/{a}/{b}")就等价于@RequestMapping(value="/add/{a}/{b}",method = RequestMethod.GET)
同理也有其他的@PostMapping,@PutMapping,@DeleteMapping等等注解。

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RestFulController {

    //@RequestMapping(value="/add/{a}/{b}",method = RequestMethod.GET)
    //这里的@GetMapping("/add/{a}/{b}")就等价于上面这段代码。
    @GetMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","result:"+res);
        return "test";
    }

}

我们可以在相同的url下面，接受不同的请求：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

@Controller
public class RestFulController {

    //我们就可以通过@GetMapping或@PostMapping来分类型来接受了。
    @GetMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","result_get:"+res);
        return "test";
    }

    @PostMapping("/add/{a}/{b}")
    public String test2(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","result_post:"+res);
        return "test";
    }

}

写一个jsp来测试post方法的接受：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<!--因为是按照url来接受参数，为了方便测试，我直接用url来传参数。-->
    <form action="/add/10/20" method="post">
        <input type="submit" value="submit">
    </form>
</body>
</html>

在这里插入图片描述

通过上面的操作就可以体现出RestFul风格可以通过不同的请求方式来实现不同的效果！
在这里插入图片描述

3.5 Ambiguous(模棱两可)

记住这个单词Ambiguous英文意思是模棱两可的意思。

如果报错有这个Ambiguous单词，第一时间想到，就是我们后台写的代码处理相同类型有两个方法能处理。

例如：前台传送get请求，而后台有两个@GetMapping或@RequestMapping(value="/add/{a}/{b}",method = RequestMethod.GET)来接受，这样代码就不知道选择哪一个了。
在这里插入图片描述

3.6 RestFul风格优点

优点：

简洁(写法简单)
高效(支持缓存)
安全(让使用者无法知道参数啥的)

4. SpringMVC的结果跳转方式

4.1 ModelAndView的作用

ModelAndView对象的作用：
在这里插入图片描述

4.2 原生Servlet的请求转发或重定向

在我们的原生的Servlet中，是通过request接受参数，response来返回参数或者请求转发重定向的。

在这里插入图片描述
原生servlet的请求转发或重定向如下：

4.3 Spring MVC的请求转发和重定向

SpringMVC的底层原理也是用的Servlet，因此也可以来使用request和response，接收返回参数，请求转发或重定向。

4.3.1 无需视图解析器的SpringMVC的请求转发和重定向

首先，删除或者注释掉，视图解析器。

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

    <context:component-scan base-package="com.itholmes.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

<!--将视图解析器注释掉或者删除。-->
<!--    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">-->
<!--        &lt;!&ndash;注意：/WEB-INF/jsp/ 后面必须要有 / 不然报404的！！&ndash;&gt;-->
<!--        <property name="prefix" value="/WEB-INF/jsp/"/>-->
<!--        <property name="suffix" value=".jsp"/>-->
<!--    </bean>-->
</beans>

在没有视图解析器的情况下，请求转发：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

@Controller
public class ModelTest1 {

    @RequestMapping("/m1")
    public String test(Model model){
        Model model1 = model.addAttribute("msg", "forward");
        //使用forward:来标识它是一个转发。其实不加上forward:也是转发，只不过没有视图解析器了。
        return "forward:/WEB-INF/jsp/test.jsp";
    }

}

在这里插入图片描述

在没有视图解析器的情况下，重定向：

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

@Controller
public class ModelTest1 {

    @RequestMapping("/m2")
    public String test2(Model model){
        Model model1 = model.addAttribute("msg", "redirect");
        //使用redirect:来标识它是一个重定向。
        return "redirect:/index.jsp";
    }

}

在这里插入图片描述

4.3.2 有视图解析器的SpringMVC的请求转发和重定向

先将视图解析器配置好。

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

    <context:component-scan base-package="com.itholmes.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--注意：/WEB-INF/jsp/ 后面必须要有 / 不然报404的！！-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

其实，没啥区别，有了视图解析器，那么默认就是请求转发。如果我们想让他重定向还是用redirect:来标识就可以了。

package com.itholmes.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ModelTest1 {

    @RequestMapping("/m1")
    public String test(Model model){
        Model model1 = model.addAttribute("msg", "forward");
        //有了视图解析器，默认就是请求转发的效果。
        return "test";
    }

    @RequestMapping("/m2")
    public String test2(Model model){
        Model model1 = model.addAttribute("msg", "redirect");
        //有了视图解析器，还是使用redirect:来标识它是一个重定向。
        return "redirect:/index.jsp";
    }

}

在这里插入图片描述

5. 后台接受请求参数

5.1 请求参数的获取和返回

参数和形参相同，那么参数就将值传给了形参。
(专业术语就是提交的域名称与处理方法的参数名一致的情况，就直接将域名称参数对应的值，直接传给了形参。)
在这里插入图片描述

如果参数名和形参名不同，但是我们仍然想让他们之间进行传参，可以使用@RequestParam()注解来实现。
(专业术语就是提交的域名称与处理方法的参数名不一致的情况，就通过@requestParam注解来完成实现。)
在这里插入图片描述

5.2 接受一个对象形式的请求参数

创建一个实体类User：(这里用lombok来生成结构了)

package com.itholmes.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String age;
}

前提：要求提交的表单域和对象的属性名一致，参数使用对象即可。

package com.itholmes.controller;

import com.itholmes.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/user")
public class UserController {

    /*
        1. 接受前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用。
        2. 假设传递的是一个User对象，它就会匹配User对象中的字段名。匹配成功就赋值，没有匹配到的就是默认值了。
     */

    //前端接受的是一个对象：id,name,age
    @GetMapping("/t2")
    public String test02(User user , Model model){
        System.out.println(user.toString());
        model.addAttribute("msg",user.toString());
        return "test";
    }

}

在这里插入图片描述

注意事项：如果使用对象的话，前端传递的参数名和对象名不一致的话，没有匹配到的参数就是对象代码的默认值。例如：String为null，int为0等。

6. 数据回显(数据显示到前端)

6.1 通过ModelAndView方式

下图的绿色部分就是通过ModelAndView方式来回显数据的。

ModelAndView是通过setViewName设置视图名字，该名字会通过视图解析器拼接前后缀。这里注意返回值一定是我们的ModelAndView对象！

package com.itholmes.controller;

import com.itholmes.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/user")
public class UserController {

    @GetMapping("/t3")
    public ModelAndView test03(User user , ModelAndView mv){
        mv.addObject("msg",user.toString());
        //依据mv的viewName，通过视图解析器拼接前后缀，返回对应路径的内容。
        mv.setViewName("test");
        System.out.println();
        return mv;
    }

}

在这里插入图片描述

6.2 通过ModelMap方式

在这里插入图片描述
ModelMap要比Model功能多一点(因为继承了LinkedHashMap类)，但是大多数情况下，都是用Model。

package com.itholmes.controller;

import com.itholmes.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/user")
public class UserController {

    @GetMapping("/t4")
    public String test04(ModelMap modelMap){
        modelMap.addAttribute("msg","ModelMap");
        return "test";
    }

}

在这里插入图片描述

6.3 通过Model方式(常用方式)

下图的绿色部分就是通过Mode方式来回显数据的。

model是通过return来进行视图跳转，return的内容先经过视图解析器进行前后缀拼接。

在源码上来看，这三个回显是有关联的。我们可以自己看看源码结构方面的东西等等。
在这里插入图片描述

7. SpringMVC 乱码问题解决

我们写一个fomr表单，让他的action指向我们设定好的路径，然后传中文参数，就发现乱码的情况。
在这里插入图片描述

我们不能在控制器类或者@Controller注解类的方法里面，配置HttpServletRequest或者HttpServletResponse对象的编码类型去。因为那个时候springmvc已经编译完了。

不过我们可以通过过滤器来解决。

第一种方式，我们自己设置过滤器，通过filter过滤器来配置HttpServletRequest或者HttpServletResponse对象(过滤器中可能是它们的子类ServletRequest或者ServletResponse)：

在filter层，声明一个过滤类EncodingFilter类：

package com.itholmes.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter("*")
public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain dochain) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        dochain.doFilter(req,resp);
    }

    @Override
    public void destroy() {

    }
}

在这里插入图片描述

第二种方式，SpringMVC给我们提供了一个过滤器，我们可以在web.xml中配置就可以了。(注意：修改了web.xml文件，就必须要重启服务器)

这里有个坑，就是 / 和 /* 匹配到的东西是不一样的，像post请求，我们一般使用 /* 的！！因为，/ 只能匹配url路径，而 /* 能匹配所有的东西包括页面。
有些人以为问什么get请求发送的参数，能用 / 匹配到，因为get请求的参数就加到了url路径的后面。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <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>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--配置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路径。
               “/*”：可以匹配路径和页面所有的请求。
        -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

配置了上面的乱码情况，还有乱码就有可能是下面情况：

就有可能时tomcat配置上是别的编码格式，去tomcat的server.xml查看。
也有有可能是客户端有乱码情况，因此也要看客户端乱码。
还有可能是你的idea，不是UTF-8 的格式，idea很智能，要配置三个地方为utf-8才可以。

最后补充，注解驱动乱码解决：（一般是后台往前台发汉字为？？乱码了）

<mvc:annotation-driven>
    <mvc:message-converters>
        <!-- 处理响应中文内容乱码 -->
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <property name="defaultCharset" value="UTF-8" />
            <property name="supportedMediaTypes">
                <list>
                    <value>text/html</value>
                    <value>application/json</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

web.xml配置的乱码问题，注意顺序问题！最好乱码过滤放到前端控制器前！！

我之前配置了一个过滤器，但是过滤器和springmvc是同级别的，请求先经过过滤器因为前端发的是utf-8，过滤器也是utf-8，但是走完过滤器再走springmvc的时候，springmvc却不是使用utf-8来解析的，因此经常遇到乱码！！！

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <!--乱码过滤-->
  <filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!--配置前端控制器-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:ApplicationContext.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!--Session-->
  <session-config>
    <!--设置session会话时间为15分钟-->
    <session-timeout>15</session-timeout>
  </session-config>

</web-app>

xupengboo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring MVC框架学习笔记总结(二)

1. SpringMVC的控制器controller配置2. 什么是RestFul风格？3. RestFul 风格(几乎所有网站都在使用)4. SpringMVC的结果跳转方式5. 后台接受请求参数5.1 请求参数的获取和返回5.2 接受一个对象形式的请求参数6. 数据回显(数据显示到前端)6.1 通过ModelAndView方式6.2 通过ModelMap方式6.3 通过Model方式(常用方式)7. SpringMVC 乱码问题解决
复制链接

扫一扫