SpringMVC：使用注解、RestFul风格介绍
第一个SpringMVC程序
1、新建一个Moudle ， 添加web的支持！
2、确定导入了SpringMVC 的依赖！
3、配置web.xml ， 注册DispatcherServlet
4、配置Tomcat
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">
<!--配置DispatchServlet：springMVC的核心，请求分发器，前端控制器-->
<servlet>
<servlet-name>ljy</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--dispatchservlet要绑定spring的配置文件-->
<init-param>
<param-name>contextConfigLocation</param-name>
<!--绑定的路径是资源文件-->
<param-value>classpath:ljy-servlet.xml</param-value>
</init-param>
<!--启动级别：1-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--
在SpringMVC中： / /*
/：只匹配所有的请求，不会去匹配jsp页面
/* ： 匹配所有的请求，包括jsp页面
-->
<servlet-mapping>
<servlet-name>ljy</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>
在配置文件中添加 处理映射器、处理器适配器、视图解析器
<!--处理器映射器-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--视图解析器:模板引擎Thymeleaf Freemarker..-->
<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 HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象，放在ModelAndView中。Model
mv.addObject("msg","HelloSpringMVC!");
//封装要跳转的视图，放在ModelAndView中
mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}
再将自己的类交给springioc容器，注册bean
<!--Handler-->
<bean id="/ljy" class="cmo.li.controller.HelloController"/>
可能遇到的问题：访问出现404，排查步骤：
- 查看控制台输出，看一下是不是缺少了什么jar包。
- 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
- 重启Tomcat 即可解决！
小结：看这个估计大部分同学都能理解其中的原理了，但是我们实际开发才不会这么写，不然就疯了，还学这个玩意干嘛！我们来看个注解版实现，这才是SpringMVC的精髓，到底有多么简单，看这个图就知道了
使用注解写SpringMVc
步骤
1、新建一个Moudle，springmvc-03-hello-annotation 。添加web支持！
2、由于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>
3、在pom.xml文件引入相关的依赖：主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我在父依赖中已经引入了！
<!--导入依赖-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<!--EL表达式-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.18</version>
</dependency>
</dependencies>
4、配置web.xml
<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>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
注意点：
- 注意web.xml版本问题，要最新版
- 注册DispatcherServlet
- 关联SpringMVC的配置文件
- 启动级别为1
- 映射路径为/【不要用/*，会报404】
5、添加Spring MVC配置文件
在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：
- 让IOC的注解生效
- 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 .....
- MVC的注解驱动
- 配置视图解析器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns: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.li.controller"/>
<!-- 让Spring MVC不处理静态资源 如：.css .js .html .mp3...-->
<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/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。
6、创建controller
编写一个Java控制类：com.li.controller.HelloController , 注意编码规范
package com.li.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller //让spring IOC容器初始化时自动扫描到
//是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/Hello/h1；
@RequestMapping("/hello")
public class HelloController {
//localhost:8080/hello/h1
@RequestMapping("/h1")
public String hello(Model model) {
//封装数据
model.addAttribute("msg", "hello world!");
return "hello";//会被视图解析器处理
}
@RequestMapping("/h2")
public String hello2(Model model) {
//封装数据
model.addAttribute("msg", "hello lll!");
return "hello";//会被视图解析器处理
}
}
- @Controller是为了让Spring IOC容器初始化时自动扫描到；
- @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
- 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
- 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。
7、创建视图层
在WEB-INF/ jsp目录中创建hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；
可以通过EL表示取出Model中存放的值，或者对象；
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${msg}
</body>
</html>
8、配置Tomcat
配置Tomcat ， 开启服务器 ， 访问 对应的请求路径！
小结
实现步骤其实非常的简单：
- 新建一个web项目
- 导入相关jar包
- 编写web.xml , 注册DispatcherServlet
- 编写springmvc配置文件
- 接下来就是去创建对应的控制类 , controller
- 最后完善前端视图和controller之间的对应
- 测试运行调试.
注意： 用Spring MVC必须配置的三大件：（在注解中，前两个都替我们做了，我们只需要做视图解析器的部分）
- 处理器映射器
- 处理器适配器
- 视图解析器
通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置
Controller
控制器 Controller
- 控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
- 控制器负责解析用户的请求并将其转换为一个模型。
- 在Spring MVC中一个控制器类可以包含多个方法
- 在Spring MVC中，对于Controller的配置方式有很多种
实现Controller接口
Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；
//实现该接口的类获得控制器功能
public interface Controller {
//处理请求且返回一个模型与视图对象
ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponsevar2) throws Exception;
}
测试：
1、新建一个Module，
2、编写一个Controller类，
//只要实现了Controller接口的类，说明这就是一个控制器了
public class ControllerTest1 implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
ModelAndView mv = new ModelAndView();
mv.addObject("msg","controller1");
mv.setViewName("tset1");
return null;
}
}
3、编写完毕后，去Spring配置文件中注册请求的bean；name对应请求路径，class对应处理请求的类
<bean id="/qwe" class="com.li.controller.ControllerTest1"/>
4、在jsp包里创建一个jsp页面和mv.setViewName里的名字对应
说明：
- 实现接口Controller定义控制器是较老的办法
- 缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；
使用注解@Controller
@Component 组件
@Service service层
@Controller controller层
@Respository dao层
- @Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）；
- Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。
在springmvc-servlet.xml中添加：
<!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
<context:component-scan base-package="com.kuang.controller"/>
增加一个ControllerTest2类，使用注解实现；
package com.li.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller //代表这个类会被spring接管，被这个注解的类中的所有方法
//如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析。
public class ControllerTest2 {
@RequestMapping("/t2")
public String test1(Model model) {
model.addAttribute("msg", "controllertest2");
return "test1"; //WEB-INF/jsp/tset1.jsp
}
}
注意：test1是创建的jsp文件名字。
运行Tomcat测试
可以发现，我们的两个请求（ControllerTest1和ControllerTest2）都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。
注解是平时开发中使用最多的方式
RequestMapping
@RequestMapping
- @RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
- 为了测试结论更加准确，我们可以加上一个项目名测试 myweb
- 只注解在方法上面
@Controller
@RequestMapping("/c3")
public class ControllerTest3 {
@RequestMapping("/t2")
public String test1(Model model){
model.addAttribute("msg", "qwer");
return "test1";
}
}
访问路径就是：http://localhost:8080/c3/t2
- 也可以不要类上面那个RequestMapping注解 路径就去掉c6
- 为了方便检查代码，我们一般只在方法上写 比如 @RequestMapping("/c3/t2") 这样样的访问路径和上面代码的访问路径是一样的
RestFul风格
概念
Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
功能
资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应 添加、 删除、修改、查询。
传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，post和get。
-
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
学习测试
原来的风格
1、在新建一个类 RestFulController
@Controller
public class RestFulController {
//原来的url：http://localhost:8080/add?a=1&b=4
@RequestMapping("/add/)
public String test1(int a,i nt b, Model model){
int res=a+b;
model.addAttribute("msg","结果为"+res);
return "test1";
}
}
2、启动tomcat测试
http://localhost:8080/add?a=1&b=4 才能成功
RestFul风格代码
1、在新建一个类 RestFulController
在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。
package com.li.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class RestFulController {
//原来的url：http://localhost:8080/add?a=1&b=4
// RestFul的url :http://localhost:8080/add/1/4
@RequestMapping("/add/{a}/{b}")
public String test1(@PathVariable int a, @PathVariable int b, Model model) {
int res = a + b;
model.addAttribute("msg", "结果为" + res);
return "test1";
}
}
2、启动tomcat测试
RestFul的url :http://localhost:8080/add/1/4
3、思考：使用路径变量的好处？
-
- 使路径变得更加简洁；
- 安全
- 获得参数更加方便，框架会自动进行类型转换。
- 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/add/1/2，则路径与方法不匹配，而不会是参数转换失败。
4、我们来修改下对应的参数类型，再次测试
//映射访问路径
@RequestMapping("/commit/{p1}/{p2}")
public String index(@PathVariable int p1, @PathVariable String p2, Model model){
String result = p1+p2;
//Spring MVC会自动实例化一个Model对象用于向视图中传值
model.addAttribute("msg", "结果："+result);
//返回视图位置
return "test1";
}
访问：localhost:8080/commit/1/a
结果：1a
使用method属性指定请求类型
用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等
我们来测试一下：
- 增加一个方法
//映射访问路径,必须是POST请求
@RequestMapping(value = "/hello",method = RequestMethod.POST)
public String index2(Model model){
model.addAttribute("msg", "hello!");
return "test1";
}
- 我们使用浏览器地址栏进行访问默认是Get请求，会报错405
- 如果将POST修改为GET则正常了；
//映射访问路径,必须是Get请求
@RequestMapping(value = "/hello",method = RequestMethod.GET)
public String index2(Model model){
model.addAttribute("msg", "hello!");
return "test1";
}
小结
Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。
所有的地址栏请求默认都会是 HTTP GET 类型的。
方法级别的注解变体有如下几个：组合注解
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@GetMapping 是一个组合注解，平时使用的会比较多！
它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
扩展:小黄鸭调试法
场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。
场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候就想出答案走了，留下一脸茫然的你。
其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它是我们软件工程中最常使用调试方法之一。
此概念据说来自《程序员修炼之道》书中的一个故事，传说程序大师随身携带一只小黄鸭，在调试代码的时候会在桌上放上这只小黄鸭，然后详细地向鸭子解释每行代码，然后很快就将问题定位修复了。
