跳至主要內容

2.SpringMVC框架

holic-x...大约 29 分钟框架SpringSpringMVC

[JAVA]-SpringMVC学习

1.SpringMVC架构基础

【1】SpringMVC架构学习内容

SpringMVC的基础知识

  • 什么是SpringMVC?

  • SpringMVC框架原理(掌握)

    前端控制器、处理器映射器、处理器适配器、视图解析器

  • SpringMVC的入门程序

    目的：对前端控制、处理器映射器、处理器适配器、视图解析器学习

    非注解的处理器映射器、非注解的处理器适配器

    注解的处理器映射器、处理器适配器

  • SpringMVC和MyBatis的整合

  • SpringMVC注解开发(重点)

    常用的注解学习

    参数绑定(简单类型、POJO、集合类型)

    自定义参数绑定

SpringMVC的高级应用

  • 数据回显

  • 上传图片

  • JSON数据支持

  • RESTful支持

  • 拦截器

【2】SpringMVC简介

​ SpringMVC是属于表现层的框架。它是Spring框架的一部分

image-20210503144802848

架构流程说明

image-20210503152646596

1.用户发送请求到前段控制器DispatchServlet
2.DispatchServlet接受到请求调用HandlerMapping处理器映射器
3.处理器映射器根据请求的URL找到具体的处理器，生成处理器对象以及拦截器并把所有的内容返回到DispatchServlet
4.DispatchServlet通过HandlerAdapter处理器适配器调用处理器
5.执行处理器(Controller-后端控制器)
6.Controller执行完成返回ModelAndView
7.HandlerAdapter将Controller执行的结果ModelAndView返回给DispatchServlet
8.DispatchServlet将ModelAndView传递给ViewReslover视图解析器
9.视图解析器解析后会返回具体的View
10.DispatchServlet对View进行渲染、将模型数据填充到视图
11.DispatchServlet响应客户端请求

2.SpringMVC架构基础

【1】SpringMVC入门基础

商品订单业务

（1）需求分析

​ 通过商品订单业务学习SpringMVC相关的功能（利用之前的表格数据进行操作）

image-20210503152839134

​ 主要测试内容：简单实现商品的查询列表功能

（2）搭建开发环境

Mysql 5.7 、Jdk1.8、Spring5.0.8

导入相关的jar包（在之前的项目的基础上添加spring-webmvc jar包）

pom.xml: 
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring-version>5.0.8.RELEASE</spring-version>
    <logging-version>1.2</logging-version>
    <mysql-version>5.1.6</mysql-version>
    <c3p0-version>0.9.5.2</c3p0-version>
    <druid-version>1.1.10</druid-version>
    <dbcp-version>1.4</dbcp-version>
    <jstl-version>1.2</jstl-version>
  </properties>
  
  <dependencies>
  	<!-- spring框架相关 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>${spring-version}</version>
	</dependency>
	
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-test</artifactId>
	    <version>${spring-version}</version>
	    <scope>test</scope>
	</dependency>
	
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-aspects</artifactId>
	    <version>${spring-version}</version>
	</dependency>
	
	<!-- spring数据库连接相关： mysql数据库连接、druid数据库连接池-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-jdbc</artifactId>
	    <version>${spring-version}</version>
	</dependency>
	
	<dependency>
	    <groupId>mysql</groupId>
	    <artifactId>mysql-connector-java</artifactId>
	    <version>${mysql-version}</version>
	</dependency>
	
	<dependency>
	    <groupId>com.alibaba</groupId>
	    <artifactId>druid</artifactId>
	    <version>${druid-version}</version>
	</dependency>
	
	<!-- springMVC框架相关 -->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-webmvc</artifactId>
	    <version>${spring-version}</version>
	</dependency>
		
	<!-- 日志相关 -->
	<dependency>
	    <groupId>commons-logging</groupId>
	    <artifactId>commons-logging</artifactId>
	    <version>${logging-version}</version>
	</dependency>
	
	<!-- jstl表达式相关 -->	
	<dependency>
	    <groupId>javax.servlet</groupId>
	    <artifactId>jstl</artifactId>
	    <version>${jstl-version}</version>
	</dependency>
	
  </dependencies>
 
  <build>
    <finalName>Spring_Day04</finalName>
     <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-compiler-plugin</artifactId>  
            <version>2.3.2</version>  
            <configuration>  
                <source>1.8</source>  
                <target>1.8</target>  
            </configuration>  
        </plugin>  
    </plugins>  
  </build>
（3）springMVC流程配置

配置web.xml文件（前端控制器）

在src/main/webapp/WEB-INF下的web.xml中配置Spring的前端控制器

配置形式：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
	http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">	
<display-name>Archetype Created Web Application</display-name>
<servlet>
		<servlet-name>指定名称</servlet-name>
		<!-- org.springframework.web.servlet.DispatcherServlet -->
		<servlet-class>DispatcherServlet类全名</servlet-class>
		<!-- 通过设置contextConfigLocation属性指定加载配置文件的位置 -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
	</servlet>
	<servlet-mapping>
		<servlet-name>指定名称</servlet-name>
		<url-pattern>*.action</url-pattern>
	</servlet-mapping>
</web-app>

image-20210503153137471

配置springmvc.xml的文件

​ 在resource目录下创建springmvc.xml文件，引入spring-mvc的命名空间

<?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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
......配置内容
</beans>

​ 在springmvc.xml中主要需要配置如下内容

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

<!-- 
		1.配置处理器映射器:BeanNameUrlHandlerMapping 
		BeanNameUrlHandlerMapping表示将定于的Bean的名字作为请求的url,
		需要将编写的controller在spring中进行配置并且需要指定bean的name为请求的url
	-->
	<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
	
	<!-- 
		2.配置处理器适配器:SimpleControllerHandlerAdapter 
		SimpleControllerHandlerAdapter即简单控制器处理器适配器,
		所有实现了Controller接口的Bean作为SpringMVC的后端控制器
	-->
	<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
	
	<!-- 
		3.配置处理器:ItemsController(自定义开发的处理器) 
		自定义处理器实现Controller接口,传送数据到指定视图
	-->
	<bean id="处理器id" name="指定名称作为访问路径" class="处理器类全名"></bean>
	
	<!-- 4.配置视图解析器:InternalResourceViewResolver -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"></bean>
处理器的开发(Handler) Controller
public class ItemsController implements Controller{

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		// 模拟数据库实现数据的封装
		Items item1 = new Items();
		item1.setId(1);
		item1.setName("宏碁笔记本");
		item1.setPrice(8000f);
		item1.setCreatetime(new Date());
		item1.setDetail("宏碁笔记本超级无敌卡的");

		Items item2 = new Items();
		item2.setId(2);
		item2.setName("联想笔记本");
		item2.setPrice(6000f);
		item2.setCreatetime(new Date());
		item2.setDetail("联想笔记本也是超级无敌卡的");
		
		Items item3 = new Items();
		item3.setId(3);
		item3.setName("苹果笔记本");
		item3.setPrice(10000f);
		item3.setCreatetime(new Date());
		item3.setDetail("宏碁笔记本超级好用");
      
		List list = new ArrayList();
		list.add(item1);
		list.add(item2);
		list.add(item3);
		
		// 创建ModelAndView对象，将数据转发到指定页面
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.addObject("list",list);
		modelAndView.setViewName("WEB-INF/jsp/list.jsp");
		// 返回该ModelAndView对象
		return modelAndView;
	}
}

完成开发视图

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Spring入门程序测试</title>
</head>
<body>

	<table border="1">
		<tr>
			<th>产品id</th>
			<th>产品名称</th>
			<th>产品价格</th>
			<th>生产日期</th>
			<th>详细描述</th>
			<th>具体操作</th>
		</tr>

		<c:forEach var="item" items="${list }">
			<tr>
				<td>${item.id }</td>
				<td>${item.name }</td>
				<td>${item.price }</td>
				<td>${item.createtime }</td>
				<td>${item.detail }</td>
				<td><a href="#">修改</a> <a href="#">删除</a></td>
			</tr>
		</c:forEach>

	</table>
</body>
</html>

发布项目到tomcat进行测试

访问地址：（与上述处理器配置的访问地址相关）

http://localhost:8080/SpringMVC_Base/queryItems.action

image-20210503153433285

（4）DispatcherServlet

image-20210503153511373

DispatcherServlet.properties:(简单参考)

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

非注解方式的HandlerMapping处理器映射器

HandlerMapping负责根据requst请求找到对应的Handler处理器

在上述案例的基础上进行修改相应的springmvc.xml文件

（1）BeanNameUrlHandlerMapping

image-20210503153716522

（2）SimpleUrlHandlerMapping

image-20210503153728607

​ 上述两种处理器映射方式是可以同时并存的，哪一个路径对应哪个映射，就执行哪个映射来确定具体的Handler

非注解方式的HandlerApater处理器适配器

（1）SimpleControllerHandlerAdapter

image-20210503153823231

对应的controller实现：

image-20210503153831232

（2）HttpRequestHandlerAdapter

image-20210503153846028

对应的controller实现：

image-20210503153853399

​ 不同的处理器适配器对应着不同的处理器，根据实际需求去完成相关配置即可

（3）最终的配置文件springmvc.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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 
		1.配置处理器映射器:BeanNameUrlHandlerMapping 
		BeanNameUrlHandlerMapping表示将定于的Bean的名字作为请求的url,
		需要将编写的controller在spring中进行配置并且需要指定bean的name为请求的url
	-->
	<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
	<!-- 配置处理器映射器形式2：SimpleUrlHandlerMapping -->
	<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<property name="mappings">
			<props>
				<prop key="/queryItems2.action">itemsController</prop>
				<prop key="/queryItems3.action">itemsController</prop>
				<prop key="/queryItems4.action">itemsController2</prop>
			</props>
		</property>
	</bean>
	
	<!-- 
		2.配置处理器适配器:SimpleControllerHandlerAdapter 
		SimpleControllerHandlerAdapter即简单控制器处理器适配器,
		所有实现了Controller接口的Bean作为SpringMVC的后端控制器
	-->
	<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>
	
	<!-- 
		配置处理器适配器方式2：HttpRequestHandlerAdapter 
		其控制器相应地需要实现HttpRequestHandler接口
	--> 
	<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean>
	
	
	<!-- 
		3.配置处理器:ItemsController(自定义开发的处理器) 
		自定义处理器实现Controller接口,传送数据到指定视图
	-->
	<bean id="itemsController" name="/queryItems.action" class="com.guigu.springmvc.a_quickstart.ItemsController"></bean>
	<bean id="itemsController2" class="com.guigu.springmvc.a_quickstart.ItemsController2"></bean>
	
	<!-- 4.配置视图解析器:InternalResourceViewResolver -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"></bean>
</beans>

上述配置使得下列url均能正确访问数据

http://localhost:8080/SpringMVC_Base/queryItems.actionopen in new window

http://localhost:8080/SpringMVC_Base/queryItems2.actionopen in new window

http://localhost:8080/SpringMVC_Base/queryItems3.actionopen in new window

http://localhost:8080/SpringMVC_Base/queryItems4.action

注解方式的映射器和适配器

​ 采用注解方式配置映射器和适配器，在Controller不需要实现任何接口，只需要使用@ResultMapping(“控制器名称”)进行注解即可，但需要在springmvc.xml中配置组件扫描器，用以扫描指定的包下的文件

注解方式的映射器

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

注解方式的适配器

org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

Springmvc.xml配置如下：

image-20210503154157130

对应Controller层代码编写如下所示：

image-20210503154202169

测试结果：

访问链接：http://localhost:8080/SpringMVC_Base/queryItems.action

image-20210503154221718

mvc:annotation-driven（重点掌握）

​ 将上述所有内容进一步简化，通过使用springMVC的mvc标签完成数据的自动配置，springmvc.xml中的配置如下，controller层编写代码参考上述即可

image-20210503154305476

数据正常访问

http://localhost:8080/SpringMVC_Base/queryItems.action

image-20210503154315443

【2】Spring整合MyBatis

为了更好的学习SpringMVC和MyBatis进行整合开发

整合的目标： 控制层采用SpringMVC 、持久层使用MyBatis实现

开发步骤：
a.需求分析
b.梳理整合思路
c.搭建开发环境
d.根据需求完成dao层、Service层、Controller层、测试界面的开发

需求分析

​ 连接数据库，实现商品列表的查询

梳理整合思路

image-20210503154615433

第一步：整合DAO层

​ MyBatis和Spring整合：

​ 通过spring管理mapper接口

​ 使用mapper的自动扫描mapper接口在spring的注册

第二步：整合service层

​ 通过spring管理service接口:

​ 使用配置方式将service接口配置在spring配置文件中

​ 实现事务管理

第三步：整合springmvc

​ 由于springmvc是是属于spring的模块 所以不需要整合 直接使用

搭建开发环境

导入相关的jar包：

包括spring 和springmvc相关的jar包、MyBaits相关的jar包

Mybatis-spring整合的jar包、数据库的驱动jar包、第三方数据库连接池驱动的jar包

<project xmlns="http://maven.apache.org/POM/4.0.0" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.guigu.springmvc</groupId>
	<artifactId>SpringMVC_MyBatis</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>SpringMVC_MyBatis Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring-version>5.0.8.RELEASE</spring-version>
		<mybatis-version>3.4.6</mybatis-version>
		<log4j-version>1.2.17</log4j-version>
		<logging-version>1.2</logging-version>
		<mysql-version>5.1.6</mysql-version>
		<druid-version>1.1.10</druid-version>
		<jstl-version>1.2</jstl-version>
		<mybatis-spring-version>1.3.2</mybatis-spring-version>
	</properties>

	<dependencies>
		<!-- spring相关的jar包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring-version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<!-- springMVC相关的jar包 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring-version}</version>
		</dependency>

		<!-- MyBatis相关的jar包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis-version}</version>
		</dependency>

		<!-- spring整合mybatis必备的jar包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis-spring-version}</version>
		</dependency>

		<!-- 日志相关的jar包 -->
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>${logging-version}</version>
		</dependency>

		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j-version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.25</version>
			<scope>test</scope>
		</dependency>

		<!-- mysql驱动的jar包 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql-version}</version>
		</dependency>

		<!-- 第三方数据库连接池相关jar包 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>${druid-version}</version>
		</dependency>

		<!-- jstl相关的jar -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl-version}</version>
		</dependency>
		
	</dependencies>

	<build>
		<finalName>SpringMVC_MyBatis</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

根据需求完成dao、service、controller

（1）dao层

目标： 使用Spring管理SqlSessionFactory 、Mapper

完成以下步骤：

a.导入db.properties文件（数据库连接配置文件）
b.导入log4j.properties日志文件
c.创建核心配置文件sqlMapConfig.xml，配置相关内容
d.使用逆向工程生成pojo类、mapper.java接口、mapper.xml配置文件
e.创建applicationContext-dao.xml配置文件，使用spring管理dao层

a.导入db.properties文件（数据库连接配置文件）

image-20210503154901848

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springmvc
jdbc.username=root
jdbc.password=root

b.导入log4j.properties日志文件

image-20210503154930919

c.创建核心配置文件sqlMapConfig.xml，配置相关内

image-20210503154941670

d.使用逆向工程生成pojo类、mapper.java接口、mapper.xml配置文件

image-20210503154959100

v e.创建applicationContext-dao.xml配置文件，使用spring管理dao层

applicationContext-dao.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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- a.加载指定的配置文件:实现数据库连接 -->
	<context:property-placeholder location="classpath:config/db.properties" />
	<!-- 使用druid数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>

	<!-- 
		b.配置sqlSessionFactory ： 
		SqlSessionFactoryBean 需要配置两个属性： 
			配置数据库连接池:dataSource 
			配置加载mybatis的文件:configLocation 
	-->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 配置数据库连接池 -->
		<property name="dataSource" ref="dataSource"></property>
		<!-- 配置加载mybatis的文件 -->
		<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>
	</bean>

	<!-- 
		c.定义mapper扫描器 ：MapperScannerConfigurer 
		需要配置两个属性： 
			配置扫描包的路径信息:basePackage 
			配置sqlSessionFactory:sqlSessionFactoryBeanName 
	-->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 配置扫描包的路径信息 -->
		<property name="basePackage" value="com.guigu.ssm.mapper"></property>
		<!-- 配置sqlSessionFactory -->
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
	</bean>
</beans>

image-20210503155032367

（2）service层
目标：
	Service交给spring管理
	spring对service进行事务管理
开发步骤：
	a.配置applicationContext-service.xml文件
	b.配置applicationContext-transaction.xml文件
	c.编写Service接口和相应的ServiceImpl实现类

v a.配置applicationContext-service.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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
	
	<!-- 配置相关的service，也可以不需要配置，直接通过注解的形式进行管理 -->
     
</beans>

b.配置applicationContext-transaction.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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">

	<!-- 
		事务管理配置： 
		对mybatis操作数据库的事务进行控制，spring使用jdbc的事务控制类
		org.springframework.jdbc.datasource.DataSourceTransactionManager
	-->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 配置数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
 
	<!-- 
		a.可以使用默认的配置
		<tx:annotation-driven/>
 	-->
 	
 	<!-- 
 		b.手动配置 		
 	-->
 	<!-- 定义通知 -->
 	<tx:advice id="txAdvice" transaction-manager="transactionManager">
 		<tx:attributes>
 			<!-- 传播行为定义 -->
 			<tx:method name="save*" propagation="REQUIRED"/>
 			<tx:method name="delete*" propagation="REQUIRED"/>
 			<tx:method name="insert*" propagation="REQUIRED"/>
 			<tx:method name="update*" propagation="REQUIRED"/>
 			<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
 			<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
 			<tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
 		</tx:attributes>
 	</tx:advice>
	<!-- 定义切面 -->
 	<aop:config>
 		<aop:advisor advice-ref="txAdvice" pointcut="execution (* com.guigu.ssm.service.impl.*.*(..))"/>
 	</aop:config>
</beans>

c.编写Service接口和相应的ServiceImpl实现类

此处为了测试商品管理相关的内容，以商品管理相关进行测试

ItemsService.java：
public interface ItemsService {
	// 查找所有项目信息
	public List<Items> findItemsList()throws Exception;
	
	// 根据id查找详细信息
	public Items findItemsById(Integer id)throws Exception;
	
	// 根据主键id修改信息
	public void updateItemsById(Integer id,Items item)throws Exception;
}

ItemsServiceImpl.java：
@Service("itemsService")
public class ItemsServiceImpl implements ItemsService{

	@Autowired
	private ItemsMapper itemsMapper;

	@Override
	public List<Items> findItemsList() throws Exception {
		List<Items> list = itemsMapper.selectByExampleWithBLOBs(null);
		// 打印数据进行验证
		System.out.println(list);
		return list;
	}

	@Override
	public Items findItemsById(Integer id) throws Exception {
		return itemsMapper.selectByPrimaryKey(id);
	}

	@Override
	public void updateItemsById(Integer id, Items item) throws Exception {
		// 一般是通过主键id进行修改，此处明确指定主键id
		item.setId(id);
		// 执行修改操作
		itemsMapper.updateByPrimaryKeyWithBLOBs(item);
	}
}
（3）action（controller）
目的：
	完成controller层的开发
	完成相关配置文件的导入并编写测试代码
开发步骤：
	a.创建springmvc.xml进行配置（完成扫描包路径配置和视图解析器的配置）
	b.配置web.xml文件（加载spring容器、配置springMVC的前端控制器）
	c.创建xxxController.java完成控制层代码编写
	d.编写测试页面进行相关测试

a.创建springmvc.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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
	
	<!-- 定义扫描包的路径 -->
	<context:component-scan base-package="com.guigu.ssm.controller,com.guigu.ssm.service.impl"></context:component-scan>
    <mvc:annotation-driven/>
    
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    	<!-- 配置视图的前缀 -->
    	<property name="prefix" value="WEB-INF/jsp/"></property>
    	<!-- 配置视图的后缀 -->
    	<property name="suffix" value=".jsp"></property>
    </bean>

</beans>

b.配置web.xml文件（加载spring容器、配置springMVC的前端控制器）

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

	<display-name>Archetype Created Web Application</display-name>

	<!-- 加载spring容器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/classes/spring/applicationContext-*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 配置SpringMVC的前端控制器 -->
	<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:spring/springmvc.xml</param-value>
		</init-param>
	</servlet>

	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<url-pattern>*.action</url-pattern>
	</servlet-mapping>

</web-app>

c.创建xxxController.java完成控制层代码编写

@Controller
public class ItemsController {

	@Autowired
	private ItemsService itemsService;
	
	@RequestMapping("/queryItems")
	public ModelAndView queryItems() throws Exception {
		List<Items> list = itemsService.findItemsList();
		ModelAndView modelAndView = new ModelAndView();
		// 转发数据到指定页面
		modelAndView.addObject("itemList", list);
		// 在配置文件中指定了前缀和后缀，此处可以省略部分内容等价于WEB-INF/jsp/xxx/xxx.jsp
		modelAndView.setViewName("items/itemList");
		return modelAndView;
	}
}

d.编写测试页面进行相关测试

itemList.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>查阅所有商品信息</title>
</head>
<body>
	<table border="1">
		<tr>商品信息一览</tr>
		<tr>
			<th>商品id</th>
			<th>商品名称</th>
			<th>商品价格</th>
			<th>商品描述</th>
			<th>生产日期</th>
			<th>操作</th>
		</tr>
		<c:forEach var="item" items="${itemList }">
			<tr>
				<td>${item.id }</td>
				<td>${item.name }</td>
				<td>${item.price }</td>
				<td>${item.detail }</td>
				<td>${item.createtime }</td>
				<td><a href="${pageContext.request.contextPath }/editItems.action?id=${item.id}">修改</a></td>
			</tr>
		</c:forEach>
	</table>
</body>
</html>

测试结果：

访问链接：http://localhost:8080/SpringMVC_MyBatis/queryItems.action，测试结果如下所示

image-20210503155506134

【3】SpringMVC注解开发

基础开发说明

（1）案例：修改数据信息
需求分析

​ 使用springMVC实现商品信息的维护

操作流程：
1、进行商品列表页面
2、点击修改，进行商品修改页面，页面中显示要修改的商品信息(数据库查询而来)，
根据商品的id进行查询商品信息
3、在商品修改修改页面，修改商品信息，修改后点击提交即可
商品修改

dao层

使用逆向工程自动生成的代码：

ItemsMapper.java、ItemsMapper.xml

service层

image-20210503160140601

image-20210503160145344

controller层

image-20210503160202435

页面

editItems.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>修改产品信息</title>
</head>
<body>
	<form action="${pageContext.request.contextPath }/updateItems.action">
		<table border="1">
			<tr>
				<td>产品名称</td>
				<td>
					<input type="hidden" name="id" value="${findItem.id }"/>
					<input type="text" name="name" value="${findItem.name }"/>
				</td>
			</tr>
			<tr>
				<td>产品价格</td>
				<td>
					<input type="text" name="price" value="${findItem.price }"/>
				</td>
			</tr>
			<tr>
				<td>具体描述</td>
				<td>
					<textarea name="detail" rows="5" cols="20">${findItem.detail }</textarea>
				</td>
			</tr>
			<tr>
				<td>图片介绍</td>
				<td>
					<c:if test="${items.pic!=null }">
		 				<img alt="图片" src="${pageContext.request.contextPath }/${items.pic}" width="100" height="100">
		 			</c:if>
					<input type="file" name="pic" />
				</td>
			</tr>
			<tr>
				<td>生产时间</td>
				<td>
					<input type="text" name="createtime" value='<fmt:formatDate value="${findItem.createtime }" pattern="yyyy-MM-dd HH:mm:ss"/>'/>
				</td>
			</tr>
			<tr>
				<td>操作</td>
				<td>
					<button type="submit">修改</button>
					<button type="reset">重置</button>
				</td>
			</tr>
		</table>
	</form>
</body>
</html>

​ 在没有了解注解开发的时候，修改的item的id是固定的，在学习注解开发相关知识之后学会利用springMVC实现动态绑定数据修改item

（2）@RequestMapping

通过RequestMapping注解可以定义不同的处理器映射规则

URL路径映射

image-20210503160334578

image-20210503160339288

还可以将多个url映射到同一个方法中

image-20210503160350089

image-20210503160401840

image-20210503160405466

窄化请求映射

​ 在当前的类上加上@RequestMapping 指定通用请求前缀 限制此类所有的方法的请求url

image-20210503160431520

​ 常见问题：在窄化请求路径的时候，会发现请求指定action跳转页面的时候，始终会多一层目录（窄化的目录），从而导致路径操作，始终跳转不到指定的jsp页面

image-20210503160446866

​ 在springmvc.xml中配置视图解析器的时候配置前缀少了个“/”，从而导致出错：

image-20210503160502171

修改完成，再次进行测试，请求路径：

（如果数据还是不能正常显示，可通过更新工程或者重启服务器再次进行测试即可）

image-20210503160512422

此外，由于窄化了请求，因此在修改部分也要相应地提交正确路径的action，否则会报404错误

ItemList.jsp：

image-20210503160531245

EditItems.jsp：

image-20210503160540360

（此处由于时间进行了格式化，在提交的时候会报400错误，是由于提交的参数值与其数据类型不汽配，需要进行调整，之后会学习通过转化器实现字符串数据与日期类的转化）

请求方法的限定

​ 在某些业务需求中，要求只能是get或者post提交表单，其它方法报错

限定POST方法

限定访问的方式是post

image-20210503160646515

image-20210503160650532

如果是以get方式访问，则报错

image-20210503160659011

限定GET方法

限定访问的方式是GET

image-20210503160715320

image-20210503160718694

如果是以post方式访问，则报错

image-20210503160725610

限定GET和POST都可以

image-20210503160739069

（5）Controller方法返回值
返回ModelAndView

ModelAndView封装了数据和视图页面

image-20210503160931134

返回字符串

image-20210503160936398

返回字符串逻辑视图名字

表示返回逻辑视图名:真正的视图是jsp路径 =前缀 +逻辑视图+后缀

image-20210503161013509

Redirect重定向

可以重定向到一个url路径

image-20210503161023928

Forward转发

image-20210503161030349

（4）参数绑定
a.参数绑定的介绍

注解适配器RequestMapping标记的方法进行适配，对方法中的形参进行参数绑定

处理器适配器在执行Handler之前需要把Http请求的key/value数据绑定到Handler方法的形参上

b.默认支持的参数类型

在Controller的方法的形参上直接定义，就可以直接使用

HttpServletRequest

image-20210503161208519

HttpServletResponse

HttpSession

Model/ModelMap

image-20210503161217235

c.简单类型

​ 当请的求的参数名称和形参的名称一致的时候，可以自动进行绑定

image-20210503161316967

image-20210503161329044

如果表单的传递的参数名称和方法的形参的名称是一致的，可以直接进行绑定。

所支持的数据类型有整形、字符串、单精度、双精度、布尔类型

@RequestParam

如果传递的参数名称和方法的形参是不一致的，该怎样绑定？
通过@RequestParam指定要绑定的数据名称即可：
value：参数的名称 就是表单中参数的，名称  这个是必须要传递的
required：是否是必须的，默认就是true，表示请求参数中必须有对应的id，如果没有则报错

image-20210503161500769

image-20210503161504994

d.POJO

​ 针对简单的pojo类型，只需要在jsp中定义的提交的参数的name属性与pojo类中相应的属性一致，即可完成pojo的封装

image-20210503161548372

image-20210503161554718

image-20210503161559430

e.自定义参数绑定

​ 通过自定义转换器实现字符串数据和日期数据之间的转换：在绑定数据的时候，需要把字符串类型转换为日期类型，否则会报400错误，实则为提交的数据类型与实际数据定义的类型不匹配引发的问题

image-20210503161615606

image-20210503161621044

解决步骤：
1.自定义转换器Converter
2.在核心配置文件springmvc.xml中配置自定义转换器

自定义Converter

image-20210503161709614

配置自定义转换器

image-20210503161734660

image-20210503161741591

（5）问题总结

解决中文乱码问题

为了解决中文乱码问题，在web.xml配置如下

image-20210503161834718

高级开发说明

（1）数据验证

​ 数据验证分为分为客户端校验和服务端校验

需求分析

​ 在商品信息修改提交时，对商品信息内容进行校验。比如对商品的名称必须输入，价格必须合法。生产日期不能为空等校验

步骤分析

a.添加springMVC数据校验所需要的jar包
b.配置校验器
c.将定义的校验器添加到处理器适配器上
d.在指定的pojo类中添加校验规则并在配置文件中添加校验信息
e.捕获错误信息并回显数据

a.添加springMVC数据校验所需要的jar包

​ 在pom.xml文件中配置校验相关的jar包（利用Hibernate验证的jar包）

image-20210503162219668

b.配置校验器

image-20210503162233934

c.将定义的校验器添加到处理器适配器上

image-20210503162254557

d.在指定的pojo类中添加校验规则并在配置文件中添加校验信息

image-20210503162318677

image-20210503162323236

e.捕获错误信息并回显数据

​ 在相应的controller层通过注解对数据进行校验，捕获相应的错误信息并转发到指定jsp页面实现校验

image-20210503162343029

image-20210503162347169

测试结果：

​ 此处会有一个小问题，如果测试输入日期为空会报相应的日期转换异常问题，其余数据能够正常操作并显示，数据测试如下：

image-20210503162400867

（2）分组校验

​ 如果有多处使用同一个Items类则可以进行分组校验，通过分组校验可以对每处的校验个性化

解决办法： 定义多个校验分组，其实就是一个空接口，用来标记不同的分组

步骤：
a.定义多个校验分组（即空接口）
b.在校验规则中使用分组
c.在Controller对应方法中指定分组

a.定义多个检验分组

image-20210503162509860

image-20210503162520750

b.在校验规则中使用分组

image-20210503162538181

c.在Controller对应方法中指定分组

image-20210503162555927

测试结果：

image-20210503162606427

（3）常见的注解校验
@Null   被注释的元素必须为null
@NotNull  被注释的元素不能为空

@Min  被注释的元素必须是一个数字 而且其中的值必须大于等于指定的值
@Max  被注释的元素必须是一个数字 而且其中的值必须小于于等于指定的值
@Size  被注释的元素必须处于指定的范围内

@Past 被注释的元素必须是一个过去的日期
@Future 被注释的元素必须是一个将来的日期

@Email 被注释的元素必须是一个合法的邮箱
@length 被注释的元素字符串的大小必须在指定的范围
@NotEmpty 被注释的元素字符串不能为空
（4）数据回显

需求分析：如果表单校验失败 需要再次把数据回显到表单内

根据当前页面中的属性确定传递的数据

image-20210503162658655

数据校验完成，在Controller中传递的内容要与页面中的一一对应

image-20210503162714537

在执行的会自动进行数据的回显

在springMVC中默认支持POJO数据的回显，要求是首字母小写 ，所以上方的代码自动回显

但如果把Controller的内容修改如下，即传递的属性和model对象不一致，则无法完成数据的回显

image-20210503162803529

@ModelAttribute

​ 通过@ModelAttribute 可以完成数据的传递

image-20210503162835359

通过@ModelAttribute将数据传递到页面

image-20210503162851027

image-20210503162855332

image-20210503162859785

【4】SpringMVC异常处理

​ Springmvc在处理请求的过程中，如果出现异常信息，统一交给异常处理器进行处理

异常处理思路分析

image-20210503163006924

操作步骤：
a.自定义异常类和异常类处理器
b.定义相应的错误页面显示异常提示信息
c.在核心配置文件springmvc.xml中配置全局的异常处理器
d.在controller中的某个方法中针对某个异常情况抛出异常进行测试

案例分析

a.自定义异常类和异常类处理器

image-20210503163057476

image-20210503163105305

b.定义相应的错误页面显示异常提示信息

image-20210503163122979

c.在核心配置文件springmvc.xml中配置全局的异常处理器

image-20210503163146073

d.在controller中的某个方法中针对某个异常情况抛出异常进行测试

image-20210503163200511

​

访问一个不存在的id进行测试，可以看到后台相应抛出异常，且对应的error.jsp中显示相应的异常信息

image-20210503163220281

【5】SpringMVC文件上传

文件上传相关

操作步骤：
a.在pom.xml中添加文件上传相关jar包
b.配置文件解析器（在核心配置文件springmvc.xml、相关jsp文件中进行配置）
c.根据提交的数据在Controller层完成文件的上传

a.在pom.xml中添加文件上传相关jar包

image-20210503163445072

b.配置文件解析器（在核心配置文件springmvc.xml、相关jsp文件中进行配置）

image-20210503163512899

image-20210503163521507

image-20210503163524716

c.根据提交的数据在Controller层完成文件的上传

image-20210503163542553

​ 问题解决：测试的时候发现图片数据不能够回显，考虑将存储路径修改为当前工程路径下目录再进行测试

image-20210503163558302

image-20210503163602585

image-20210503163606659

SpringMVC与JSON的数据交互

JSON数据格式在接口调用中 。html中比较常见，json的格式也比较简单，解析比较方便

User{
  Id:1,
  Username:zhangsan,
  Age:30
}

xml和json是两种不同的数据格式 ，json的数据格式更为简单，也更为容易解析

（1）SpringMVC进行JSON的交互流程

image-20210503163717461

（2）@RequestBody

​ 作用：@RequestBody注解用于读取HTTP请求，请求的内容通过SpringmVC提供的HttpMessageConverter接口 把读取到的内容转换为JSON， 并把数据绑定到Controller方法的形参上

（3）@ResponseBody

​ 作用：该注解是用于把Controller的方法返回的对象通过HttpMessageConvter接口转换为指定的JSON格式，xml的数据，通过Response对象响应到客户端

请求JSON、响应JSON

环境准备

​ springMVC默认是用org.springframework.http.converter.json.MappingJackson2HttpMessageConverter对json数据转换，需要在相应工程的pom.xml文件下导入json相关jar包

image-20210503164029497

配置JSON转换器

image-20210503164033936

编写JS代码进行测试

image-20210503164039633

Controller代码

image-20210503164046554

测试代码

image-20210503164051647

  • 请求的数据格式

image-20210503164122507

  • 响应的数据格式

image-20210503164127288

【6】SpringMVC的拦截器

SpringMVC的拦截器类似于Servlet的过滤器，用于在请求服务器之前进行拦截和请求之后进行处理。
开发步骤：
a.定义拦截器
b.在核心配置文件springmvc.xml中配置拦截器
c.进入到相应Controller的方法中执行测试

拦截器的基本使用

a.定义拦截器

image-20210503164301989

image-20210503164309345

image-20210503164314316

b.在核心配置文件springmvc.xml中配置拦截器

image-20210503164326652

c.进入到相应Controller的方法中执行测试

访问任意一个页面，查阅控制台拦截器执行的顺序（与servlet的过滤器执行顺序相同）

image-20210503164351974

拦截器的应用实例

需求分析：如果用户没有登录，无法执行修改、查询等操作
开发步骤：
a.定义Controller（用户用户登录、退出）
b.定义拦截器
c.在核心配置文件springmvc.xml中配置拦截器
d.编写login.jsp，进入到相应Controller的方法中执行测试

a.定义Controller（用户用户登录、退出）

image-20210503164422436

b.定义拦截器

image-20210503164435228

c.在核心配置文件springmvc.xml中配置拦截器

image-20210503164451452

d.编写login.jsp，进入到相应Controller的方法中执行测试

image-20210503164510484

直接访问：http://localhost:8080/SpringMVC_MyBatis/items/queryItems.action

第一次访问没有进行登录，因此该action被拦截器所拦截直接跳转到登录界面要求强制进行登录

image-20210503164534000

输入任意数据模拟登录，数据能够正常操作

image-20210503164548398

执行logout.action清空缓存数据（模拟登录退出操作），

再次访问http://localhost:8080/SpringMVC_MyBatis/items/queryItems.action，此时又再次强制跳转到相应登录界面

image-20210503164601800

0  字
评论
  • 按正序
  • 按倒序
  • 按热度
Powered by Waline v3.1.3
一人の境 Copyright © 2019-未知 holic-x
Copyright © 2024 holic-x