SpringMVC

最新推荐文章于 2025-06-05 14:42:06 发布

漂泊老猫

最新推荐文章于 2025-06-05 14:42:06 发布

阅读量109

点赞数

分类专栏： Java后端文章标签： java servlet spring

本文链接：https://blog.youkuaiyun.com/qq_44799103/article/details/129369734

版权

Java后端专栏收录该内容

24 篇文章

订阅专栏

序一、学习方式

ssm：mybatis + Spring + SpringMVC MVC三层架构

SSM框架：研究官方文档，锻炼自学能力，锻炼笔记能力，锻炼项目能力

剩余路线：SpringMVC + VUE + SpringBoot + SpringCloud + Linux

SSM = JavaWeb做项目；

Spring：IOC+AOP
SpringMVC：执行流程！
SpringMVC：SSM框架整合！

序二、什么是MVC

MVC：模型（dao， service）视图（jsp）控制器（servlet）

软件设计规范

dao
service
servlet：转发，重定向
jsp/html

公司中实际操作类：

前端数据传输实体类
实体类：用户名密码生日爱好。。。 20个
前端：用户名密码
pojo：User
vo/dto： UserVo 细分的实体类，专注于做一件业务

假设：你的项目的架构，是设计好的，还是演进的？

Alibaba PHP
随着用户量大，Java（淘宝的十年革命）
王坚去IOE MySQL
MySQL： MySQL—》AliSQL、AliRedis
All in one —》微服务

序三、web发展史

Model1时代

在web早期的开发中，通常采用的都是Model1；
主要分为两层：视图层和模型层。

request
JSP取请求参数
调用业务逻辑方法
数据返回后渲染页面

Model1优点：架构简单，比较适合小型项目的开发；
Model1缺点：JSP职责不单一，职责过重，不便于维护。

Model2时代

Model2把一个项目分成三部分，包括：视图、控制、模型。

步骤

用户发请求
Servlet 接受请求数据，并调用对应的业务逻辑方法
业务处理完毕，返回更新后的数据给Servlet
servlet转向导JSP，由JSP来渲染页面
响应给前端更新后的页面

职责分析：

Controller：控制器

取得表单
调用业务逻辑
转向指定的页面
Model：模型
业务逻辑
保存数据的状态
View: 视图
显示页面

Model2 这样不仅提高了代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1 模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2 消除了Model1 的缺点。

回顾Servlet

导入依赖

<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.9.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>

建立一个Module：SpringMVC-01-servlet，添加web app的支持。
导入Servlet和JSP的jar包

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

编写一个Servlet类，用来处理用户请求

package com.mao.servlet;

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

public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 获取前端参数
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了 add 方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了 delete 方法");
        }

        // 2. 调用业务层
        // 3. 视图转发或者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);

    }

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

写前端表单页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<form action="/hello" method="post">
    <input type="text" name="method">
    <input type="submit">
</form>

</body>
</html>

注册Servlet

<?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.mao.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <!--超时设置-->
    <!--<session-config>-->
    <!--    <session-timeout>15</session-timeout>-->
    <!--</session-config>-->

    <!--欢迎页-->
    <!--<welcome-file-list>-->
    <!--    <welcome-file>index.jsp</welcome-file>-->
    <!--</welcome-file-list>-->

</web-app>

配置Tomcat，并启动测试
http://localhost:8080/hello?method=add
http://localhost:8080/hello?method=delete
MVC框架要做的事情

将url映射到Java类或Java类的方法；
封装用户提交的数据；
处理请求–调用相关的业务处理–封装响应数据；
将响应的数据进行渲染 .jsp/html 等表示层数据。
说明：
常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；
常见的前端MVC框架：VUE、 angularjs、react、backbone；
由MVC演化出了另外一些模式：如：MVP，MVVM 等等。。

什么是SpringMVC

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。
官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/web.html
Spring MVC的特点：

轻量级，简单易学
高效，基于请求响应的MVC框架
与Spring兼容性好，无缝衔接
约定大于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活
我们可以将SpringMVC中所有要用到的bean，注册到Spring中。

中心控制器

Spring的Web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分法到不同的处理器。从Spring 2.5 开始，使用Java5或者以上版本的用户可以采用注解的Controller声明方式。

SpringMVC框架像许多其他MVC框架一样，以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet（它继承了HttpServlet 基类）。
在这里插入图片描述

原理讲述【挖坑】

在这里插入图片描述

SpringMVC：Hello，SpringMVC

HelloSpringMVC配置版：

新建一个Module，添加web的支持！
确定导入了SpringMVC的依赖！
配置web.xml，注册DispatcherServlet！

<?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：这是SpringMVC的核心；请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别：1-->
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!--在SpringMVC中，  /  和 /*
    /:  只匹配所有的请求，不会去匹配jsp页面
    /*: 匹配所有的请求，包括JSP页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
</web-app>

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

编写HelloController

package com.mao.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 {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();

        // 业务代码
        String result = "HelloSpringMVC";
        mv.addObject("msg",result);

        // 视图跳转
        mv.setViewName("test");

        return mv;
    }
}

springmvc-servlet.xml中配置Bean

    <!--BeanNameUrlHandlerMapping：bean-->
    <bean id="/hello" class="com.mao.controller.HelloController"/>

测试
可能遇到的问题，访问404，排查步骤

查看控制器输出，看一下是不是缺少了jar包
如果jar包存在，显示无法输出，就在IDEA项目发布中，添加lib依赖
重启Tomcat！

HelloSpringMVC注解版：

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/aop
       https://www.springframework.org/schema/aop/spring-aop.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.mao.controller"/>
    
    <!--让SpringMVC不处理静态资源  .css  .js  .html  .mp3  .mp4-->
    <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>

实现步骤

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

使用SpringMVC必须配置的三大件：处理器映射器、处理器适配器、视图解析器
通常我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可。

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

RestFul 风格：简化Url、安全。

更改请求方式。。。

重定向和转发（结果跳转方式）

ModelAndView

设置ModelAndView
设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面。
页面：（视图解析器前缀）+viewName + （视图解析器后缀）

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

对应的Controller类

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

ServletAPI

通过设置ServletAPI，不需要视图解析器

通过HttpServletResponse进行输出
通过HttpServletRequest实现重定向
通过HttpServletRequest实现转发

@Controller
public class ResultGo{
	@RequestMapping("/resullt/t1")
	public void test1(HttpServletRequest req, HttpServletResponse resp) throws IOException{
		// 输出
		resp.getWritter().println("Hello,Spring BY servlet API");
	}
	@RequestMapping("/resullt/t2")
	public void test2(HttpServletRequest req, HttpServletResponse resp) throws IOException{
		// 重定向
		resp.sendRedirect("/index.jsp");
	}
	@RequestMapping("/resullt/t3")
	public void test3(HttpServletRequest req, HttpServletResponse resp) throws IOException{
		// 转发
		resp.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
	}
}

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

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

@Controller
public class RequestSpringMVC {
	@RequestMapping("/rsm/t1")
	public String test1(){
		// 转发
		return "/WEB-INF/index.jsp";
	}
	@RequestMapping("/rsm/t2")
	public String test2(){
		// 转发二
		return "forward:/index.jsp";
	}
	@RequestMapping("/rsm/t3")
	public String test3(){
		// 重定向
		return "redirect:/index.jsp";
	}
}

数据处理

处理提交数据

提交的域名称和处理方法的参数名一致
提交数据：http://localhost:8080/hello?name=laomao
处理方法：

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

后台输出： laomao
2. 提交的域名称和处理方法的参数名不一致
提交数据：http://localhost:8080/hello?username=laomao
处理方法：

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

后台输出： laomao
3. 前端提交的是一个对象
要求提交的表单域和对象的属性名一致，参数使用对象即可
1. 实体类

public class User {
	private int id;
	private String name;
	private int age;
}

2. 提交数据

http://localhost:8080/user?username=laomao&id=1&age=3
3. 处理方法

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

后台输出： User{id=1,name=‘laomamo’,age=5}
说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则为null。

LinkedHashMap
ModelMap： 继承了LinkedHashMap，所以他拥有LinkedHashMap的全部功能!
Model:精简版（大部分情况，直接使用Model）

乱码问题

过滤器解决乱码，无法解决POST方式请求的乱码，可以解决GET方式的。
SpringMVC给我们提供了一个过滤器，可以在web.xml中配置，修改了xml文件需要重启服务器。

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>

JSON

前后端分离时代：
后端部署后端，提供接口，提供数据；

JSON：数据交换格式

前端独立部署，负责渲染后端的数据。

什么是JSON

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

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

对象表示为键值对，数据由逗号分隔
花括号保存对象
方括号表示数组
JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异

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

<script type="text/javascript">
	var user = {
		name:"laomao",
		age:3,
		sex:"男"
	};

	// 将js对象转换为JSON对象：
	var json = JSON.stringify(user);
	console.log(json);
	// 将JSON对象转换为js对象
	var obj = JSON.parse(json);
	console.log(obj);
</script>

Controller返回JSON数据

Jackson应该是目前比较好的json解析工具了
当然工具不止这一个，还有阿里的fstjson等；
使用Jackson，导入jar包

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.14.2</version>
</dependency>

web.xml

    <!--注册Servlet-->
    <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>
    
    <!--所有请求都会被springmvc拦截-->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <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>

写实体类
写controller

// @Controller  会走视图解析器
@RestController	// 不会走视图解析器
public class UserController {
	@RequestMapping("/j1")
	// @ResponseBody // 它就不会走视图解析器，会直接返回一个字符串
	public String json1() throws JsonProcessingException{
		ObjectMapper mapper = new ObjectMapper();
		User user = new User("laomao",3,"男");
		String str = mapper.writerValueAsString(user);
		return str;
	}

	@RequestMapping("/j2")
	public String json2() throws JsonProcessingException{
		ObjectMapper mapper = new ObjectMapper();
		List<User> userList = new ArrayList<User>();
		User user1 = new User("laomao1",3,"男");
		User user2 = new User("laomao2",3,"男");
		User user3 = new User("laomao3",3,"男");

		userList.add(user1);
		userList.add(user2);
		userList.add(user3);
		
		String str = mapper.writerValueAsString(userList);
		return str;
	}

	@RequestMapping("/j3")
	public String json3() throws JsonProcessingException{
		ObjectMapper mapper = new ObjectMapper();
		Date date = new Date();	// 时间戳
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		
		String str = mapper.writerValueAsString(sdf.format(date));
		return str;
	}
}

JSON乱码问题配置

	<!-- 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>

FastJson

阿里的json

导包

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.24</version>
</dependency>