1回顾MVC
1.1什么是MVC
-
MVC是模型(Model)、视图(View)、控制器(Controller)的简写,是一种软件设计规范。
-
是将业务逻辑、数据、显示分离的方法来组织代码。
-
MVC主要作用是降低了视图与业务逻辑间的双向偶合。
-
MVC不是一种设计模式,MVC是一种架构模式。当然不同的MVC存在差异。
**Model(模型):**数据模型,提供要展示的数据,因此包含数据和行为,可以认为是领域模型或JavaBean组件(包含数据和行为),不过现在一般都分离开来:Value Object(数据Dao) 和 服务层(行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能,包括数据和业务。
**View(视图):**负责进行模型的展示,一般就是我们见到的用户界面,客户想看到的东西。【JSP】
**Controller(控制器):**接收用户请求,委托给模型进行处理(状态改变),处理完毕后把返回的模型数据返回给视图,由视图负责展示。也就是说控制器做了个调度员的工作。【Servlet】
最典型的MVC就是javabean+JSP 【本质是一个servlet】+ servlet 的模式。
dao层:连接数据库
service层:调dao层,管具体的业务
servlet层:接受前端的数据,交给service处理,处理之后返回的结果显示在界面
jsp/html:前端
1.2Model1时代
- 在web早期的开发中,通常采用的都是Model1。
- Model1中,主要分为两层,视图层和模型层。【jsp+dao层+service层,因为jsp本质上是servlet】
Model1优点:架构简单,比较适合小型项目开发;
Model1缺点:JSP职责不单一,职责过重,不便于维护;
1.3Model2时代
Model2把一个项目分成三部分,包括视图、控制、模型。
- 用户发请求
- Servlet接收请求数据,并调用对应的业务逻辑方法
- 业务处理完毕,返回更新后的数据给servlet
- servlet转向到JSP,由JSP来渲染页面
- 响应给前端更新后的页面
职责分析:
Controller:控制器【servlet】
- 取得表单数据
- 调用业务逻辑
- 转向指定的页面
Model:模型
- 业务逻辑
- 保存数据的状态
View:视图
- 显示页面
Model2这样不仅提高的代码的复用率与项目的扩展性,且大大降低了项目的维护成本。Model 1模式的实现比较简单,适用于快速开发小规模项目,Model1中JSP页面身兼View和Controller两种角色,将控制逻辑和表现逻辑混杂在一起,从而导致代码的重用性非常低,增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。
方便团队开发。
1.4Servlet
1新建一个maven父工程,删掉src,导入公共的依赖。
<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建立一个普通的maven的Moudle:springmvc-01-servlet ,现在还不是一个web项目,需要 再添加Web app的支持!【不要一上来就选带webapp的】
方法:右击项目,选第二个ADD FrameWork support,选web application
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a7he58bN-1621425607517)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518165903489.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xy099xRh-1621425607519)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518165954069.png)]
3导入servlet 和 jsp 的 jar 依赖【为了保险起见,再导一次】
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
4编写一个Servlet类HelloServlet【src/main/java/com.kuang.servlet】,用来处理用户的请求【之后就要在web.xml中注册Servlet】
重写doget和dopost方法,dopost中可以调doget就可以实现复用了。主要实现的是doget方法,包括三部分
1获取前端参数2调用业务层3视图转发req.getRequestDispatcher()或者重定向resp.sendRedirect();
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//取得参数,看表单上的method是add还是delete
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/hello.jsp").forward(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
在web.xml中注册Servlet
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/helloServlet</url-pattern>
</servlet-mapping>
还可以添加一些其他的
<session-config>
<session-timeout>15</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
5编写页面,为了安全在WEB-INF目录下新建一个jsp的文件夹,新建hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
6编写一个表单页面form.jsp【web下】
表单请求的地址是helloServlet,就会找到HelloServlet类,HelloServelt就会处理表单例如看他的name为method的那一栏,然后就会请求转发到hello.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="helloServlet" method="post">
<input type="text" name="method">
<input type="submit">
</form>
</body>
</html>
注意注意action不要加杠,
7配置Tomcat,并启动测试
- 先点配置,再点页面左边的+号,选tomcat的local,然后自己配置一下。注意:自己设置的工程路径
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u2mS41Xx-1621425607520)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518173501860.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g2plQfyU-1621425607525)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518173520325.png)]
-
测试1:运行成功后,输入form.jsp,在里面输入add,页面显示执行了add方法【其实是请求转发到hello.jsp】。
-
测试2:输入/helloServlet,这样就会报500,因为这样请求是直接给了servlet处理,并没有请求参数,需要在后面加上?method=add,这样有了参数,就会给msg赋值为执行了add方法,就会显示在hello.jsp页面。但是由于是请求转发,所以页面并没有跳转到hello.jsp还是http://localhost:8080/springMVC_01_servlet/helloServlet?method=add
MVC框架要做哪些事情
- 将url映射到java类或java类的方法 .
- 封装用户提交的数据 .
- 处理请求–调用相关的业务处理–封装响应数据 .
- 将响应的数据进行渲染 . jsp / html 等表示层数据 .
说明:
常见的服务器端MVC框架有:Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF;常见前端MVC框架:vue、angularjs、react、backbone;由MVC演化出了另外一些模式如:MVP、MVVM 等等…
2SpringMVC
2.1概述
Spring MVC是Spring Framework的一部分,是基于Java实现MVC的轻量级Web框架。【所以还是Servlet】
查看官方文档:https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web
Spring MVC的特点:
- 轻量级,简单易学
- 高效 , 基于请求响应的MVC框架
- 与Spring兼容性好,无缝结合【Spring的一部分,Spring就是个大容器】
- 约定优于配置
- 功能强大:RESTful、数据验证、格式化、本地化、主题等
- 简洁灵活
Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。
DispatcherServlet的作用是将请求分发到不同的处理器【不同的方法和类】。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解形式进行开发,十分简洁;
正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等…所以我们要学习 .
最重要的一点还是用的人多 , 使用的公司多 .
2.2中心控制器
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c7JpLwEE-1621425607526)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518203221458.png)]
Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始,使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能,DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
SpringMVC的原理如下图所示:
当发起请求时被前置的控制器拦截到请求,根据请求参数生成代理请求,找到请求对应的实际控制器,控制器处理请求,创建数据模型,访问数据库,将模型响应给中心控制器,控制器使用模型与视图渲染视图结果,将结果返回给中心控制器,再将结果返回给请求者。
服务器运行成功,输入请求,回车就把请求给了前端控制器;这里的前端控制器就是个DispatcherServlet;然后交给处理器也就是Controller,然后做一堆操作【345】返回给前端控制器。
2.3SpringMVC执行原理【重点】
图为SpringMVC的一个较完整的流程图,实线表示SpringMVC框架提供的技术,不需要开发者实现,虚线表示需要开发者实现。
虚线就是controller调业务层,
简要分析执行流程
-
DispatcherServlet表示前置控制器、请求分发器,是整个SpringMVC的控制中心。用户发出请求,DispatcherServlet接收请求并拦截请求。
<servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
经过/的请求都可以被接收,如果这写的是/hello代表着hello之后的请求才会请求,一般就写杠
我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
如上url拆分成三部分:
http://localhost:8080服务器域名
SpringMVC部署在服务器上的web站点【就是tomcat自己配的工程名】
hello表示控制器
通过分析,如上url表示为:请求位于服务器localhost:8080上的SpringMVC站点的hello控制器【就是控制器的id】。
-
HandlerMapping为处理器映射。【代码中:处理映射器BeanNameUrlHandlerMapping是要按bean找的,所以得给控制器创建bean】DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url****查找Handler。
【3.1案例里面的请求的url是http://localhost:8080/springMVC_02/hello】
-
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器,如上url被查找控制器为:hello。
-
HandlerExecution**将解析后的信息传递给DispatcherServlet,**如解析控制器映射等。
-
HandlerAdapter表示处理器适配器,其按照特定的规则去执行Handler。
-
Handler让具体的Controller执行。
-
Controller将具体的执行信息返回给HandlerAdapter【返回的时候携带了数据和视图】,如ModelAndView。【自己要写的—调业务层,封装对象,跳转视图】
-
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
-
DispatcherServlet调用视图解析器[1获取了ModelAndView的数据2解析ModelAndView的视图名字3拼接试图名字找到对应视图](ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
-
视图解析器将解析的逻辑视图名传给DispatcherServlet。
-
DispatcherServlet根据视图解析器解析的视图结果,调用具体的视图。
-
最终视图呈现给用户。
自己总结:请求给了DispatcherServlet,DispatcherServlet调用HandlerMapping根据url查找handler,handler根据url找到控制器,然后把这个信息返回给DispatcherServlet;DispatcherServlet又通知HandlerAdapter去执行handler,handler去让具体的那个控制器执行,控制器把执行结果返回给HandlerAdapter,HandlerAdapter又传给了DispatcherServlet;DispatcherServlet又去调用视图解析器,视图解析器将解析的视图名和解析的视图结果传给DispatcherServlet,DispatcherServlet根据解析的视图结果调用具体的试图,呈现出来。
对应3.1的代码:先是web.xml对DispatcherServlet的配置,然后就找到了springmvc-servlet.xml,就会找到处理器映射器,他就会找baen,找到了hello这个控制器,就找到了那个控制器去处理,返回一个ModelAndView交给视图解析器,展示出来。
3HelloSpringMVC
3.1配置版
-
新建一个Moudle , springmvc-02-hello , 添加web的支持!
-
确定导入了SpringMVC 的依赖!
-
配置web.xml , 注册DispatcherServlet【自己并没有写这个类,spring写好的】
【servlet】和【servlet-mapping】,另外需要关联一个springmvc的配置文件,所以需要在【resources下】写一个配置文件springmvc-servlet.xml【步骤4】
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <!--1.注册DispatcherServlet--> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!--启动级别-1--> <load-on-startup>1</load-on-startup> </servlet> <!--/ 匹配所有的请求;不会匹配.jsp页面)--> <!--/* 匹配所有的请求;会匹配.jsp页面,不要用这个,会一直跳转成死循环)--> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
-
编写SpringMVC 的 配置文件!名称:springmvc-servlet.xml : [servletname]-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-servlet.xml】添加 处理映射器【这个类是spring写的】【567是必要的】
注意:处理映射器BeanNameUrlHandlerMapping是要按bean找的,所以得给控制器创建bean
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
-
在【springmvc-servlet.xml】添加 处理器适配器【这个类是spring写的】
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
-
在【springmvc-servlet.xml】添加 视图解析器【这个类是spring写的】
<!--视图解析器: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>
注意前缀后面有个杠,目录的意思;就是把url分解开了,例如原来的
req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);
前缀/WEB-INF/jsp/ 后缀.jsp 所以以后只写中间的hello就好了
-
编写我们要操作业务Controller ,要么实现Controller接口,要么增加注解;需要返回一个ModelAndView【new一个再返回】,装数据【set】,视图跳转【设置试图名字就好】;
在src/main/Java下建一个包【com.kuang.controller】
import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.Controller; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class HelloController implements Controller { public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { //ModelAndView 模型和视图 ModelAndView mv = new ModelAndView(); //封装对象,放在ModelAndView中。Model mv.addObject("msg","HelloSpringMVC!"); //就是原来的req.getSession().setAttribute("msg","执行了delete方法"); //封装要跳转的视图,放在ModelAndView中,就是原来的请求转发 mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp return mv; } }
因为要跳转,所以要写跳转的页面/WEB-INF/jsp/hello.jsp【步骤10】
-
将自己的类交给SpringIOC容器,在【springmvc-servlet.xml】注册bean
因为步骤8写了一个类,所以要注册到spring中
为什么起名叫/hello呢?是通过这个id去访问HelloController?就和原来配servletmapping的url是不是一样的效果?
<bean id="/hello" class="com.kuang.controller.HelloController"/>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X9urJAqP-1621425607529)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518213419975.png)]
测试了一下,确实是通过这个id找的controller
-
写要跳转的jsp页面,显示ModelandView存放的数据,以及我们的正常页面;
【web-if下建一个jsp文件夹,下面将一个hello.jsp】
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> ${msg} </body> </html>
-
配置Tomcat 启动测试!
和之前的对比:不用配Servlet,没有Servlet包,有的是Controller。
注意事项;如果jar包存在,显示无法输出,就在IDEA的项目发布中,添加lib依赖!
点右上角,要手动在web-inf下建一个lib的文件夹,
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l0EsZstI-1621425607529)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518212443182.png)]
点开+号把第一个library里面的所有jar包导入到lib里面
测试:启动服务器,输入hello,就会到controller去处理了。然后会把文字给msg然后显示在hello.jsp
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lO8RGSpH-1621425607530)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210518212756954.png)]
分析:HelloController要返回一个模型和视图,模型去存数据,视图去显示跳转到hello那个页面
全程干了什么【写一个controller,注册一个bean,写一个视图hello.jsp】
1在web.xml配置了DispatcherServlet
2在springmvc-servlet.xml添加了处理映射器、处理适配器、视图解析器
3写了一个controller并把它注册到springmvc-servlet.xml【spring的容器】
4测试
3.2注解版
-
新建一个Moudle , springmvc-03-annotation, 再添加web的支持!
-
由于Maven可能存在资源过滤的问题,我们将配置完善【只要使用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>
-
在pom.xml文件引入相关的依赖:主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了!
确认包要都导进来
-
配置web.xml
首先要手动打开项目结构,----Artifacts—选中项目—手动给web-if增加一个lib的目录,把依赖都导进去—配置web.xml
/ 和 /* 的区别:< url-pattern > / </ url-pattern > 不会匹配到.jsp, 只针对我们编写的请求;即:.jsp 不会进入spring的 DispatcherServlet类 。< url-pattern > /* </ url-pattern > 会匹配 *.jsp,会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类,导致找不到对应的controller所以报404错。
-
-
注意web.xml版本问题,要最新版!
-
注册DispatcherServlet
-
关联SpringMVC的配置文件【需要自己写,步骤5】
-
启动级别为1
-
映射路径为 / 【不要用/*,会404】
<?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> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>SpringMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>
-
-
-
添加Spring MVC配置文件【resources下的springmvc-servlet.xml】
配置的形式与Spring容器配置基本类似,
要干的事情
- 让IOC的注解生效
- 静态资源过滤 :HTML . JS . CSS . 图片 , 视频 …
- MVC的注解驱动
- 配置视图解析器
-
为了支持基于注解的IOC,设置了自动扫描包的功能,让指定包下的注解生效,由IOC容器统一管理,在[src/main/java]下建立包com.kuang.controller, <context:component-scan base-package=“com.kuang.controller”/>
-
让Spring MVC不处理静态资源 【.css等文件】 <mvc:default-servlet-handler />
-
支持mvc注解驱动,不需要再写处理映射器和处理适配器,一句话搞定 <mvc:annotation-driven />,会自动开启并注入那两个 在spring中一般采用@RequestMapping注解来完成映射关系, 要想使@RequestMapping注解生效, 必须向上下文中注册DefaultAnnotationHandlerMapping 和一个AnnotationMethodHandlerAdapter实例,这两个实例分别在类级别和方法级别处理; 而annotation-driven配置帮助我们自动完成上述两个实例的注入。
-
视图解析器,还是通过bean配置
在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下,这样可以保证视图安全,因为这个目录下的文件,客户端不能直接访问。【所以要在web-if下建立一个目录】
前面这几步的内容以后就复制粘贴
<?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"/> <!-- 让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>
-
创建Controller
上面扫描的包是com.kuang.controller,为了让这里面的注解生效;编写一个Java控制类:com.kuang.controller.HelloController , 在类上加上注解@Controller,这一步就代替了原来是配置文件手动配置这个类的bean,所以这一步就会对原来的bean的id也就是服务器运行后真实的访问地址(输入什么)进行设置,通过RequestMapping。同时这个类里面的方法会返回一个字符串,也就是视图的名字的一部分,加上配置的前缀和后缀可以拼成完整的。
-
@Controller是为了让Spring IOC容器初始化时自动扫描到;
-
@RequestMapping是为了映射请求路径,注意加杠,这里因为类与方法上都有映射所以访问时应该是http://localhost:8080/springMVC_03_annotation/HelloController/hello;
-
方法中声明Model类型的参数是为了把Action中的数据带到视图中;
-
方法返回的结果是视图的名称hello,加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。
@Controller @RequestMapping("/HelloController") public class HelloController { @RequestMapping("/hello") //真实访问地址 :工程路径/HelloController/hello public String hello(Model model){ //这个方法就是封装数据,返回一个视图的名字(字符串) //封装数据 model.addAttribute("msg","hellospringmvc");//向模型中添加属性msg与值,可以在JSP页面中取出并渲染 return "hello";//和前缀和后缀拼接,视图的完整名字是web-inf/jsp/hello.jsp } }
-
-
创建视图层
在WEB-INF/ jsp目录中创建hello.jsp , 视图可以直接取出并展示从Controller带回的信息;
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> ${msg} </body> </html>
-
配置Tomcat运行
在地址栏输入HelloController/hello
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-khkEcKwC-1621425607530)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210519155903116.png)]
小结
实现步骤其实非常的简单:
-
新建一个web项目
-
导入相关jar包
-
编写web.xml , 注册DispatcherServlet
-
编写springmvc配置文件
-
接下来就是去创建对应的控制类 , controller
-
最后完善前端视图和controller之间的对应
-
测试运行调试.
使用springMVC必须配置的三大件:
处理器映射器、处理器适配器、视图解析器
通常,我们只需要手动配置视图解析器,而处理器映射器和处理器适配器只需要开启注解驱动即可,而省去了大段的xml配置
4控制器Controller
4.1控制器Controller
- 控制器复杂提供访问应用程序的行为,通常通过接口定义或注解定义两种方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在Spring MVC中一个控制器类可以包含多个方法
- 在Spring MVC中,对于Controller的配置方式有很多种
4.2实现Controller接口【org.springframework.web.servlet.mvc.Controller】
准备工作:新建一个模块,并添加web支持,手动添加lib,导包,写好web.xml和配置文件springmvc-servlet.xml【只留下视图解析器】,在web-if下建文件夹放静态资源,新建com.kuang.controller放控制器。
Controller是一个接口,在org.springframework.web.servlet.mvc包下,接口中只有一个方法;
//实现该接口的类获得控制器功能
public interface Controller {
//处理请求且返回一个模型与视图对象
ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}
1 编写一个ControllerTest实现Controller接口
public class ControllerTest implements Controller {
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
ModelAndView mv = new ModelAndView();
mv.addObject("msg","ControllerTest");
mv.setViewName("test");
return mv;
}
}
2编写完毕后,去Spring配置文件中注册请求的bean;name对应请求路径【注意加杠,不加杠会出错】,class对应处理请求的类
<bean id="/t1" class="com.kuang.controller.ControllerTest"/>
<bean name="/t1" class="com.kuang.controller.ControllerTest"/>
3编写前端test.jsp,注意在WEB-INF/jsp目录下编写,对应我们的视图解析器
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
4测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UAAo40Wc-1621425607531)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210519163740158.png)]
说明:
- 实现接口Controller定义控制器是较老的办法
- 缺点是:一个控制器中只有一个方法,如果要多个方法则需要定义多个Controller;定义的方式比较麻烦;
4.3使用注解@Controller
【org.springframework.stereotype.Controller;】
准备工作:新建一个模块,并添加web支持,手动添加lib,导包,写好web.xml和配置文件springmvc-servlet.xml,在web-if下建文件夹放静态资源,新建com.kuang.controller放控制器。
-
@Controller
@Controller public class ControllerTest2 { @RequestMapping("/t2") public String test2(Model model){ model.addAttribute("msg","test2"); return "test"; } }
-
@Controller public class ControllerTest2 { @RequestMapping("/t2") public String test2(Model model){ model.addAttribute("msg","test2"); return "test"; } }
-
注解类型用于声明Spring类的实例是一个控制器(在讲IOC时还提到了另外3个注解)
@Component 组件
@Service 业务层
@Repository dao层 -
-
-
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类,为了保证Spring能找到你的控制器,需要在配置文件中声明组件扫描。
<context:component-scan base-package="com.kuang.controller"/>
增加一个ControllerTest2类,使用注解实现;
@Controller注解的类会自动添加到Spring上下文中
Spring MVC会自动实例化一个Model对象用于向视图中传值
@Controller
public class ControllerTest2 {
@RequestMapping("/t2")
public String test2(Model model){
model.addAttribute("msg","test2");
return "test";
}
//这里可以写多个方法
}
测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kxen0NJ3-1621425607532)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210519165514841.png)]
可以发现,我们的两个请求都可以指向一个视图,但是页面结果的结果是不一样的,从这里可以看出视图test.jsp是被复用的,而控制器与视图之间是弱偶合关系。
注解方式是平时使用的最多的方式!
4.4RequestMapping
@RequestMapping
- @RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
1 只注解在方法上面,访问路径:http://localhost:8080 / 项目名 / h1
@Controller
public class TestController {
@RequestMapping("/h1")
public String test(){
return "test";
}
}
2同时注解类与方法
访问路径:http://localhost:8080 / 项目名/ admin /h1 , 需要先指定类的路径再指定方法的路径;
@Controller
@RequestMapping("/admin")
public class TestController {
@RequestMapping("/h1")
public String test(){
return "test";
}
所以可以在方法上直接写死 @RequestMapping("/ admin/h1"),类上就可以不用写了。
5RestFul风格
5.1介绍
概念
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
5.2学习测试
5.2.1测试
-
在新建一个类 RestFulController【在com.kuang.controller】
原来的方式:通过参数也就是地址
@Controller public class RestFulController { @RequestMapping("/add") public String test1(int a,int b,Model model){ int res=a+b; model.addAttribute("msg",res); return "test"; } }
测试
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xXEqyHbP-1621425607533)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210519171312886.png)]
参数在访问前端的时候传。
-
在Spring MVC中可以使用 @PathVariable 注解,让方法参数的值对应绑定到一个URI模板变量上。
原来的http://localhost:8080/springMVC_04/add?a=1&b=2
现在的http://localhost:8080/springMVC_04/add/1/2
@Controller
public class RestFulController {
@RequestMapping("/add/{a}/{b}")
public String test1(@PathVariable int a, @PathVariable int b, Model model){
int res=a+b;
model.addAttribute("msg",res);
return "test";
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F59ramwo-1621425607533)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210519171651032.png)]
3使用路径变量的好处?
-
- 使路径变得更加简洁;
- 获得参数更加方便,框架会自动进行类型转换。
- 通过路径变量的类型可以约束访问参数,如果类型不一样,则访问不到对应的请求方法,如这里访问是的路径是/commit/1/a,则路径与方法不匹配,而不会是参数转换失败。【因为方法里面设定的是int,int,修改类型为int,String就可以了】
- 原来的方法会暴露很多参数,再结合5.2.2会使url更加安全,http://localhost:8080/springMVC_04/add/1/2只看这个也不知道是什么请求。
- 简洁高效安全。
5.2.2使用method属性指定请求类型
**要用到RequestMethod这个是个枚举类,里面有GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等,用于约束请求的类型,可以收窄请求范围。
使用浏览器地址栏进行访问默认是Get请求,而且要使用这种的时候,前面的地址要用value或者path,不能用name;而且不能写其他方法例如post就会报错
@RequestMapping(value="/add/{a}/{b}",method = RequestMethod.GET)
还有种更加简单的方式
@GetMapping("/add/{a}/{b}")
同理还有@DeleteMapping等@PostMapping@PutMapping@DeleteMapping@PatchMapping组合注解,平时使用的会比较多!。
如果都是通过浏览器进行访问的话,就是get请求;其他请求可以利用表单【创建一个表单,表单的action是方法的地址】等实现。
@GetMapping("/add/{a}/{b}")
public String test1(@PathVariable int a, @PathVariable int b, Model model){
int res=a+b;
model.addAttribute("msg",res);
return "test";
}
@PostMapping("/add/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable int b, Model model){
int res=a+b;
model.addAttribute("msg","结果为"+res);
return "test";
}
在控制器中同时存在这两个方法,因为浏览器默认访问get请求,所以会走下面的方法,虽然两个方法的访问地址是一样的,但是请求方式并不一样。【实现了url的复用】。
小结:
400的错误都是请求的错误,500的错误就是代码的错误。
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。
所有的地址栏请求默认都会是 HTTP GET 类型的。