SpringMVC-框架学习

最新推荐文章于 2024-06-30 20:34:05 发布
最新推荐文章于 2024-06-30 20:34:05 发布
阅读量246 收藏
点赞数 1
分类专栏： 笔记 文章标签： spring java 后端 maven mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53410332/article/details/121375572
版权

1、SpringMVC-第一天

1.1、什么是MVC

  1. Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。

  2. MVC 设计模式一般指 MVC 框架，M（Model）指数据模型层，V（View）指视图层，C（Controller）指控制层。使用 MVC 的目的是将 M 和 V 的实现代码分离，使同一个程序可以有不同的表现形式。其中，View 的定义比较清晰，就是用户界面。

  • 视图层（View-jsp）：负责格式化数据并把它们呈现给用户，包括数据展示、用户交互、数据验证、界面设计等功能。
  • 控制层（Controller-servlet）：负责接收并转发请求，对请求进行处理后，指定视图并将响应结果发送给客户端。
  • 数据模型层（Model-dao/service）：模型对象拥有最多的处理任务，是应用程序的主体部分，它负责数据逻辑（业务规则）的处理和实现数据操作（即在数据库中存取数据）。

  1. SUN 公司推出 JSP 技术的同时，也推出了两种 Web 应用程序的开发模式。即 JSP+JavaBean 和 Servlet+JSP+JavaBean。

    早期: JSP+JavaBean : JSP+JavaBean 中 JSP 用于处理用户请求，JavaBean 用于封装和处理数据。该模式只有视图和模型，一般把控制器的功能交给视图来实现，适合业务流程比较简单的 Web 程序。在这里插入图片描述

    现在：Servlet+JSP+JavaBean : Servlet 用于处理用户请求，JSP 用于数据显示，JavaBean 用于数据封装，适合复杂的 Web 程序。
    在这里插入图片描述

  • MVC要做的事情：
  1. 将url映射到java类或java类的方法 .
  2. 封装用户提交的数据 .
  3. 处理请求–调用相关的业务处理–封装响应数据 .
  4. 将响应的数据进行渲染 . jsp / html 等表示层数据 .

1.2、环境搭建

<!--    导入依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.19.RELEASE</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.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

  1. 创建一个子Maven项目，右击添加框架支持，选择web支持

  2. 创建servlet test

    public class helloservlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、获取前端参数
        String method = req.getParameter("method");
        //2、调用业务层
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }

        //3、视图转发、重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);//请求转发
//        resp.sendRedirect();//重定向

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

  3. 在web.xml中注册Servlet（配置web核心配置文件）

<?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>hello</servlet-name>
        <servlet-class>com.xcong.servlet.helloservlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>


<!--    <session-config>-->
<!--        <session-timeout>超时时间</session-timeout>-->
<!--    </session-config>-->

</web-app>
  1. 配置tomca

在这里插入图片描述

访问：http://localhost:8080/hello?method=delete

error：The server encountered an internal error that prevented it from fulfilling this request.-空指针异常（因为没有传参）

1.3、什么是SpringMVC

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

优点：

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

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器（调用不同业务/方法）。

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

1.4、创建一个SpringMVC 例子

  1. 配置web.xml

    <?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">

    <!--1.注册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>
</web-app>

  2. 在resources目录下编写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>

<!--    handler-- hello.jsp">
    <bean id="/hello" class="com.xcong.controller.HelloController"></bean>
</beans>
  1. 编写controller
package com.xcong.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 HelloController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

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

4.启动Tomcat

可能出现404：找到项目结构，然后添加lib目录，将包导入，重启Tomcat即可
在这里插入图片描述

简要分析执行流程：

  1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

    我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

    如上url拆分成三部分：

    http://localhost:8080服务器域名

    SpringMVC部署在服务器上的web站点

    hello表示控制器

    通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

  2. **HandlerMapping为处理器映射。**DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

  3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

  4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

  5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

  6. Handler让具体的Controller执行。

  7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

  8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

  9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

  10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

  11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

  12. 最终视图呈现给用户。

在这里插入图片描述
在这里插入图片描述

1.5、使用注解开发SpringMVC

步骤：

  1. 搭建好maven环境（选择web项目-Tomcat配置）
  2. 配置web.xml文件
<?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">

    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <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拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>
  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
       https://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.xcong.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <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>

</beans>
  1. 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。
  2. 创建Controller
package com.xcong.controller;

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

@Controller
public class TestController {


    @RequestMapping("/test")
    public String hello(Model model){
        //封装数据   向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg","hello,this is a testSpringMVC");
        return "test";//会被视图解析器处理
    }

}
  • @Controller是为了让Spring IOC容器初始化时自动扫描到；
  • @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/test；
  • 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
  • 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/test.jsp

实现步骤其实非常的简单：

  1. 新建一个web项目
  2. 导入相关jar包
  3. 编写web.xml , 注册DispatcherServlet
  4. 编写springmvc配置文件
  5. 接下来就是去创建对应的控制类 , controller
  6. 最后完善前端视图和controller之间的对应
  7. 测试运行调试.

使用springMVC必须配置的三大件

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

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

1.6、Controller

方法一：实现Controller接口

Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；

public class TestController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msc","sdad");
        mv.setViewName("test");
        return mv;
    }
}

<bean id="/test" class="com.xcong.controller.TestController"></bean>
  • 缺点：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；

方法二：使用注解 @Controlle

  • 访问路径：http://localhost:8080 /test(前提是Tomcat配置的是根路径)

  • 实现了视图的复用，我们可以在controller里面写多个方法，只需要更改return “×××” 返回值即可（对应jsp/×××.jsp）,访问路径：http://localhost:8080 /aaa) <-(@RequestMapping("/aaa")

package com.xcong.controller;


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


@Controller
public class TestController {
    @RequestMapping("/test")
   public String test(Model model){
       model.addAttribute("msg","hello");
       return "test";
   }

}

其他注解:

@Component 组件
@Service service
@Controller controller
@Repository dao

2、SpringMVC-第二天

2.1、RestFul 风格

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

2、功能：

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

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。分别对应 添加、 删除、修改、查询。

3、传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

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

4、使用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

2.2、对比测试

  1. 新建一个类：RestFulController
  2. 在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。
package com.xcong.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 {

    //原来的：http://localhost:8080/add?a=1&b=2
    
    //RestFul风格： http://localhost:8080/add/a/b


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

  1. 使用method属性指定请求类型

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

方法一：pring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

//映射访问路径
@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
public String test1(@PathVariable int a, @PathVariable int b, Model model){
    int res=a+b;
    //Spring MVC会自动实例化一个Model对象用于向视图中传值
    model.addAttribute("msg","结果为"+res);
    //返回视图位置
    return "test";
}

方法二：直接使用对应的注解。所有的地址栏请求默认都会是 HTTP GET 类型的。

@GetMapping === @RequestMapping(method =RequestMethod.GET)
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

   //映射访问路径
//    @RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
    @GetMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","结果为"+res);
        //返回视图位置
        return "test";
    }
  1. 通过SpringMVC来实现转发和重定向 - 无需视图解析器；

测试前，需要将视图解析器注释掉

  • 默认为forward转发（也可以加上）
  • redirect转发需特别加
@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";
  }
}
  1. 通过SpringMVC来实现转发和重定向 - 有视图解析器；

​ 重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题。可以重定向到另外一个请求实现 .

  • 默认为forward转发（不可以加上）
  • redirect转发需特别加
@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.3、接收请求参数

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

请求路径：//localhost：8080/user/t1?name=×××

Restful风格：//localhost：8080/user/t1/×××

@Controller
@RequestMapping("/user")
public class UserController 
    //localhost：8080/user/t1/×××
    @GetMapping("/t1/{name}")
    public String tets1(@PathVariable String name, Model model){
        //1、接收前端参数
        System.out.println("接收到前端的参数为："+name);
        //2、将返回的结果传递给前端 使用Model
        model.addAttribute("msg",name);
        //3、跳转视图
        return "test";
    }
}

2、提交的域名称和处理方法的参数名不一致 localhost：8080/user/t1?username=×××

@Controller
@RequestMapping("/user")
public class UserController {
    //localhost：8080/user/t1?username=×××
    @GetMapping("/t1")
    public String tets1(@RequestParam("username") String name, Model model){
        //1、接收前端参数
        System.out.println("接收到前端的参数为："+name);
        //2、将返回的结果传递给前端 使用Model
        model.addAttribute("msg",name);
        //3、跳转视图
        return "test";
    }
}

3、提交的是一个对象

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

  • 粗暴方式：直接传参
//前端接收的是一个对象
//localhost:8080/user/t2?id=×××&name=×××&age=×××
@GetMapping("/t2")
public String test2(int id,String name,int age,Model model){
    model.addAttribute("msg",id);
    return "test";
}
  • 传对象：localhost:8080/user/t2?id=×××&name=×××&age=×××
//前端接收的是一个对象
//localhost:8080/user/t2?id=×××&name=×××&age=×××
@GetMapping("/t2")
public String test2(User user){
    System.out.println(user);
    return "test";
}

后台输出 : User { id=×××, name=×××, age=××× }

注意： 传递参数要和字段一样，不一样为null

2.4、数据回显

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

2、第二种 :通过Model

@GetMapping("/t2")
public String test2(int id,String name,int age,Model model){
    model.addAttribute("msg",id);
    return "test";
}

3、第三种 : 通过ModelMap

 //model map
    @GetMapping("/t3")
    public String test3(@RequestParam("username") String name,ModelMap map){
        //相当于req.setAttribute("name",name);
        map.addAttribute("msg",name);
        return "test";
    }

2.5、过滤器解决乱码

之前解决：

1、创建类 EncodingController

package com.xcong.filter;

import org.springframework.stereotype.Controller;

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

@Controller
public class EncodingController implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    public void destroy() {

    }
}

2、在web.xml配置

<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.xcong.filter.EncodingController</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-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-pattern>/*</url-pattern>
    </filter-mapping>

注意：这里写/*，写/的话过滤不了jsp页面，不能解决乱码

但是我们发现 , 有些极端情况下.这个过滤器对get的支持不好 .

处理方法 :

  1. 修改tomcat配置文件 ：设置编码！

    <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

1234

  2. 自定义过滤器（万能解决）

    package com.kuang.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;
  }
}

    一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！

    然后在web.xml中配置这个过滤器即可！

    乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

揽星河吖
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringMVC(全)
m0_47711130的博客
05-30 8995
全网最全总结，有不足之处欢迎补充 925850563@qq.com 可以通过图片连接自行查看结果截图
SpringMVC框架学习总结
姝涵的一年365
06-26 410
文件上传和下载步骤1.导入文件上传的相关jar包. 2.在application.xml中配置文件上传解析器. 3.编写核心类. 开发过程中遇到的问题及原因说明需要配置文件上传解析器. 缺少文件上传的包 源码解析HanderMapping 请求映射处理器:(说明书)作用：根据不同的请求选择最合适的处理器(自己编写的控制器)，请求映射处理器可以配置多个，谁最先匹配就执行谁。 [org.springfr
Spring MVC框架学习
m0_63039919的博客
12-29 1292
Spring MVC 全称,Spring Web MVC 又被简称为SpringMVC或SpringWeb.SpringMVC是基于Servlet API构建的一个Web框架.MVC是一种思想Spring/SpringBoot/Spring MVC有什么区别?Spring是一个框架,是一个包含了众多工具的IoC容器,其核心思想就是IoC;
SpringMVC框架学习
qq_44733345的博客
05-17 57
2.ServletAPI向request域共享数据 = 一次请求 session 一次会话 浏览器开启到关闭。3.SevletContext = ApplicationContext 整个应用的范围，服务器开启到服务器关闭。钝化:服务器关闭，浏览器没关闭，会话仍然在继续，存储在session中的数据会序列化到我们的磁盘上。活化：浏览器没关闭，服务器重新开启，将钝化后的文件内容重新读取到session中。2.生成get，set方法和无参构造，有参构造。1.简介:风格，一种架构格式，表现层状态转移。
springMVC
qq_45687780的博客
04-21 8593
基于狂神说的笔记+个人理解和总结
SpringMVC 框架基础知识
m0_67698950的博客
06-12 335
在原生的 Java EE 技术体系中，处理用户请求的是组件，通常情况下，每个组件处理 1 种请求，例如“用户注册”的请求可能由来处理，“用户登录”的请求可能由来处理……在比较复杂的业务系统中，用户提交的请求的种类可能特别多，就会导致组件的数量也特别多！进而导致代码的管理难度很大，同时，在项目运行时，诸多的组件也会占用较多的内存空间……在 SpringMVC 框架的设计中，就解决了以上问题，它使用 1 个的组件，用于接收所有请求（当然，也可以配置为某些特定的请求，例如配置为仅处理的请求），以此减少组件的数量！
Java_SpringMvc-maven.rar_springmvc_springmvc框架
09-23
搭建springMVC简单框架，适合初学者了解学习springmvc
SpringMVC-Mybatis-Shiro-redis-master
01-18
【标题】"SpringMVC-Mybatis-Shiro-redis-master" 涉及的是一个集成框架项目，这个项目集成了四个关键的技术组件：SpringMVC、MyBatis、Shiro和Redis。这些技术在现代Java Web开发中扮演着重要角色。 **SpringMVC**...
SSM 框架整合教程：三、SpringMVC-尚硅谷学习笔记 2022 年
09-08
SSM 框架整合教程：三、SpringMVC——尚硅谷学习笔记 2022 年
基于Spring MVC的个人博客系统的设计与实现
05-11
资源为本人14年的毕业设计，下载着可以作为参考资料，其中包含源码以及数据库表的创建脚本，也可作为JAVA初学者的参考资料，欢迎下载，如需要E-R图请另行下载。
SSM框架整合Java项目源码 - SpringMvc-05示例
03-25
项目概述：本项目命名为 SpringMvc-05 示例，主要采用 Java 语言开发，整合了 SSM（Spring、SpringMVC、MyBatis）框架。项目包含前端和后端两部分，前端使用了 JavaScript、CSS 和 HTML，后端则完全是 Java 实现。...
springmvc-mybatis-学习资料
07-24
SpringMVC 和 MyBatis 是两个非常流行的 Java 开发框架，它们经常被一起使用来构建高效、可维护的Web应用程序。SpringMVC 是 Spring 框架的一部分，负责处理HTTP请求，而 MyBatis 是一个轻量级的持久层框架，简化了...
SpringMVC学习总结
xingyuncaojun的博客
06-09 1万+
1、SpringMVC 和 Struts2 对比 ①、SpringMVC 的入口是 Servlet,而Struts2是Filter ②、SpringMVC会稍微比Struts2快些，SpringMVC是基于方法设计的，而Struts2是基于类设计的，每次发一次请求都会实例一个Action. ③、SpringMVC使用更加简洁，开发效率比Struts2高。支持JSR303，处理ajax的请求更...
SpringMVC框架入门教程
热门推荐
凉亭的博客
09-13 1万+
1.MVC 2.SpringMVC执行流程 Spring MVC是结构最清晰的MVC实现。Controller接收请求，然后返回ModelAndView。 1.springmvc将所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作。 2.DispatcherServlet查询HandlerMapping,找到处理请求的Con...
第二章 Spring MVC入门 —— 跟开涛学SpringMVC
jinnianshilongnian的专栏
07-16 1457
  扫一扫，关注我的公众号    我的新书 购买地址 2．1、Spring Web MVC是什么 Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常...
SpringMVC框架学习基础篇
weixin_43310305的博客
06-01 283
SpringMVC学习笔记 1.前言 接下来我们将进入springMVC框架的学习，在学习这个框架之前，我们应该做一些知识的预备，比如说什么是MVC模式？M: model V:view C :controllor可能到这里大家还是比较迷糊，那我们通过这个MVC来看看我们所应用的框架的工作模式和工作原理是怎么样的呢？我们通过原理图来看看吧！ 我们可以清晰的看出，view层使用的是springMVC框架，也就是我们的视图层，主要负责视图转发，数据的绑定，拦截我们的转发请求，用户通过URL向我们的服务器发
【计算机毕业设计】基于Springboot的B2B平台医疗病历交互系统【源码+lw+部署文档】
最新发布
06-30 314
目录1.1 选题的依据及意义1.2 国内外现状研究1.3 研究目的 第2章 设计技术与开发环境2.1 相关技术介绍 2.1.1 B/S模式分析2.1.2 mysql简介2.1.3 Spring Boot 简介2.2 开发环境介绍 2.2.1 eclipse简介2.2.2 Tomcat简介第3章 需求分析与可行性分析3.1 需求分析3.1.1 应用需求分析3.1.2 运行需求分析3.1.3 其他需求分析3.2 数据流程分析3.2.1 系统操作流程3.2.2 数据增加流程3.2.3 数据修改流程3.2.4
完整版 Java开发实训课程系列-SpringMVC框架技术教程 第9章 SSM框架整合 （共26页）.pptx
12-26
从SpringMVC框架的基础概述开始，逐渐深入到各个方面的细节，如处理器映射器和适配器、映射请求和返回值、参数绑定、数据校验、异常处理等，使学习者能够系统地掌握SpringMVC框架的各个方面。而在第9章的SSM框架整合...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

揽星河吖

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

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

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

打赏作者

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

抵扣说明：

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

余额充值