目录
SpringMVC(SpringMVC执行流程)
1、什么是MVC
1.1、概念理解
MVC:
- 模型(model)一般是dao、service层
- 视图(view)一般是jsp页面
- 控制器(controller)一般是servlet
- MVC是一种软件设计规范
使用这种规范的优点:
- 是将业务逻辑、数据,显示分离的组织代码方法
- 降低了视图和业务逻辑的双向耦合
- 它不是一种设计模式,而是一种架构模式,当然不同的MVC模式也存在差异
Model模型:
- 数据模型,提供要展示的数据,因此包含数据和行为,可以认为是领域模型或者是JavaBean组件(包含数据和行为)
- 一般分为Dao层和Service层
View视图:
- 负责进行模型的展示
Controller控制:
- 接收用户请求,委托给模型进行处理(状态改变)。处理完之后把返回的模型数据给视图,由视图负责展示。
- 充当调度员的工作
最典型的MVC设计规范:jsp+servlet+javabean
1.2、Model1时代
- Web早期开发中通常采用Model1
- 它主要分为两层:视图层、模型层
- 优点:架构简单,适合小型开发
- 缺点:jsp职责不单一,不便于维护,在该模式中jsp页面就相当于servlet
1.3、Model2时代
Model2把项目分为三部分:模型、视图、控制器
- 用户发送请求
- Servlet接收请求数据,并调用对应的业务逻辑方法
- 业务处理完毕返回数据给Servlet
- Servlet转向jsp,由jsp进行渲染
- 响应给前端更新后的页面
职责分析:
Controller控制器:
- 取得表单数据
- 调用对应逻辑
- 转向指定页面
Model模型:
- 业务逻辑
- 保存所需数据状态
View视图:
- 显示页面
Model2模型优点:
- 提高代码复用率和项目可扩展性
- 降低维护成本
- java语言优势就是越复杂的项目越容易维护
1.4、回顾Servlet
1、新建一个Maven父工程,导入依赖
<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>
2、建立一个Moudle:SpringMVC_01,添加Web APP的支持
3、导入servlet/jsp依赖
<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>
4、编写Servlet类,来接收用户请求
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//取得参数
String method = req.getParameter("method");
if (method.equals("add")){
req.getSession().setAttribute("msg","执行了add方法");
}
if (method.equals("delete")){
req.getSession().setAttribute("msg","执行了delete方法");
}
//业务逻辑
//视图跳转(请求转发、重定向)
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
5、编写jsp页面来进行验证(一般公共的jsp页面直接放在web文件夹下,如果不想要让别人看见,就放在WEB-INF文件夹下)
6、在web.xml中注册Servlet
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>com.my.servlet.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet</servlet-name>
<url-pattern>/user</url-pattern>
</servlet-mapping>
7、配置Tomcat,并启动测试
1.5、MVC框架要做哪些事情
- 将url映射到java类或java类的方法
- 封装用户提交的数据
- 处理请求-调用相应的业务方法-封装相应数据
- 将响应数据进行渲染到表示层数据
说明:常见的服务器端MVC框架:Struts2、SpringMVC、ASP.NET MVC…;常见前端MVC框架:vue、angularjs、react…;由MVC演化出的另外一些模式:MVP、MVVM等
2、什么是SpringMVC
2.1、概述
Spring MVC是Spring Framework的一部分,是基于Java实现MVC的轻量级Web框架
官方文档:https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web(4.3.24)
Spring MVC特点:
- 轻量级,简单易学
- 高效,基于请求响应的MVC框架
- 与Spring兼容性好,无缝结合(Spring大杂烩,我们可以将Spring MVC所有的bean注册到Spring容器中)
- 约定大于配置
- 功能强大:RESTful、数据验证、格式化、本地化等等
- 简洁灵活
Spring的Web框架围绕DispatcherServlet【调度Servlet】设计---->没有什么是“加一层”解决不了的
DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解形式进行开发,十分简洁
正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等…所以我们要学习
2.2、中心控制器
只要是实现Servlet接口的实现类都是一个Servlet
2.3、Spring MVC原理
当发起请求时被前置的控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制器,控制器处理请求,创建数据模型,访问数据库,将模型响应给中心控制器,控制器使用模型与视图渲染视图结果,将结果返回给中心控制器,再将结果返回给请求者。
2.4、Spring MVC执行原理
图为SpringMVC的一个较完整的流程图,实线表示SpringMVC框架提供的技术,不需要开发者实现,虚线表示需要开发者实现
- DispatcherServlet表示前置控制器,是整个SpringMVC的控制中心;用户发出请求,DispatcherServlet接收请求并拦截请求
- 说明:
- 假设请求的url为 : http://localhost:8080/SpringMVC/hello
- url拆分成三部分:
- http://localhost:8080 ------> 服务器域名
- SpringMVC ------> 部署在服务器上的web站点
- hello ------> 表示控制器
- 通过分析,如上url表示为:请求位于服务器localhost:8080上的SpringMVC站点的hello控制器
- HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler
- HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器,如上url被查找控制器为:hello
- HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等
- HandlerAdapter表示处理器适配器,其按照特定的规则去执行Handler(意思就是在实现Controller接口的类中找到对应的Handler)
- Handler让具体的Controller执行(实现该接口的类执行)
- Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView
- HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet
- DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
- 视图解析器将解析的逻辑视图名传给DispatcherServlet
- DispatcherServlet根据视图解析器解析的视图结果,调用具体的视图
- 最终视图呈现给用户
3、第一个Spring MVC程序
3.1、详细步骤(“原理版”)
-
新建Module,添加Web支持
-
导入Spring MVC依赖
-
配置web.xml,注册DispatcherServlet
<!--1.注册DispatcherServlet--> <!--配置DispatcherServlet:这个是SpringMVC的核心,请求分发器、前端控制器--> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!--启动级别设置为1:当服务器启动时,它的许多配置文件也回启动;设置为1就是让咱们的这个项目和这些配置文件一起启动; 意思就是运行Tomcat进行测试时,直接使用默认服务器进入index.jsp --> <load-on-startup>1</load-on-startup> </servlet> <!--注意:在SpringMVC中,/和/*的区别: /:只匹配所有的请求,不去匹配.jsp页面 /*:匹配所有的请求,包括.jsp页面 --> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
-
编写Spring MVC的配置文件: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"> </beans>
-
添加处理映射器(SpringMVC的核心三要素)
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
-
添加处理适配器(SpringMVC的核心三要素)
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
-
添加视图解析器(SpringMVC的核心三要素)
<!--视图解析器:DispatcherServlet给他的ModelAndView--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver"> <!--前缀--> <property name="prefix" value="/WEB-INF/jsp/"/> <!--后缀--> <property name="suffix" value=".jsp"/> </bean>
-
编写操作业务controller
//注意:这里我们先实现Controller接口! public class MyController implements Controller { @Override public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { //ModelAndView:模型和视图 ModelAndView modelAndView = new ModelAndView(); //封装对象,放在modelAndView中 modelAndView.addObject("msg","Spring MVC Hello!"); //封装要跳转的视图,放到ModelAndView中 modelAndView.setViewName("hello"); return modelAndView; } }
-
将编写的类在Spring容器中进行bean注册
<!-- Handler--> <bean id="/hello" class="com.my.controller.MyController"/>
-
编写要跳转的jsp页面
-
配置Tomcat,进行测试
3.2、可能遇到的问题
访问出现404:
- 查看控制台输出,查看是否缺少jar包
- 如果jar包存在,显示无法输出,就在IDEA项目中,添加lib依赖
- 重启Tomcat解决
3.3、详细步骤(注解版)
-
新建Module,添加Web支持
-
可能会存在Maven项目资源过滤问题(看有没有对应的报错)
<build> <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>
-
导入相关依赖
-
配置web.xml文件
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <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> <!--启动级别设置为1:当服务器启动时,它的许多配置文件也回启动;设置为1就是让咱们的这个项目和这些配置文件一起启动 意思就是运行Tomcat进行测试时,直接使用默认服务器进入index.jsp--> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <!--在SpringMVC中,/和/*的区别:--> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
-
配置SpringMVC配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 自动扫描包,让指定包下的注解生效,由IOC容器统一管理 --> <context:component-scan base-package="com.my.controller"/> <!-- 让Spring MVC不处理静态资源 :例如.mp3 .mp4 .css .js .html等等,来过滤这些静态资源--> <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> <!--这也是固定配置,需要修改的只有需要注入IOC的包--> </beans>
-
创建Controller
@Controller //@RequestMapping注解可以修饰类和方法, // 这样的话,路径就存在“父子关系”,http://localhost:8080/项目名/hello/h1, // 一般直接写在方法名上,便于排查 @RequestMapping("/hello") public class AnnotationController { @RequestMapping("/h1")//真实访问地址:项目名/AnnotationController/hello public String Hello(Model model){ //封装数据:向模型中添加msg和对应的值,可以在jsp页面中取出并渲染 model.addAttribute("msg","Hello,Spring_Annotation"); //: /WEB-INF/jsp/hello.jsp return "hello";//会被视图解析器处理 } @RequestMapping("/h2") public String Hello1(Model model){ //封装数据 model.addAttribute("msg","Hello,Spring_Annotation"); return "hello";//会被视图解析器处理 } @RequestMapping("/h3") public String Hello2(Model model){ //封装数据 model.addAttribute("msg","Hello,Spring_Annotation"); return "hello";//会被视图解析器处理 } }
-
创建视图层(hello.jsp)
-
配置Tomcat测试执行
注意:在SpringMVC中,/和/*的区别
- < url-pattern > / </ url-pattern > 不会匹配到.jsp, 只针对我们编写的请求;即:.jsp 不会进入spring的 DispatcherServlet类
- < url-pattern > /* </ url-pattern > 会匹配 *.jsp,会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类,导致找不到对应的controller所以报404错
小结:SpringMVC配置的三大件(处理器映射器、处理器适配器、视图解析器),通常我们使用注解的方式,只需要手动配置视图解析器即可,余下两个开启注解驱动即可!
4、控制器和RestFul
4.1、控制器(Controller)
- 控制器复杂提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现
- 控制器负责解析用户的请求并将其转换为一个模型
- 在Spring MVC中一个控制器类可以包含多个方法
- 在Spring MVC中,对于Controller的配置方式有很多种
4.2、实现Controller接口
Controller是一个接口,在org.springframework.web.servlet.mvc包下,接口中只有一个方法:
//实现该接口的类获得控制器功能
public interface Controller {
//处理请求且返回一个模型与视图对象
ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}
步骤:
- 新建Module,添加Web支持
- 在web.xml文件中配置DispatcherServlet
- 编写SpringMVC配置文件:springmvc-servlet.xml==(只编写视图解析器,之前在上面加的处理器映射器。处理器适配器是为了讲解原理,现在可以省略也行)==
- 定义控制器(编写实现Controller接口的类。从而获取控制器功能)
- 编写在跳转的jsp页面
- 之后在springmvc-servlet.xml配置文件中,来注册bean
- 启动Tomcat,测试执行
- 具体示例参考:SpringMVC_04_Controller
说明:
- 实现接口Controller定义控制器是较老的办法
- 缺点:一个控制器中只有一个方法,如果要多个方法则需要定义多个Controller,会导致定义的方式比较麻烦
4.3、使用注解@Controller
-
@Controller注解:用于声明Spring类的实例是一个控制器(在讲IOC时还提到了另外3个注解)
-
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类,为了保证Spring能找到你的控制器,需要在配置文件中声明组件扫描
<!--扫描对应包下的注解--> <context:component-scan base-package="com.my.controller"/>
-
新建ControllerTest02类,使用注解方式
@Controller//代表这个类被Spring接管 /* * 被这类注解的所有方法,如果返回值是String类型 * 并且有具体页面的话 * 那么返回的字符串就会被视图解析器跳转 * */ public class ControllerTest02 { @RequestMapping("/t1") public String test01(Model model){ model.addAttribute("msg","ControllerTest02_t1"); return "test"; } @RequestMapping("/t2") public String test02(Model model){ model.addAttribute("msg","ControllerTest02_t2"); return "test"; } }
说明:通过这个类的示例可以看出,两个请求都可以使用同一个视图(test),但是页面的结果是不一样的(ControllerTest02_t1、ControllerTest02_t2);从这里看出视图是被复用的,而控制器和视图之间是弱耦合关系
注解是平时最常用的方式!
4.4、RequestMapping
@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径
该注解同时作用在类和方法上:http://localhost:8080/c3/t1(访问格式)
@Controller
@RequestMapping("/c3")//http://localhost:8080/c3/t1
public class ControllerTest03 {
@RequestMapping("/t1")
public String test01(Model model){
model.addAttribute("msg","ControllerTest03");
return "test";
}
}
该注解只作用在方法上:http://localhost:8080/t1(访问格式)
@Controller
//http://localhost:8080/t1
public class ControllerTest03 {
@RequestMapping("/t1")
public String test01(Model model){
model.addAttribute("msg","ControllerTest03");
return "test";
}
}
4.5、RestFul风格
概念:
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议,只是一种风格。基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存等机制
功能:
- 资源:互联网所有事物都可以被抽象为资源
- 资源操作:使用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
通过测试来理解什么是RestFul风格:
-
新建一个类(RestFulController)
-
原来的请求方式和RestFul风格对比,以及了解什么是RestFul风格(使用 @PathVariable 注解,让方法参数的值对应绑定到一个URI模板变量上)
//原来的请求方式:http://localhost:8080/add?a=1&b=2 //RestFul风格:http://localhost:8080/add/3/4 @RequestMapping("/add/{a}/{b}") public String test01(@PathVariable int a, @PathVariable int b, Model model){ int result = a+b; model.addAttribute("msg","计算1结果:"+result); return "test"; }
-
原来的风格->RestFul风格,映射访问路径必须是get请求 ;method属性指定请求的类型
方法级别的RequestMapping注解变体:@GetMapping 是一个组合注解,平时使用的会比较多;它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式
@GetMapping @PostMapping @PutMapping @DeleteMapping @PatchMapping
//@RequestMapping(value/path = "/add/{a}/{b}",method = RequestMethod.GET),映射访问路径必须是get请求,method属性指定请求的类型 @GetMapping("/add/{a}/{b}") public String test02(@PathVariable int a, @PathVariable int b, Model model){ int result = a+b; model.addAttribute("msg","计算2结果:"+result); return "test"; } @PostMapping ("/add/{a}/{b}") public String test03(@PathVariable int a, @PathVariable int b, Model model){ int result = a+b; model.addAttribute("msg","计算3结果:"+result); return "test"; }
所有的地址栏请求默认都会是 HTTP GET 类型的
小结:使用这种风格的好处
- 使路径变得更加简洁
- 获得参数更加方便,框架会自动进行类型转换
- 通过路径变量的类型可以约束访问参数,如果类型不一样,则访问不到对应的请求方法;如这里访问是的路径是/add/1/a,则路径与方法不匹配,而不会是参数转换失败
扩展:小黄鸭调试法
5、结果跳转方式
5.1、ModelAndView
设置ModelAndView对象,根据ViewName和视图解析器来跳转对应的页面
视图解析器:页面(视图解析器前缀+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 ControllerTest01 implements Controller {
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
//返回一个模型视图对象
ModelAndView mv = new ModelAndView();
mv.addObject("msg","ControllerTest01");
mv.setViewName("test");
return mv;
}
}
5.2、ServletAPI
通过设置ServletAPI , 不需要视图解析器
-
通过HttpServletResponse进行输出
-
通过HttpServletResponse实现重定向
-
通过HttpServletResponse实现转发
@Controller
public class ResultGo {
@RequestMapping("/result/t1")
public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
rsp.getWriter().println("Hello,Spring BY servlet API");
}
@RequestMapping("/result/t2")
public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
rsp.sendRedirect("/index.jsp");
}
@RequestMapping("/result/t3")
public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
//转发
req.setAttribute("msg","/result/t3");
req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
}
}
5.3、SpringMVC
通过SpringMVC来实现转发和重定向 ,无需视图解析器
1、测试(无视图解析器):
- 请求转发(默认的)不需要特别声明
- 重定向需要特别声明:redirect
@Controller
public class ServletAPI2 {
@RequestMapping("/m2/t1")
public String test01(Model model){
model.addAttribute("msg","SpringMVC方式实现结果跳转!test01");
return "forward:/WEB-INF/jsp/test.jsp";//forward可省略!!!默认
}
@RequestMapping("/m2/t2")
public String test02(Model model){
model.addAttribute("msg","SpringMVC方式实现结果跳转!test02");
return "redirect:/index.jsp";
}
}
结论:
- 测试test01时,可以正常跳转,URL没有改变(http://localhost:8080/m2/t1);请求转发
- 测试test02时,访问URL为:http://localhost:8080/m2/t2;进行重定向之后,URL发生改变:http://localhost:8080/index.jsp?msg=SpringMVC%3F%3F%3F%3F%3F%3F%3F%3F%3Ftest02
2、测试(有视图解析器):
- 请求转发(默认的),不可以加上(原因:视图解析器拼接的思想)
- 重定向:有无视图解析器,写法都是一样的(反正都要转发到一个新地方)
@RequestMapping("/m2/t3")
public String test03(Model model){
model.addAttribute("msg","SpringMVC方式实现结果跳转!test03");
return "test";
}
@RequestMapping("/m2/t4")
public String test04(Model model){
model.addAttribute("msg","SpringMVC方式实现结果跳转!test04");
return "redirect:/index.jsp";
}
6、数据处理
6.1、处理前端提交的数据
-
前端提交的参数名(域名称)和后端方法参数名一致时
//http://localhost:8080/user/t1?name=麻腾飞 @RequestMapping("/t1") public String test01(String name, Model model){ //1、接收前端参数 System.out.println("接收的前端参数为:"+name); //2、将结果返回给前端 model.addAttribute("msg",name); //3、视图跳转 return "test"; }
-
前端提交的参数名(域名称)和后端方法参数名不一致时:@RequestParam
//http://localhost:8080/user/t2?username=麻腾飞 @RequestMapping("/t2") //@RequestParam:该注解既可以表明前端需要操作该参数,也可以解决地址栏和方法参数名不一致的情况! public String test02(@RequestParam("username") String name, Model model){ model.addAttribute("msg",name); System.out.println("接收的前端参数为:"+name); return "test"; }
-
当前端提交的是一个对象时(一个实体类的所有字段)
/* * 当前端传递的参数和方法名的参数一致时,则可以直接进行匹配使用 * 当前端传递一个对象时,同时参数名也为对象类型,则前端会匹配对象实体类的字段 * 前提是前端传递参数的字段名必须与实体类的字段名保持一致 * */ //http://localhost:8080/user/t3?id=1&name=麻腾飞&age=18 @RequestMapping("/t3") public String test03(User user){ System.out.println("接收的前端参数为:"+user); return "test"; }
6.2、数据显示到前端
-
Model
@RequestMapping("/ct2/hello") public String hello(@RequestParam("username") String name, Model model){ //封装要显示到视图中的数据 //相当于req.setAttribute("name",name); model.addAttribute("msg",name); System.out.println(name); return "test"; }
-
ModelMap
@RequestMapping("/hello") public String hello(@RequestParam("username") String name, ModelMap modelMap){ //封装要显示到视图中的数据 //相当于req.setAttribute("name",name); modelMap.addAttribute("name",name); System.out.println(name); return "hello"; }
-
ModelAndView
public class ControllerTest1 implements Controller { public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { //返回一个模型视图对象 ModelAndView mv = new ModelAndView(); mv.addObject("msg","ControllerTest1"); mv.setViewName("test"); return mv; } }
三种方式的对比:
- Model 只有寥寥几个方法只适合用于储存数据,简化了新手对于Model对象的操作和理解;
- ModelMap 继承了 LinkedMap ,除了实现了自身的一些方法,同样的继承 LinkedMap 的方法和特性;
- ModelAndView 可以在储存数据的同时,可以进行设置返回的逻辑视图,进行控制展示层的跳转;
7、乱码问题
解决方式:
-
通过设置请求时的编码格式(Post提交方式中没有成功)
@PostMapping("/e/t2") public String test02(String name, Model model, HttpServletRequest request) throws UnsupportedEncodingException { //第一种解决方式,没有成功! //request.setCharacterEncoding("utf-8"); System.out.println(name); model.addAttribute("msg",name); return "test"; }
-
手动设置过滤器,并在web.xml进行引用(有效)
//第二种方式:通过手动设置过滤器,需要在web.xml文件中进行配置 public class EncodingFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { servletRequest.setCharacterEncoding("utf-8"); servletResponse.setCharacterEncoding("utf-8"); filterChain.doFilter(servletRequest,servletResponse); } @Override public void destroy() { } }
<!--配值过滤器:EncodingFilter--> <filter> <filter-name>encoding</filter-name> <filter-class>com.my.filter.EncodingFilter</filter-class> </filter> <filter-mapping> <filter-name>encoding</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
-
SpringMVC给我们提供了一个过滤器,只需要在web.xml进行配置即可(有效)
<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>
-
在网上下载大神码的自定义过滤器试试,只需要在web.xml进行相应配置就可以了(有效)
package com.kuang.filter; import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.Map; /** * 解决get和post请求 全部乱码的过滤器 */ public class GenericEncodingFilter implements Filter { @Override public void destroy() { } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { //处理response的字符编码 HttpServletResponse myResponse=(HttpServletResponse) response; myResponse.setContentType("text/html;charset=UTF-8"); // 转型为与协议相关对象 HttpServletRequest httpServletRequest = (HttpServletRequest) request; // 对request包装增强 HttpServletRequest myrequest = new MyRequest(httpServletRequest); chain.doFilter(myrequest, response); } @Override public void init(FilterConfig filterConfig) throws ServletException { } } //自定义request对象,HttpServletRequest的包装类 class MyRequest extends HttpServletRequestWrapper { private HttpServletRequest request; //是否编码的标记 private boolean hasEncode; //定义一个可以传入HttpServletRequest对象的构造函数,以便对其进行装饰 public MyRequest(HttpServletRequest request) { super(request);// super必须写 this.request = request; } // 对需要增强方法 进行覆盖 @Override public Map getParameterMap() { // 先获得请求方式 String method = request.getMethod(); if (method.equalsIgnoreCase("post")) { // post请求 try { // 处理post乱码 request.setCharacterEncoding("utf-8"); return request.getParameterMap(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } else if (method.equalsIgnoreCase("get")) { // get请求 Map<String, String[]> parameterMap = request.getParameterMap(); if (!hasEncode) { // 确保get手动编码逻辑只运行一次 for (String parameterName : parameterMap.keySet()) { String[] values = parameterMap.get(parameterName); if (values != null) { for (int i = 0; i < values.length; i++) { try { // 处理get乱码 values[i] = new String(values[i] .getBytes("ISO-8859-1"), "utf-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } } hasEncode = true; } return parameterMap; } return super.getParameterMap(); } //取一个值 @Override public String getParameter(String name) { Map<String, String[]> parameterMap = getParameterMap(); String[] values = parameterMap.get(name); if (values == null) { return null; } return values[0]; // 取回参数的第一个值 } //取所有值 @Override public String[] getParameterValues(String name) { Map<String, String[]> parameterMap = getParameterMap(); String[] values = parameterMap.get(name); return values; } }
小结:乱码问题,需要平时多注意,在尽可能能设置编码的地方,都设置为统一编码 UTF-8!
Tomcat重启问题:
- 改变Java类文件,只需要redeploy(重新部署)
- 改变.jsp等文件,只需要update calsses and resource
- 改动web.xml文件,需要重新启动tomcat
8、Json交互处理
8.1、什么是Json
- JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式,目前使用特别广泛
- 采用完全独立于编程语言的文本格式来存储和表示数据
- 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言
- 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率
在 JavaScript 语言中,一切都是对象。因此,任何JavaScript 支持的类型都可以通过 JSON 来表示,例如字符串、数字、对象、数组等。看看他的要求和语法格式:
- 对象表示为键值对,数据由逗号分隔
- 花括号保存对象
- 方括号保存数组
JSON 键值对是用来保存 JavaScript 对象的一种方式,和 JavaScript 对象的写法也大同小异,键/值对组合中的键名写在前面并用双引号 “” 包裹,使用冒号 : 分隔,然后紧接着值:
{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}
很多人搞不清楚 JSON 和 JavaScript 对象的关系,甚至连谁是谁都不清楚。其实,可以这么理解:JSON 是 JavaScript 对象的字符串表示法,它使用文本表示一个 JS (JavaScript )对象的信息,本质是一个字符串
var obj = {a: 'Hello', b: 'World'}; //这是一个对象,注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串,本质是一个字符串
8.2、Json和JavaScript对象互转
-
要实现从JSON字符串转换为JavaScript 对象,使用 JSON.parse() 方法
var obj = JSON.parse('{"a": "Hello", "b": "World"}'); //结果是 {a: 'Hello', b: 'World'}
-
要实现从JavaScript 对象转换为JSON字符串,使用 JSON.stringify() 方法
var json = JSON.stringify({a: 'Hello', b: 'World'}); //结果是 '{"a": "Hello", "b": "World"}'
代码测试:
<script type="text/javascript">
/*
* Json对象和Js对象的互相转换
* */
//编写一个JavaScript对象
var user={
name:"麻腾飞",
age:18,
sex:"男"
};
var json = JSON.stringify(user);
console.log(json);
console.log("==============")
var js = JSON.parse(json);
console.log(js);
</script>
8.3、Controller返回Json数据(Jackson使用)
- Jackson应该是目前比较好的json解析工具
- 当然工具不止这一个,比如还有阿里巴巴的 fastjson 等等
我们这里使用Jackson,需要导入它的依赖:
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.8</version>
</dependency>
步骤:
-
Jackson解析工具依赖
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.8</version> </dependency>
-
配置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"> <!--1.注册servlet--> <servlet> <servlet-name>SpringMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--通过初始化参数指定SpringMVC配置文件的位置,进行关联--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!-- 启动顺序,数字越小,启动越早 --> <load-on-startup>1</load-on-startup> </servlet> <!--所有请求都会被springmvc拦截 --> <servlet-mapping> <servlet-name>SpringMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!--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> </web-app>
-
配置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" 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.my.controller"/> <!-- 视图解析器 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver"> <!-- 前缀 --> <property name="prefix" value="/WEB-INF/jsp/" /> <!-- 后缀 --> <property name="suffix" value=".jsp" /> </bean> </beans>
-
编写控制器
@Controller public class UserController { @RequestMapping("/json") @ResponseBody public String Json01() throws JsonProcessingException { User user = new User(1,"麻腾飞",18); ObjectMapper mapper = new ObjectMapper(); String s = mapper.writeValueAsString(user); return s; } }
出现的问题:使用Jackson返回给前端Json数据出现乱码
-
@RequestMapping(value = “/json”,produces=“application/json;charset=utf-8”)中的produces
-
乱码统一解决:这样不用每次都添加produces
<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>
小结:
- @ResponseBody注解:使修饰的方法不经过视图解析器,而仅仅返回字符串(修饰方法)
- @RestController注解:修饰该类下的所有方法都不经过视图解析器,仅仅返回字符串(修饰类)
使用Jackson步骤:
- 导入Jackson依赖
- 解决乱码使用统一乱码解决方式或者produces都可以
- 创建ObjectMapper对象调用相应方法来将java对象转换为json对象并返回给前段
重点:该8.3节讲到了抽取工具类和重载方法实现代码复用的思想,参考SpringMVC_06_JsonAgain,重点理解思想!
8.4、FastJson
- fastjson.jar是阿里开发的一款专门用于Java开发的包
- 实现json对象与JavaBean对象的转换
- 实现JavaBean对象与json字符串的转换
- 实现json对象与json字符串的转换
- 实现json的转换方法很多,最后的实现结果都是一样的
FastJson依赖:
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.60</version>
</dependency>
代码测试:
@Controller
public class FastJsonController {
@RequestMapping("/f/j")
@ResponseBody
public String FastJson01(){
User user1 = new User(1,"麻腾飞",18);
User user2 = new User(1,"麻腾飞",18);
User user3 = new User(1,"麻腾飞",18);
User user4 = new User(1,"麻腾飞",18);
ArrayList<User> list = new ArrayList<>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
System.out.println("=============java对象 转 json字符串==========");
String str1 = JSON.toJSONString(list);
System.out.println(str1);
String str2 = JSON.toJSONString(user1);
System.out.println(str2);
System.out.println("=============json字符串 转 java对象=========");
User user = JSON.parseObject(str2, User.class);
System.out.println(user);
System.out.println("==============java对象 转 json对象===========");
JSONObject json = (JSONObject) JSON.toJSON(user2);
System.out.println(json);
System.out.println("==============json对象 转 java对象===========");
User user5 = JSON.toJavaObject(json, User.class);
System.out.println(user5);
return "four";
}
}
9、Ajax研究
9.1、简介
什么是Ajax?
- AJAX = Asynchronous JavaScript and XML(异步的 JavaScript 和 XML)
- AJAX 是一种在无需重新加载整个网页的情况下,能够更新部分网页的技术
- Ajax 不是一种新的编程语言,而是一种用于创建更好更快以及交互性更强的Web应用程序的技术
历史发展和工作原理
- 在 2005 年,Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词
- Google Suggest 使用 AJAX 创造出动态性极强的 web 界面:当您在谷歌的搜索框输入关键字时,JavaScript 会把这些字符发送到服务器,然后服务器会返回一个搜索建议的列表
- 就和国内百度的搜索框一样
- 传统的网页(即不用ajax技术的网页),想要更新内容或者提交一个表单,都需要重新加载整个网页
- 使用ajax技术的网页,通过在后台服务器进行少量的数据交换,就可以实现异步局部更新
- 使用Ajax,用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面
9.2、伪造Ajax
新建一个test.html文件来伪造一下ajax的效果:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>iframe测试体验页面无刷新</title>
</head>
<script>
function go(){
var url = document.getElementById("url").value;
document.getElementById("iframe1").src=url;
}
</script>
<body>
<div>
<p>请输入地址:</p>
<p>
<input type="text" id="url" value="https://www.bilibili.com/">
<input type="button" value="提交" onclick="go()">
</p>
</div>
<div>
<iframe id="iframe1" style="width: 100%;height: 500px"></iframe>
</div>
</body>
</html>
9.3、jQuery.ajax
- 纯JS原生实现Ajax我们不去讲解这里,直接使用jquery提供的,方便学习和使用,避免重复造轮子,有兴趣的同学可以去了解下JS原生XMLHttpRequest
- Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据
- jQuery 提供多个与 AJAX 有关的方法
- 通过 jQuery AJAX 方法,您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中
- jQuery 不是生产者,而是大自然搬运工
- jQuery Ajax本质就是 XMLHttpRequest,对它进行了封装,方便调用
- jQuery 是一个库,里面包含了js的大量函数
jQuery.ajax(...)
部分参数:
url:请求地址
type:请求方式,GET、POST(1.9.0之后用method)
headers:请求头
data:要发送的数据
contentType:即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
async:是否异步
timeout:设置请求超时时间(毫秒)
beforeSend:发送请求前执行的函数(全局)
complete:完成之后执行的回调函数(全局)
success:成功之后执行的回调函数(全局)
error:失败之后执行的回调函数(全局)
accepts:通过请求头发送给服务器,告诉服务器当前客户端可接受的数据类型
dataType:将服务器端返回的数据转换成指定类型
"xml": 将服务器端返回的内容转换成xml格式
"text": 将服务器端返回的内容转换成普通文本格式
"html": 将服务器端返回的内容转换成普通文本格式,在插入DOM中时,如果包含JavaScript标签,则会尝试去执行。
"script": 尝试将返回值当作JavaScript去执行,然后再将服务器端返回的内容转换成普通文本格式
"json": 将服务器端返回的内容转换成相应的JavaScript对象
"jsonp": JSONP 格式使用 JSONP 形式调用函数时,如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名,以执行回调函数
简单测试:
-
配置web.xml和SpringMVC的配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 自动扫描指定的包,下面所有注解类交给IOC容器管理 --> <context:component-scan base-package="com.kuang.controller"/> <!--静态资源过滤--> <mvc:default-servlet-handler /> <!--注解驱动配--> <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>
-
编写一个AjaxController类
@Controller public class AjaxController { @RequestMapping("/a1") public void ajax1(String name , HttpServletResponse response) throws IOException { if ("admin".equals(name)){ response.getWriter().print("true"); }else{ response.getWriter().print("false"); } } }
-
导入jquery , 可以使用在线的CDN , 也可以下载导入
-
编写(index.jsp)
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>$Title$</title>
</head>
<%--jQuery文件的引用--%>
<script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>
<script>
function a(){
$.post({
url:"${pageContext.request.contextPath}/test02",
data:{"name":$("#username").val()},
success:function (data,status){
console.log(data);
console.log(status);
},error:function (){
}
})
}
</script>
<body>
<%--失去一个焦点的时候,会发送一个请求(携带信息)到后台--%>
<input type="text" id="username" onblur="a()">
</body>
</html>
- 启动tomcat测试!打开浏览器的控制台,当我们鼠标离开输入框的时候,可以看到发出了一个ajax的请求!是后台返回给我们的结果!测试成功
9.4、SpringMVC实现
-
实体类
@Data @AllArgsConstructor @NoArgsConstructor public class User { private String name; private int age; private String sex; }
1. 编写Controller来返回给前端一个list集合
```java
@RequestMapping("/test03")
public List<User> test03(){
ArrayList<User> list = new ArrayList<>();
//添加数据
list.add(new User("ma",1,"男"));
list.add(new User("teng",1,"女"));
list.add(new User("fei",1,"男"));
return list;
}
-
前端页面(test02.jsp)
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>展示页面</title> </head> <%--jQuery文件的引用--%> <script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script> <script> $(function (){ $("#btn").click(function (){ /*console.log("111");*/ /* * 简写: * */ $.post("${pageContext.request.contextPath}/test03",function (data){ console.log(data); let html = ""; for (let i = 0; i < data.length; i++) { html += `<tr> <td>${"${data[i].name}"}</td> <td>${"${data[i].age}"}</td> <td>${"${data[i].sex}"}</td> </tr>` } $("#content").html(html) }) }) }) </script> <body> <input type="button" value="加载数据" id="btn"> <table> <tr> <td>姓名</td> <td>年龄</td> <td>性别</td> </tr> <tbody id="content"> <%--数据:后台--%> </tbody> </table> </body> </html>
9.5、注册提示效果
-
编写Controller
@RequestMapping("/test04") public String test04(String name,String password){ String msg = ""; if (name!=null){ if ("admin".equals(name)){ msg = "OK"; }else { msg = "用户名有误"; } } if (password!=null){ if ("123456".equals(password)){ msg = "OK"; }else { msg = "密码错误"; } } return msg; }
-
前端页面:login.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>用户登录</title> </head> <%--jQuery文件的引用--%> <script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script> <script> function a1(){ //用户名输入框失去焦点,后台验证用户名是否存在 $.post({ url:"${pageContext.request.contextPath}/test04", data:{"name":$("#name").val()}, success:function (data) { if (data==='OK'){ $("#userInfo").css("color", "green"); } else { $("#userInfo").css("color", "red"); } $("#userInfo").html(data); } }) } function a2(){ $.post({ url: "${pageContext.request.contextPath}/test04", data:{"password":$("#password").val()}, success:function (data){ if (data==='OK'){ $("#passwordInFo").css("color","green"); }else { $("#passwordInFo").css("color","red"); } $("#passwordInFo").html(data); } }) } </script> <body> <p> 用户名:<input type="text" id="name" onblur="a1()"> <span id="nameInFo"></span> </p> <p> 密码:<input type="text" id="password" onblur="a2()"> <span id="passwordInFo"></span> </p> </body> </html>
-
记得处理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>
-
10、拦截器
10.1、概述
- SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理
- 开发者可以自己定义一些拦截器来实现特定的功能
10.2、过滤器和拦截器的区别
- 拦截器
- 拦截器是AOP思想的具体应用
- 拦截器是SpringMVC框架自己的,只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法, 如果访问的是jsp/html/css/image/js是不会进行拦截的(自带静态资源过滤)
- 过滤器
- servlet规范中的一部分,任何javaweb工程都可以使用
- 在url-pattern中配置了/*之后,可以对所有要访问的资源进行拦截
10.3、自定义拦截器
-
新建Module,添加web支持
-
配置web.xml和applicationContext.xml
- web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!--注册DispatcherServlet--> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--加载SpringMVC配置文件--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </init-param> <!--设置启动级别--> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!--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> </web-app>
- applicationContext.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"> <!--自动扫描controller包--> <context:component-scan base-package="com.my.controller"/> <!--静态资源过滤--> <mvc:default-servlet-handler/> <!--开启注解驱动,以及防止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> <!--视图解析器--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp"/> <property name="suffix" value=".jsp"/> </bean> <!--配置拦截器--> <mvc:interceptors> <mvc:interceptor> <!--path: /admin/**:意思就是执行当前路径下,admin路径下,的所以请求 /**:意思就是执行当前路径下的所有请求 --> <mvc:mapping path="/**"/> <bean class="com.my.config.MyInterceptor"/> </mvc:interceptor> </mvc:interceptors> </beans>
3.编写一个拦截器(必须实现HandlerInterceptor接口)
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyInterceptor implements HandlerInterceptor {
/*
* return true;放行,来执行下一个拦截器
* return false;不放行
* */
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
/*return HandlerInterceptor.super.preHandle(request, response, handler);*/
System.out.println("==========拦截前==========");
return true;
}
//后两个一般日志会用到
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
System.out.println("==========拦截后==========");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
System.out.println("==========清理==========");
}
}
-
在SpringMVC的配置文件中配置拦截器
<!--配置拦截器--> <mvc:interceptors> <mvc:interceptor> <!--path: /admin/**:意思就是执行当前路径下,admin路径下,的所以请求 /**:意思就是执行当前路径下的所有请求 --> <mvc:mapping path="/**"/> <bean class="com.my.config.MyInterceptor"/> </mvc:interceptor> </mvc:interceptors>
-
编写一个Controller
@RestController public class TestHandlerInterceptor { @RequestMapping("/test01") public String test01(){ System.out.println("执行了test01测试方法!"); return "success"; } }
-
启动测试
10.4、验证用户是否登录(认证用户)
场景描述:就是在登录一个网站时候,如果用户没有登录该网站时,那么用户不能直接进入首页,而是需要先进行登录。
问题来了:网站怎么判断用户是否已经登录呢?
11、文件的上传和下载
11.1、准备工作
- 文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传
- SpringMVC上下文中默认没有装配MultipartResolver,因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能,则需要在上下文中配置MultipartResolver
- 前端表单要求:为了能上传文件,必须将表单的method设置为POST,并将enctype属性设置为multipart/form-data。只有在这样的情况下,浏览器才会把用户选择的文件以二进制数据发送给服务器
11.2、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实现类,因此,SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件
11.3、文件上传
上传文件:
- 导入文件上传的jar包,commons-fileupload , Maven会自动帮我们导入他的依赖包 commons-io包
- 配置bean:multipartResolver
- 编写前端页面
- Controller接口实现类
- 测试上传文件
怎样保存已经上传的文件:
- 采用file.Transto 来保存上传的文件
- 前端表单提交地址修改
- 访问提交测试
11.4、文件下载
文件下载步骤:
- 设置 response 响应头
- 读取文件 – InputStream
- 写出文件 – OutputStream
- 执行操作
- 关闭流 (先开后关)