SpringMCV
1、回顾MVC
1.1、MVC三层架构
1、MVC是模型(Model)、视图(View)、控制器(Controller)的简写,是一种软件设计规范。
2、是将业务逻辑、数据、显示分离的方法来组织代码。
3、MVC主要作用是降低了视图与业务逻辑间的双向偶合。
4、MVC不是一种设计模式,MVC是一种架构模式。当然不同的MVC存在差异。
- Model(模型):数据模型,提供要展示的数据,因此包含数据和行为,可以认为是领域模型或 JavaBean 组件(包含数据和行为),不过现在一般都分离开来:Value Object(数据) 和 服务层(行为)。也就是模型提供了模型数据查询和模型数据的状态更新等功能,包括数据和业务。
- View(视图):负责进行模型的展示,一般就是我们见到的用户界面,客户想看到的东西。
- Controller(控制器):接收用户请求,委托给模型进行处理(状态改变),处理完毕后把返回的模型数据返回给视图,由视图负责展示。
5、基于 Servlet 的 MVC 模式的具体实现如下。
- 模型:一个或多个 JavaBean 对象,用于存储数据(实体模型,由 JavaBean 类创建)和处理业务逻辑(业务模型,由一般的 Java 类创建)。
- 视图:一个或多个 JSP 页面,向控制器提交数据和为模型提供数据显示,JSP 页面主要使用 HTML 标记和 JavaBean 标记来显示数据。
- 控制器:一个或多个 Servlet 对象,根据视图提交的请求进行控制,即将请求转发给处理业务逻辑的 JavaBean,并将处理结果存放到实体模型 JavaBean 中,输出给视图显示。
5、基于 Servlet 的 MVC 模式的流程图
1.2、MVC框架
1、概念
是为了解决传统mvc模式(jsp+servlet+javabean)问题而出现的框架。
2、传统的mvc模式的不足
- 所有的servlet和servlet的映射都需要配置在web.xml中,如果项目太大,web.xml的行数就会相当庞大,并且不能实现模块化管理。
- servlet的主要功能就是接收参数,调用逻辑、跳转页面,比如像其它字符编码、文件上传等功能都要写在Servlet中。
- 接收参数比较麻烦,不能通过model接收,只能单个参数进行接收,接收完成后转换封装model。
- 跳转页面方式比较单一(forward、redirect),并且,当页面名称发生改变时需要修改Servlet的源代码。
3、MVC框架要做哪些事情
- 将url映射到java类或java类的方法。
- 封装用户提交的数据。
- 处理请求–调用相关的业务处理–封装响应数据。
- 将响应的数据进行渲染 ,jsp / html 等表示层数据。
4、说明:
- 常见的服务器端MVC框架有:Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF。
- 常见前端MVC框架:vue、angularjs、react、backbone,由MVC演化出了另外一些模式如:MVP、MVVM 等等…
2、SpringMVC
2.1、什么是SpringMVC
Spring MVC是基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级web框架。属于SpringFrameWork的后续产品,已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。
官方地址:https://docs.spring.io/spring-framework/docs/current/reference/html/web.html
使用 Spring 可插入的 MVC 架构,从而在使用Spring进行WEB开发时,可以选择使用Spring的Spring MVC框架或集成其他MVC开发框架,如Struts1(现在一般不用),Struts 2(一般老项目使用)等。
SpringMVC的特点:
1、清晰的角色划分:
- 前端控制器(DispatcherServlet)
- 请求处理器映射(HandlerMapping)
- 处理器适配器(HandlerAdapter)
- 视图解析器(ViewResolver)
- 处理器或页面控制器(Controller)
- 验证器( Validator)
- 命令对象(Command 请求参数绑定到的对象就叫命令对象)
- 表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。
2、分工明确,而且扩展点相当灵活,可以很容易扩展,虽然几乎不需要。
3、由于命令对象就是一个 POJO,无需继承框架特定 API,可以使用命令对象直接作为业务对象。
4、和 Spring 其他框架无缝集成,是其它 Web 框架所不具备的。
5、高效 , 基于请求响应的MVC框架。功能强大:RESTful、数据验证、格式化、本地化、主题等。
6、轻量级,简单易学。
7、Spring MVC 框架并不关心使用的视图技术,也不会强迫开发者只使用 JSP 技术。
2.2、为什么要学习SpringMVC
1、Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。
2、DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解形式进行开发,十分简洁;
正因为SpringMVC好,简单,便捷,易学,天生和Spring无缝集成(使用SpringIoC和Aop) ,使用约定优于配置 ,能够进行简单的junit测试,支持Restful风格 ,异常处理,本地化 ,国际化 , 数据验证, 类型转换,拦截器 等等…所以我们要学习。
最重要的一点还是用的人多,使用的公司多。
3、SpringMVC工作流程与接口
与许多其他web框架一样,Springmvc是围绕前端控制器模式设计的,其中一个中心Servlet,DispatcherServlet提供请求处理的共享算法,而实际工作则由可配置委托组件执行。该模型具有灵活性,支持多种工作流。
这个DispatcherServlet,就像任何Servlet,则需要根据servlet规范使用Java配置或web.xml。反过来,DispatcherServlet使用Spring配置来发现请求映射、视图解析、异常处理所需的委托组件等
Spring MVC框架像许多其他MVC框架一样,以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能,DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)
3.1、Spring MVC 工作流程
Spring MVC 框架主要由 DispatcherServlet、处理器映射、控制器、视图解析器、视图组成。图为SpringMVC的一个较完整的流程图。
从图可总结出 Spring MVC 的工作流程如下:
- 客户端请求提交到 DispatcherServlet。
- 由DispatcherServlet 控制器寻找一个或多个 HandlerMapping,找到处理请求的 Controller。
- DispatcherServlet 将请求提交到 Controller。
- Controller 调用业务逻辑处理后返回 ModelAndView。
- DispatcherServlet 寻找一个或多个 ViewResolver 视图解析器,找到 ModelAndView 指定的视图。
- 视图负责将结果显示到客户端。
3.2、Spring MVC 接口
在图中包含 4 个 Spring MVC 接口,即 DispatcherServlet、HandlerMapping、Controller 和 ViewResolver。
- Spring MVC 所有的请求都经过 DispatcherServlet 来统一分发,在 DispatcherServlet 将请求分发给 Controller 之前需要借助 Spring MVC 提供的 HandlerMapping 定位到具体的 Controller。
- HandlerMapping 接口负责完成客户请求到 Controller 映射。
- Controller 接口将处理用户请求,这和 Java Servlet 扮演的角色是一致的。一旦 Controller 处理完用户请求,将返回 ModelAndView 对象给 DispatcherServlet 前端控制器,ModelAndView 中包含了模型(Model)和视图(View)。
- ViewResolver 接口(视图解析器)在 Web 应用中负责查找 View 对象,从而将相应结果渲染给客户。
从宏观角度考虑,DispatcherServlet 是整个 Web 应用的控制器;从微观考虑,Controller 是单个 Http 请求处理过程中的控制器,而 ModelAndView 是 Http 请求过程中返回的模型(Model)和视图(View)。
4、SpringMVC入门程序
4.1、入门程序实现
1、创建WEB工程,引入开发的jar包 ( 具体坐标如下)
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!--junit-->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
<scope>provided</scope>
</dependency>
2、 配置核心的控制器(配置DispatcherServlet 即 在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要绑定SpringMVC的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页面
/* :匹配所有资源
-->
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
3、编写SpringMVC 的配置文件springmvc-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--处理器映射器 HandlerMapping-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--处理器适配器 HandlerAdapter-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--视图解析器 ViewResolver-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
<!--实现HandlerMapping接口的实现类BeanNameUrlHandlerMapping,通过bean寻找控制器-->
<bean id="/hello" class="com.howie.controller.HelloController"/>
</beans>
4、编写HelloController控制器类,我们要操作业务Controller ,要么实现Controller接口,要么增加注解;需要返回一个ModelAndView,装数据,封视图。
/**
* @description: HellController
* @author: laizhenghua
* @date: 2020/11/18 8:12
*/
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中。Model
mv.addObject("msg","HelloSpringMVC!"); // springMVC也会把user对象存储到request域对象中
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello"); // /WEB-INF/jsp/hello.jsp
return mv;
}
}
5、在WEB-INF目录下创建jsp文件夹,编写hello.jsp的成功页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>hello</title>
</head>
<body>
${msg}
</body>
</html>
6、配置Tomcat 启动测试
可能遇到的问题:访问出现404,排查步骤:
- 查看控制台输出,看一下是不是缺少了什么jar包。
- 如果jar包存在,显示无法输出,就在IDEA的项目发布中,添加lib依赖!
- 重启Tomcat 即可解决!
4.2、入门程序执行流程再次分析
图为SpringMVC的一个较完整的流程图,实线表示SpringMVC框架提供的技术,不需要开发者实现,虚线表示需要开发者实现。
简要分析执行流程
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、最终视图呈现给用户。
4.3、注解版入门SpringMVC
1、使用maven新建一个web项目,引入相关依赖,Maven可能存在资源过滤的问题,我们也之将配置完善。
<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.howie</groupId>
<artifactId>day05</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>day05 Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<!--junit-->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>day05</finalName>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
2、编写web.xml配置配置,注册前端控制器
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<!--配置DispatcherServlet。这是SpringMVC的核心,叫前端控制器-->
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet要绑定SpringMVC的xml配置文件-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<!--设置启动级别为1-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
<!--
访问路径/与/*的区别:
/ :只匹配请求路径,不会匹配jsp页面
/* :匹配所有资源
-->
</servlet-mapping>
</web-app>
3、编写DispatcherServlet要绑定SpringMVC的xml配置文件。
在resource目录下添加spring-mvc.xml配置文件,配置的形式与Spring容器配置基本类似,为了支持基于注解的IOC,设置了自动扫描包的功能,具体配置信息如下:
<?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">
<!-- 开启注解扫描,自动扫描包,让指定包下的注解生效,由IOC容器统一管理 -->
<context:component-scan base-package="com.howie.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>
在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下,这样可以保证视图安全,因为这个目录下的文件,客户端不能直接访问。
- 让IOC的注解生效
- 静态资源过滤 :HTML . JS . CSS . 图片 , 视频 …
- MVC的注解驱动
- 配置视图解析器
4、创建Controller
编写一个Java控制类:com.howie.controller.HelloController , 注意编码规范。
/**
* @description: HelloController
* @author: laizhenghua
* @date: 2020/11/18 22:12
*/
@Controller
public class HelloController {
@RequestMapping(value = "/hello")
public String hello(Model model){
// 封装数据
model.addAttribute("message","welcome to the world of spring mvc");
return "test"; // 会被视图解析器处理
}
}
- @Controller是为了让Spring IOC容器初始化时自动扫描到;
- @RequestMapping是为了映射请求路径,这里因为类与方法上都有映射所以访问时应该是/hello;
- 方法中声明Model类型的参数是为了把Action中的数据带到视图中;
- 方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成WEB-INF/jsp/test.jsp。
5、创建视图层
在WEB-INF/ jsp目录中创建test.jsp , 视图可以直接取出并展示从Controller带回的信息;
可以通过EL表示取出Model中存放的值,或者对象
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${requestScope.message}
</body>
</html>
6、配置Tomcat运行测试
OK,运行成功!
4.4、小结
实现步骤其实非常的简单:
1.新建一个web项目
2.导入相关jar包
3.编写web.xml , 注册DispatcherServlet
4.编写springmvc配置文件
5.接下来就是去创建对应的控制类 , controller
6.最后完善前端视图和controller之间的对应
7.测试运行调试.
使用springMVC必须配置的三大组件:
处理器映射器、处理器适配器、视图解析器
通常,我们只需要手动配置视图解析器,而处理器映射器和处理器适配器只需要开启注解驱动即可,而省去了大段的xml配置。
5、控制器Controller
5.1、实现Controller接口
1、控制器简介
- 控制器负责提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在Spring MVC中一个控制器类可以包含多个方法。
- 在Spring MVC中,对于Controller的配置方式有很多种。
2、实现Controller接口
Controller是一个接口,在org.springframework.web.servlet.mvc包下,接口中只有一个方法。
//实现该接口的类获得控制器功能
public interface Controller {
//处理请求且返回一个模型与视图对象
ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}
3、测试
以入门程序非注解版为例!我们来回忆一下,编写好相关配置文件后,我们就要编写一个实现Controller接口的接口实现类HelloController!
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中。Model
mv.addObject("msg","Controller test !");
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}
编写完毕后,去Spring配置文件中注册请求的bean;name对应请求路径,class对应处理请求的类。
<!--Handler-->
<bean id="/hello" class="com.howie.controller.HelloController"/>
编写前端hello.jsp,注意在WEB-INF/jsp目录下编写,对应我们的视图解析器。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>hello</title>
</head>
<body>
${msg}
</body>
</html>
配置Tomcat运行测试
说明:
- 实现接口Controller定义控制器是较老的办法
- 缺点是:一个控制器中只有一个方法,如果要多个方法则需要定义多个Controller,定义的方式比较麻烦。
5.2、使用注解@Controller
1、@Controller注解类型用于声明Spring类的实例是一个控制器(在讲IOC时还提到了另外3个注解@Component,@Service,@Repository)。
2、Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类,为了保证Spring能找到你的控制器,需要在配置文件中声明组件扫描。
<!-- 开启注解扫描,自动扫描包,让指定包下的注解生效,由IOC容器统一管理 -->
<context:component-scan base-package="com.howie.controller"/>
3、增加一个TestController类,使用注解实现
/**
* @description: TestController
* @author: laizhenghua
* @date: 2020/11/19 9:34
*/
@Controller // @Controller注解的类会自动添加到Spring上下文中
public class TestController {
@RequestMapping(value = "/test") // 映射访问路径
public String test(Model model){
// Spring MVC会自动实例化一个Model对象用于向视图中传值,最终会传入Request域对象中
model.addAttribute("message","hello @Controller");
// 返回视图位置,如果返回值是String,并且有具体页面可以跳转,就会被视图解析器解析。
return "test";
}
}
4、编写前端hello.jsp,注意在WEB-INF/jsp目录下编写,对应我们的视图解析器。
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${requestScope.message}
</body>
</html>
5、运行tomcat测试
ok 完美!
其实在实际开发中,两个请求都可以指向一个视图,但是页面展现的结果是不一样的,可以看出视图是可以被被复用的,而控制器与视图之间是弱偶合关系。
注解方式是平时使用的最多的方式!
5.3、@RequestMapping
1、@RequestMapping的作用
用于建立请求 URL 和处理请求方法之间的对应关系。
2、出现的位置
① 类上:请求 URL 的第一级访问目录。此处不写的话,就相当于应用的根目录。写的话需要以/开头。
它出现的目的是为了使我们的 URL 可以按照模块化管理:
例如:
- 账户模块:
/account/add
/account/update
/account/delete
…
- 订单模块:
/order/add
/order/update
/order/delete
…
加粗的部分就是把@RequsetMappding 写在类上,使我们的 URL 更加精细。
② 方法上: 请求 URL 的第二级访问目录。
③ 同时使用在类和方法上
@Controller
@RequestMapping("/admin")
public class TestController {
@RequestMapping("/h1")
public String test(){
return "test";
}
}
访问路径就是:http://localhost:8080/项目名/admin/h1 , 需要先指定类的路径再指定方法的路径。
3、@RequestMapping里的相关属性
- value:用于指定请求的 URL。它和 path 属性的作用是一样的。
- method:用于指定请求的方式。@RequestMapping(path = “/test”,method = {RequestMethod.GET})
- headers:用于指定限制请求消息头的条件。
- params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的 key 和 value 必须和配置的一模一样。
例如:
params = {"accountName"} # 表示请求参数必须有 accountName
params = {"moeny!100"} # 表示请求参数中 money 不能是 100。
params = {"userId=1"} # 表示请求参数中userId必须是1
注意: 以上四个属性只要出现 2 个或以上时,他们的关系是 与 的关系。
@RequestMapping(path = "/test",method = {RequestMethod.GET},params = {"username"},headers = {"Accept"})
public String requestMappingTest(String username){
System.out.println("test requestMapping ...");
System.out.println(username);
return "success";
}
6、RestFul 风格
6.1、概念与功能
1、概念
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制。
2、功能
- 资源:互联网所有的事物都可以被抽象为资源
- 资源操作:使用POST、DELETE、PUT、GET,使用不同方法对资源进行操作。
- 分别对应 添加、 删除、修改、查询。
传统方式操作资源 :通过不同的参数来实现不同的效果!方法单一,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
使用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
6.2、RestFul风格测试
1、在新建一个类 RestFulController,并加上@Controller注解
2、我们先来看传统传参模式 ?与&拼接
/**
* @description: 测试RestFul风格
* @author: laizhenghua
* @date: 2020/11/19 10:49
*/
@Controller
public class RestFulController {
@RequestMapping(path = "/add")
public String test1(int a, int b, Model model){
int sum = a + b;
model.addAttribute("message","a + b = "+sum); // 把数据存入request域对象中
return "test"; // /WEB-INF/jsp/test.jsp
}
}
3、我们来测试请求,查看结果
总结:
- 原来我们提交的地址:
http://localhost:8080/day05/add?a=1&b=2
4、我们再来看RestFul风格传参模式,在Spring MVC中可以使用 @PathVariable 注解,让方法参数的值对应绑定到一个URI模板变量上。
/**
* @description: 测试RestFul风格
* @author: laizhenghua
* @date: 2020/11/19 10:49
*/
@Controller
public class RestFulController {
@RequestMapping(path = "/add/{a}/{b}") // 映射访问路径
public String test1(@PathVariable int a, @PathVariable int b, Model model){
int sum = a + b;
model.addAttribute("message","a + b = " + sum); // 把数据存入request域对象中
return "test"; // /WEB-INF/jsp/test.jsp
}
}
5、我们来测试请求,查看结果。注意,使用RestFul风格后,我们原来的传参模式不能使用于RestFul风格内
总结:
RestFul风格请求地址变为:http://localhost:8080/day05/add/1/2
我们可以称之为路径变量传参!
思考:使用路径变量的好处?
-
使路径变得更加简洁;
-
获得参数更加方便,框架会自动进行类型转换。
-
通过路径变量的类型可以约束访问参数,如果类型不一样,则访问不到对应的请求方法,如这里访问是的路径是/commit/1/a,则路径与方法不匹配,而不会是参数转换失败。
6.3、使用method属性指定请求类型
用于约束请求的类型,可以收窄请求范围。指定请求谓词的类型如GET,POST,HEAD,OPTIONS,PUT,PATCH,DELETE,TRACE等。
增加一个方法
@RequestMapping(path = "/test2",method = RequestMethod.POST) // 映射路径访问,必须是POST方式提交
public String test2(){
return "test";
}
我们使用浏览器地址栏进行访问,默认是get请求所以汇报405错误!
如果将POST修改为GET则正常了。
小结:
-
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET,PUT,POST,DELETE 以及 PATCH。
-
所有的地址栏请求默认都会是 HTTP GET 类型的。
方法级别的注解变体有如下几个:组合注解
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@GetMapping 是一个组合注解,平时使用的会比较多!
它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
7、结果跳转方式
7.1、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类
/**
* @description: 接口实现类Usercontroller
* @author: laizhenghua
* @date: 2020/11/18 8:12
*/
public class UserController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中。Model
mv.addObject("msg","Controller test !");
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}
7.2、ServletAPI
通过设置ServletAPI ,不需要视图解析器
1、通过HttpServletResponse进行输出
2、通过HttpServletResponse实现重定向
3、通过HttpServletResponse实现转发
@RequestMapping(path = "/test2")
public String test2(HttpServletRequest request, HttpServletResponse response){
request.getSession().setAttribute("message","hello world");
System.out.println(request.getSession().getId());
/*
我们可以看到成功输出session的id,在这我们拿到请求和响应对象可以进行
很多操作如:
1.编写请求转发(请求转发只发起一次请求,并且会停留在老路径)
request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
2.重定向(重新发起新的请求)
response.sendRedirect(request.getContextPath()+"/spring.jsp");
3.直接进行响应
response.setContentType("text/html;charset=utf-8"); // 设置编码格式
response.getWriter().print("<h1>响应成功</h1>");
*/
return "test";
}
7.3、SpringMVC提供的方式
1、通过SpringMVC来实现转发和重定向 - 无需视图解析器。
测试前,需要将视图解析器注释掉。
@GetMapping(path = "test/add")
public String test3(Model model){
model.addAttribute("message","执行添加操作!");
/*
在没有视图解析器的情况下,如果我们返回jsp文件的全限定名称依旧能在浏览
器里访问得到。这种情况下相当于转发!路径不变。
*/
return "/WEB-INF/jsp/test.jsp";
}
@GetMapping(path = "test/add")
public String test3(Model model){
model.addAttribute("message","执行添加操作!");
// 转发
return "forward:/WEB-INF/jsp/test.jsp";
}
@GetMapping(path = "test/add")
public String test3(Model model){
model.addAttribute("message","执行添加操作!");
// 重定向
return "redirect:/index.jsp";
}
2、通过SpringMVC来实现转发和重定向 - 有视图解析器;
重定向,不需要视图解析器,本质就是重新请求一个新地方嘛,所以注意路径问题。
可以重定向到另外一个请求实现
@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为另一个请求/
}
}
8、数据处理(参数传递)
8.1、处理提交数据
1、提交的域名称和处理方法的参数名一致
提交数据 : http://localhost:8080/user/test1?name=alex
处理方法 :
/**
* @description: UserController
* @author: laizhenghua
* @date: 2020/11/19 19:56
*/
@Controller
@RequestMapping(path = "/user")
public class UserController {
@RequestMapping("/test1")
public String test1(String name){
System.out.println(name);
return "test";
}
...
}
后台输出alex
2、提交的域名称和处理方法的参数名不一致
提交数据 : localhost:8080/day05/user/test1?username=alex
@GetMapping(path = "/test1") // localhost:8080/day05/user/test1?username=alex
public String test1(@RequestParam("username") String name, Model model){
// 1、接受前端参数
System.out.println("前端参数 name = " + name);
// 2、将返回的结果传递给前端
model.addAttribute("message",name);
// 3、视图跳转
return "test";
}
后台输出alex
3、提交的是一个对象
要求提交的表单域和对象的属性名一致 , 参数使用对象即可
编写实体类:
/**
* @description: User实体类
* @author: laizhenghua
* @date: 2020/11/19 19:57
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private int age;
}
前端提交数据:localhost:8080/day05/user/test2?id=1&name=alex&age=21
// 从前端接收id name age 封装为User对象 localhost:8080/day05/user/test2?id=1&name=alex&age=21
/*
1.接收前端用户传递的参数,判断参数的名字,假设名字直接在方法上,可以直接使用
2.假设传递的是一个对象User,匹配user对象中的字段名;如果名字一致则OK,否则,匹配不到
*/
@RequestMapping(path = "test2")
public String test2(User user){
System.out.println(user);
return "test";
}
后台输出:User(id=1, name=alex, age=21)
说明:如果使用对象的话,前端传递的参数名和对象名必须一致,否则就是null。
8.2、数据显示到前端
第一种 : 通过ModelAndView
我们前面一直都是如此 . 就不过多解释。
/**
* @description:
* @author: laizhenghua
* @date: 2020/11/18 8:12
*/
public class UserController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象,放在ModelAndView中。Model
mv.addObject("msg","Controller test !");
//封装要跳转的视图,放在ModelAndView中
mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}
第二种 : 通过Model
当我们以Model存入数据时,底层代码会把数据放到Request域对象中
@GetMapping(path = "/test1")username=alex
public String test1(@RequestParam("username") String name, Model model){
// 1、接受前端参数
System.out.println("前端参数 name = " + name);
model.addAttribute("name",name); // 存入request域对象中,在test.jsp页面中,可以使用${requestScope.name}取值
// 2、将返回的结果传递给前端
// 3、视图跳转
return "test";
}
对比
- Model 只有寥寥几个方法只适合用于储存数据,简化了新手对于Model对象的操作和理解;
- ModelAndView 可以在储存数据的同时,可以进行设置返回的逻辑视图,进行控制展示层的跳转。
8.3、乱码问题
测试步骤:
1、我们可以在首页编写一个提交的表单
<h1>首页</h1>
<form action="encode" method="post">
姓名:<input type="text" name="name"><br>
<input type="submit" value="提交">
</form>
2、后台编写对应的处理类
/**
* @description: 测试乱码
* @author: laizhenghua
* @date: 2020/11/19 21:10
*/
@Controller
public class EncodingController {
@RequestMapping(path = "/encode",method = RequestMethod.POST)
public String test1(@RequestParam("name") String name, Model model){
model.addAttribute("name",name);
System.out.println(name);
return "test";
}
}
3、输入中文测试,点击提交
后台输出:???
视图跳转:
不得不说,乱码问题是在我们开发中十分常见的问题,也是让我们技术员比较头大的问题!
以前乱码问题通过过滤器解决(这里过滤器我们也回忆一下),而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置。
1、使用web过滤器解决乱码
编写过滤器类EncodingFilter
/**
* @description: 设置一个过滤器,解决乱码问题
* @author: laizhenghua
* @date: 2020/11/19 21:34
*/
public class EncodingFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=utf-8");
response.setCharacterEncoding("UTF-8");
chain.doFilter(request,response);
}
@Override
public void destroy() {
}
}
在web.xml配置文件中注册过滤器
<!--注册过滤器-->
<filter>
<filter-name>encoding</filter-name>
<filter-class>com.howie.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern><!--过滤所有资源-->
</filter-mapping>
重启Tomcat服务,测试即可。ok 完美解决乱码问题。下面来说SpringMVC提供的过滤器类。
2、使用SpringMVC提供的过滤器类
直接在web.xml配置文件中注册,SpringMVC提供的过滤器类CharacterEncodingFilter
<!--配置解决中文乱码的过滤器-->
<filter>
<filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
重启服务,测试即可!
9、Json详解
9.1、什么是Json?
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式,目前使用特别广泛。
采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。
在 JavaScript 语言中,一切都是对象。因此,任何JavaScript 支持的类型都可以通过 JSON 来表示,例如字符串、数字、对象、数组等。看看他的要求和语法格式:
- 对象表示为键值对,数据由逗号分隔
- 花括号保存对象
- 方括号保存数组
很多人搞不清楚 JSON 和 JavaScript 对象的关系,甚至连谁是谁都不清楚。其实,可以这么理解:
JSON 是 JavaScript 对象的字符串表示法,它使用文本表示一个 JS 对象的信息,本质是一个字符串。
var obj = {a: 'Hello', b: 'World'}; //这是一个对象,注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串,本质是一个字符串
9.2、json字符串与JavaScript对象转换
1、要实现从JSON字符串转换为JavaScript 对象,使用 JSON.parse() 方法。
2、要实现从JavaScript 对象转换为JSON字符串,使用 JSON.stringify() 方法。
<script type="text/javascript">
// 编写JavaScript对象
let user = {
name:"alex",
age:"21",
sex:"男"
};
console.log(user);
// 将js对象转换为json字符串
let json_user = JSON.stringify(user);
console.log(json_user);
// 将json字符串,转化为js对象
let object_user = JSON.parse(json_user);
console.log(object_user);
</script>
3、在idea中打开网页,查看控制台输出
9.3、Controller返回json数据
Jackson应该是目前比较好的json解析工具了。
当然工具不止这一个,比如还有阿里巴巴的 fastjson 等等。
我们新建一个web项目进行测试,除了导入相关依赖,配置资源过滤等外我们还有需要导入json解析工具的依赖。
1、这里我们使用Jackson,使用它需要导入它的jar包。
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
</dependency>
2、编写web.xml配置文件(注册DispatcherServlet,解决中文乱码等)
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<!--注册Spring提供的过滤器,解决参数中文乱码问题-->
<filter>
<filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!--注册前端控制器DispatcherServlet-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<!-- 启动顺序,数字越小,启动越早 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern><!--所有请求都会被springmvc拦截 -->
</servlet-mapping>
</web-app>
3、编写DispatcherServlet要绑定SpringMVC的xml配置文件
spring-mvc.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
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.howie.controller"/>
<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
</beans>
4、编写一个User实体类和对应的UserController进行测试
/**
* @description: User实体类
* @author: laizhenghua
* @date: 2020/11/20 22:41
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer id;
private String name;
private Integer age;
private String sex;
}
5、编写Controller
这里我们需要两个新东西,一个是@ResponseBody,一个是ObjectMapper对象,我们看下具体的用法。
① @ResponseBody 使用此注解后,它就不会走视图解析器,会直接返回一个字符串!
② ObjectMapper 是jackson包下的类,用于生成json格式的字符串。
/**
* @description: 控制器UserController
* @author: laizhenghua
* @date: 2020/11/21 9:54
*/
@Controller
public class UserController {
@ResponseBody
@RequestMapping(path = "/test1")
public String test1() throws JsonProcessingException {
// 创建一个user对象
User user = new User(1,"alex",21,"男");
// 将user对象转换为json字符串
ObjectMapper mapper = new ObjectMapper();
String userJson = mapper.writeValueAsString(user);
return userJson;
}
}
6、配置Tomcat,进行测试
经测试发现,我们已成功返回json字符串,但是存在乱码问题!怎么解决呢?
我们需要设置一下他的编码格式为utf-8,以及它返回的类型;
通过@RequestMaping的produces属性来实现,修改下代码
// produces:指定响应体返回类型和编码
@RequestMapping(path = "/test1",produces = "application/json;charset=utf-8")
public String test1() throws JsonProcessingException {
...
}
再次进行测试,乱码问题ok!
注意:使用json记得处理乱码问题
9.4、Spring提供的json乱码解决方式
基于上面的例子,我们可以以原生的方式(指定响应体返回类型和编码)解决json传输乱码问题。但是这种方式存在很大的弊端,如果项目中有许多请求则每一个都要添加,可以通过Spring配置统一指定,这样就不用每次都去处理了。
我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置。
<!--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>
9.5、返回json字符串统一解决
在上面的例子我们发现,@Controller需要配合@ResponseBody才能实现方法返回json字符串,但是我们有更简洁的方案让方法返回json字符串!
在类上直接使用 @RestController ,这样子,里面所有的方法都只会返回 json 字符串了,不用再每一个都添加@ResponseBody !我们在前后端分离开发中,一般都使用 @RestController ,十分便捷!
/**
* @description: 控制器UserController
* @author: laizhenghua
* @date: 2020/11/21 9:54
*/
@RestController // 使用此注解代替@Controller
public class UserController {
@RequestMapping(path = "/test1")
public String test1() throws JsonProcessingException {
// 创建一个user对象
User user = new User(1,"alex",21,"男");
// 将user对象转换为json字符串
ObjectMapper mapper = new ObjectMapper();
String userJson = mapper.writeValueAsString(user);
return userJson;
}
}
启动tomcat测试,结果都正常输出!
9.6、测试集合输出
增加一个 test2 新的方法
@RequestMapping(path = "/test2")
public String test2() throws JsonProcessingException {
// 新建一个集合
List<User> userList = new ArrayList<>();
// 新建四个user对象,并添加到集合里
User user1 = new User(1,"alex",21,"男");
User user2 = new User(2,"Java",25,"男");
User user3 = new User(3,"Python",26,"男");
User user4 = new User(4,"C/C++",50,"男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
// 创建一个jackson的对象映射器,用来解析数据
ObjectMapper mapper = new ObjectMapper();
// 解析数据并返回
return mapper.writeValueAsString(userList);
}
执行结果
我们发现后端返回的由json字符串构成的js数组!
9.7、输出时间对象
增加一个新的test3方法
@RequestMapping(path = "/test3")
public String test3() throws JsonProcessingException {
// 新建一个时间对象
Date date = new Date();
ObjectMapper mapper = new ObjectMapper(); // jackson对象映射器
return mapper.writeValueAsString(date);
}
输出结果
默认日期格式会变成一个数字,是1970年1月1日到当前日期的毫秒数!
Jackson 默认是会把时间转成timestamps(时间戳)形式。
但是我们也可以输出自定义的时间格式,解决方案:取消把时间转成timestamps或自定义时间格式。
@RequestMapping(path = "/test3")
public String test3() throws JsonProcessingException {
// 新建一个时间对象
Date date = new Date();
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳的方式
// mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
// 自定义日期格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 解析日期格式
String time = sdf.format(date);
return mapper.writeValueAsString(time);
}
输出结果
9.8、把json字符串与时间戳的转换抽象为工具类
如果要经常使用的话,这样是比较麻烦的,我们可以将这些代码封装到一个工具类中,方便调用与维护。
json工具类
/**
* @description: json格式转换的工具类
* @author: laizhenghua
* @date: 2020/11/21 12:56
*/
public class JsonUtil {
public static String getJson(Object object){
// 创建一个jackson的对象映射器,用来解析数据
ObjectMapper mapper = new ObjectMapper();
String json = null;
try {
// 解析数据并返回
json = mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return json;
}
}
时间工具类
/**
* @description: 时间工具类
* @author: laizhenghua
* @date: 2020/11/21 13:09
*/
public class DateTimeUtil {
public static String getSysTime(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
String dateStr = sdf.format(date);
return dateStr;
}
}
10、拦截器
10.1、拦截器概述
1、SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
2、可以定义拦截器链,拦截器链就是将拦截器按着一定的顺序结成一条链,在访问被拦截的方法时,拦截器链 中的拦截器会按着定义的顺序执行。
3、拦截器和过滤器的功能比较类似,有区别
-
过滤器是
Servlet规范的一部分
,任何框架都可以使用过滤器技术。 -
拦截器是SpringMVC框架独有的,只有使用了SpringMVC框架的工程才能使用。
-
过滤器 url-pattern 配置了/*,可以拦截任何资源。
-
拦截器只会对控制器中的方法进行拦截,如果访问的是jsp/html/css/image/js是不会进行拦截。
4、拦截器也是AOP思想的一种实现方式
5、想要自定义拦截器,需要实现HandlerInterceptor接口。
10.2、自定义拦截器
首先,定义拦截器必须要实现HandlerInterceptor接口!
①创建类(com.howie.interceptor),实现HandlerInterceptor接口,重写需要的方法
/**
* 自定义拦截器
*/
public class MyInterceptor implements HandlerInterceptor {
/**
* 预处理:controller方法执行前。
* return true 放行,执行下一个拦截器,如果没有执行controller中的方法
* return false 不放行
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("controller 方法前,我就执行。");
// 请求转发
// request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
return true;
}
// 后面两个方法,日志输出上用的比较多
/**
* 后处理方法:controller方法执行后,success.jsp 之前
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("controller 方法后,我就执行。");
// 请求转发
// request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
/*
预处理方法和后处理方法都可以指定跳转方法
*/
}
/**
* 最后执行,在success.jsp执行完毕后执行。
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("最后执行");
}
/*
controller 方法前,我就执行。
testInterceptor is run ...
controller 方法后,我就执行。
success.jsp is run ...
最后执行
*/
}
② 在springmvc.xml中配置拦截器类
<!--配置拦截器-->
<mvc:interceptors>
<!--可配置多个拦截器-->
<mvc:interceptor>
<!--要拦截的具体方法。/user/* 表示拦截user模块下的所有方法,/** 表示拦截所有方法-->
<mvc:mapping path="/**"/>
<!--不要拦截的具体方法
<mvc:exclude-mapping path=""/>-->
<!--配置拦截器对象-->
<bean class="com.howie.interceptor.MyInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
<!--配置spring开启注解mvc的支持-->
<mvc:annotation-driven/>
③配置多个拦截器时,只需创建多个实现HandlerInterceptor接口的类即可。
到此我们的拦截器以及配置完毕,测试拦截器时,只需在controller层里随便编写一个处里请求的方法,去发送一个http请求,就可以看到拦截器的效果了!
10.3、拦截器的使用案例(用户登录判断验证)
实现思路:
1、有一个登陆页面,需要写一个controller访问页面。
2、登陆页面有一提交表单的动作。需要在controller中处理。判断用户名密码是否正确。如果正确,向session中写入用户信息。返回登陆成功。
3、拦截用户请求,判断用户是否登陆。如果用户已经登陆。放行, 如果用户未登陆,跳转到登陆页面。
示例:
1、编写一个登陆页面 login.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String path = request.getContextPath();
%>
<html>
<head>
<title>登录页面</title>
</head>
<body>
<h1>登录页面</h1>
<form action="<%=path%>/user/login" method="post">
username : <input type="text" name="username">
password : <input type="password" name="password">
<input type="submit" value="登录">
</form>
</body>
</html>
2、编写一个Controller处理请求
@RequestMapping(path = "/login",method = RequestMethod.POST)
public String userLogin(@RequestParam String username, @RequestParam String password, HttpSession session){
session.setAttribute("user",username);
// 注销时,把这个属性节点remove即可如:session.removeAttribute("user");
/*
这里写的并不严谨,用户名和密码应该走数据库,并且要考虑查询错误的情况
*/
return "main";
}
3、编写一个登陆成功的页面 main.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
<title>首页</title>
</head>
<body>
<h1>首页</h1>
<h1>hello ${sessionScope.user}</h1>
</body>
</html>
4、编写用户登录拦截器
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
HttpSession session = request.getSession();
User user = (User)session.getAttribute("user");
if(user != null){
return true;
}
// 如果没哟登录,就转发到登录页面
request.getRequestDispatcher("/login.jsp").forward(request,response);
return false;
}
}
5、在Springmvc的配置文件中注册拦截器
<!--登录拦截器-->
<mvc:interceptor>
<mvc:mapping path="/user/*"/>
<mvc:exclude-mapping path="/user/login"/><!--登录请求不进行拦截-->
<bean class="com.howie.interceptor.LoginInterceptor"/>
</mvc:interceptor>
6、测试
11、文件上传与下载
11.1、准备工作
文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传,但是SpringMVC上下文中默认没有装配MultipartResolver,因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能,则需要在上下文中配置MultipartResolver。
前端表单要求:为了能上传文件,必须将表单的method设置为POST,并将enctype设置为multipart/form-data。只有在这样的情况下,浏览器才会把用户选择的文件以二进制数据发送给服务器;
对表单中的 enctype 属性做个详细的说明:
-
application/x-www=form-urlencoded:默认方式,只处理表单域中的 value 属性值,采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
-
multipart/form-data:这种编码方式会以二进制流的方式来处理表单数据,这种编码方式会把文件域指定文件的内容也封装到请求参数中,不会对字符编码。
-
text/plain:除了把空格转换为 “+” 号外,其他字符都不做编码处理,这种方式适用直接通过表单发送邮件。
<form action="" enctype="multipart/form-data" method="post">
<input type="file" name="file"/>
<input type="submit">
</form>
一旦设置了enctype为multipart/form-data,浏览器即会采用二进制流的方式来处理表单数据,而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年,Apache Software Foundation发布了开源的Commons FileUpload组件,其很快成为Servlet/JSP程序员上传文件的最佳选择。
-
Servlet3.0规范已经提供方法来处理文件上传,但这种上传需要在Servlet中完成。
-
而Spring MVC则提供了更简单的封装。
-
Spring MVC为文件上传提供了直接的支持,这种支持是用即插即用的MultipartResolver实现的。
-
Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类:
-
CommonsMultipartResolver。因此,SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。
11.2、文件上传
1、导入文件上传的jar包,commons-fileupload , Maven会自动帮我们导入他的依赖包 commons-io包
<!--文件上传-->
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<!--servlet要导入高版本-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!--jackson-->
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.2</version>
</dependency>
2、配置bean:multipartResolver
注意!!!这个bena的id必须为:multipartResolver , 否则上传文件会报400的错误!在这里栽过坑,教训!
<!--文件上传配置-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 请求的编码格式,必须和jSP的pageEncoding属性一致,以便正确读取表单的内容,默认为ISO-8859-1 -->
<property name="defaultEncoding" value="utf-8"/>
<!-- 上传文件大小上限,单位为字节(10485760=10M) -->
<property name="maxUploadSize" value="10485760"/>
<property name="maxInMemorySize" value="40960"/>
</bean>
CommonsMultipartFile 的 常用方法:
-
String getOriginalFilename():获取上传文件的原名
-
InputStream getInputStream():获取文件流
-
void transferTo(File dest):将上传文件保存到一个目录文件中
3、编写前端页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
String path = request.getContextPath();
%>
<html>
<body>
<h2>文件上传</h2>
<form action="<%=path%>/test/upload1" enctype="multipart/form-data" method="post">
<input type="file" name="file"/>
<input type="submit" value="upload">
</form>
<form action="<%=path%>/test/upload2" enctype="multipart/form-data" method="post">
<input type="file" name="file"/>
<input type="submit" value="upload">
</form>
</body>
</html>
4、Controller类编写处理上传文件http请求的方法
第一种方法,原生i/o流
@RestController
public class UploadController {
//@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
//批量上传CommonsMultipartFile则为数组即可
@RequestMapping(path = "/test/upload",method = RequestMethod.POST)
public String fileUpload1(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {
//获取文件名 : file.getOriginalFilename();
String uploadFileName = file.getOriginalFilename();
//如果文件名为空,直接回到首页!
if ("".equals(uploadFileName)){
return "redirect:/index.jsp";
}
System.out.println("上传文件名 : "+uploadFileName);
//上传路径保存设置
String path = request.getServletContext().getRealPath("/upload");
//如果路径不存在,创建一个
File realPath = new File(path);
if (!realPath.exists()){
realPath.mkdir();
}
System.out.println("上传文件保存地址:"+realPath);
InputStream is = file.getInputStream(); //文件输入流
OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
//读取写出
int len=0;
byte[] buffer = new byte[1024];
while ((len=is.read(buffer))!=-1){
os.write(buffer,0,len);
os.flush();
}
os.close();
is.close();
return "redirect:/index.jsp";
}
}
第二种方法,采用file.Transto 来保存上传的文件
/*
* 采用file.Transto 来保存上传的文件
*/
@RequestMapping(path = "/test/upload2",method = RequestMethod.POST)
public String fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
//上传路径保存设置
String path = request.getServletContext().getRealPath("/upload");
File realPath = new File(path);
if (!realPath.exists()){
realPath.mkdir();
}
//上传文件地址
System.out.println("上传文件保存地址:"+realPath);
//通过CommonsMultipartFile的方法直接写文件(注意这个时候)
file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));
return "redirect:/index.jsp";
}
5、测试上传文件,OK!
11.3、下载文件
文件下载步骤:
1、设置 response 响应头
2、读取文件 – InputStream
3、写出文件 – OutputStream
4、执行操作
5、关闭流 (先开后关)
代码实现:
@RequestMapping(path = "/test/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
//要下载的图片地址
String path = request.getServletContext().getRealPath("/upload");
String fileName = "基础语法.jpg";
//1、设置response 响应头
response.reset(); //设置页面不缓存,清空buffer
response.setCharacterEncoding("UTF-8"); //字符编码
response.setContentType("multipart/form-data"); //二进制传输数据
//设置响应头
response.setHeader("Content-Disposition",
"attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));
File file = new File(path,fileName);
//2、 读取文件--输入流
InputStream input=new FileInputStream(file);
//3、 写出文件--输出流
OutputStream out = response.getOutputStream();
byte[] buff =new byte[1024];
int index=0;
//4、执行 写出操作
while((index= input.read(buff))!= -1){
out.write(buff, 0, index);
out.flush();
}
out.close();
input.close();
return null;
}
前端代码:
<%
String path = request.getContextPath();
%>
...
<a href="<%=path%>/test/download">点击下载</a>
拦截器及文件操作在我们开发中十分重要,一定要学会使用!
12、SpringMVC的异常处理
1、异常处理思路
Controller调用service,service调用dao,异常都是向上抛出的,最终有DispatcherServlet找异常处理器进 行异常的处理。
2、SpringMVC的异常处理
①自定义异常类
package com.howie.exception;
/**
* 自定义异常类
*/
public class SysException extends Exception{
// 存储提示信息
private String message;
public SysException(String message) {
this.message = message;
}
@Override
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
②自定义异常处理器(实现特定的接口HandlerHandlerExceptionResolver,并重写相关方法)
package com.howie.exception;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 异常处理器类
*/
public class SysExceptionResolver implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
// 获取到异常对象
SysException exception = null;
if(e instanceof SysException){
exception = (SysException) e;
} else{
exception = new SysException("系统正在维护");
}
// 创建ModelAndView对象
ModelAndView modelAndView = new ModelAndView();
// 存入错误提示信息
modelAndView.addObject("errorMessage",exception.getMessage()); // 最终会存储到request域对象中
// 跳转的jsp页面
modelAndView.setViewName("error");
return modelAndView;
}
}
③在配置文件中配置异常处理器对象
<!--配置异常处理器对象-->
<bean id="sysExceptionResolver" class="com.howie.exception.SysExceptionResolver"/>
④使用示例
@RequestMapping(path = "/testException")
public String testException() throws SysException {
System.out.println("testException is run ...");
// 模拟异常
try {
int a = 1/0;
} catch (Exception e) {
e.printStackTrace();
throw new SysException("查询错误");
}
return "success";
}