SpringMVC-GetMapping注解总结
@GetMapping是一个组合注解，是@RequestMapping(method= RequestMethod.GET)的缩写。该注解将HTTP Get 映射到特定的处理方法上。
所以此处个人的理解，@GetMapping可以算是@RequestMapping的子集，可能该说法不是很严谨，但是我个人暂时是这么理解的。Spirng与Web集成
1.1 ApplicationContext应用上下文获取方式#
应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。
1.2 Spring提供获取应用上下文的工具#
上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。
所以我们需要做的只有两件事：
在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
使用WebApplicationContextUtils获得应用上下文对象ApplicationContext
- 哪一些情况下，浏览器会发送get请求
a. 直接在浏览器地址栏输入某个地址
b. 点击链接
c. 表单默认的提交方式
2.特点：
a. 请求参数会添加到请求资源路劲的后面，只能添加少量参数
b. 请求参数会显示在浏览器地址栏，路由器会记录请求地址
5：@PostMapping
- 哪一些情况下，浏览器会发送post请求
a. 设置表单method = "post"
2.特点：
a. 请求参数添加到实体内容里面，可以添加大量的参数（也解释了为什么浏览器地址栏不能发送post请求，在地址栏里我们只能填写URL，并不能进入到Http包的实体当中）
b. 相对安全，但是，post请求不会对请求参数进行加密处理（可以使用https协议来保证数据安全）。
6:RequestBody
如果传输的是单层json对象，我们后台可以直接用 @RequestParam接收
$.ajax({
type : "post",
dataType : "json",
url : "/testRequestBody",
data:{name:"韦德",
age:35
},success : function(result) {
}});
@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestParamMap<String, Object> map) {
System.out.println(map);// {name=韦德, age=35}
return"index";
}如果传输的是多层嵌套json对象，这个时候会就会出现数据丢失问题
@RequestBody很好的解决了这个问题，它会把前台传输过来的json转化为后台对应的对象
$.ajax({
type : "post",
dataType : "json",
url : "/testRequestBody",
contentType:"application/json",
data:JSON.stringify({name:"韦德",
win:[2006,2012,2013],
age:35}),
success : function(result) {
}});
@RequestMapping("/testRequestBody")
public StringtestRequestBody(@RequestBodyMap<String, Object> map) {
System.out.println(map);//{name=韦德, win=[2006, 2012, 2013], age=35}
return"index";
}需要注意的是前台需要指定contentType为"application/json"
同时要把json对象转化为String，否则后台不能识别
7:@ResponseBody
@ResponseBody注解到方法上，直接传回结果（字符串）
ajax请求返回json格式，往常我们这样做
privatevoid writeJson(HttpServletResponseresponse,Object object) {
String json =JSON.toJSONString(object);
response.setCharacterEncoding("UTF-8");
response.setContentType("application/json; charset=utf-8");
PrintWriter out = null;
try {out = response.getWriter();
out.write(json);} catch (IOException e) {
e.printStackTrace();
} finally {if (out != null) {
out.close();
}}
}
这个时候 @ResponseBody就派上用场了，只需要一个注解，全部搞定
$.ajax({
type : "post",
dataType : "json",
url : "/testResponseBody",
success : function(result) {console.info(result);
}});
@RequestMapping("/testResponseBody")
@ResponseBody
public Map<String, Object>testRequestBody(){
Map<String,Object> result = new HashMap<String,Object>();
result.put("name", "韦德");
result.put("age", 35);
return result;
}
前台console输出
{"age": 35,
"name": "韦德"}
说一些个人的看法，非技术层面上的，一个 API 何时用 GET、POST 甚至 PUT 请求。
首先引入一个副作用的概念，副作用指当你发送完一个请求以后，网站上的资源状态没有发生修改，即认为这个请求是无副作用的。比如注册用户这个请求是有副作用的，获取用户详情可以认为是无副作用的。
再引入一个幂等性的概念，幂等是说，一个请求原封不动的发送N次和M次（N不等于M，N和M都大于1）服务器上资源的状态最终是一致的。比如发贴是非幂等的，重放10次发贴请求会创建10个帖子。但修改帖子内容是幂等的，一个修改请求重放无论多少次，帖子最终状态都是一致的。（前提是同一个修改操作重复10次）
唠叨了这么多，回过头来，何时用 PUT POST GET DELETE：
GET：无副作用，幂等
PUT：副作用，幂等
POST：副作用，非幂等
DELETE：副作用，幂等
这么看的话，DELETE 和 PUT 请求好像毫无区别。为了进一步区分这些请求方式的应用场景，我们再引入一个技术特性，request body，就是大家广为流传的 "POST 请求传输数据量比较大“ 这一说法的来源。
POST/PUT 请求可以通过传递 request body 来发送大量的数据，而 GET/DELETE 不能。
所以上面的表格需要再加一项：
GET：无副作用，幂等，不可带 Request Body
PUT：副作用，幂等，可以带 Request Body
POST：副作用，非幂等，可以带 Request Body
DELETE：副作用，幂等，不可带 Request Body
- params，headers
params：
指定request中必须包含某些参数值，才让该方法处理。
headers：
指定request中必须包含某些指定的header值，才能让该方法处理请求。- consumes，produces
consumes：
指定处理请求的提交内容类型（Content-Type），例如application/json,text/html;
produces：
指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
2：@PathVariable
用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数。如：
3: @RequestParam
@RequestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter("name")，
它有三个常用参数：defaultValue = "0", required = false,value="isApp"；
defaultValue 表示设置默认值，required通过boolean设置是否是必须要传入的参数，value 值表示接受的传入的参数类型。
形式如项目中的：
public ObjectuserMemberShop(@RequestParam(required= false,value="corpId")IntegercorpId,
@RequestParam("uid")Longuid){
}参考一篇文章，其中讲了@controller、@service、@repository注解，自己复制下再总结下自己的一些想法。
如果一个类带了@controller、@service、@repository注解，将自动注册到Spring容器，不需要再在applicationContext.xml文件定义bean了。
首先：
Controller层使用@Controller注解
Service层使用@Service注解
Dao层使用@Repository注解
@Controller可注解于类上，声明该类为SpringMVC的Controller对象。
简单说：被@Controller注解的类是一个控制器，该类的方法是相应的动作。
@Service可注解于类上，
简单说：
1.声明该类是一个bean。如
@Service
@Scope("prototype")
public class Zoo
2.Zoo.java在bean中的id是"zoo"，即类名且首字母小写
例：@Service("userService")注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action。
dao层使用@repository注解
@Repository可注解于类上，
@Repository(value="userDao")注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。
当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，
就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即可。
java 解析URL里的协议及参数工具类，解析URL中的主域名，并统一把协议修改成http或去掉协议
public class UrlDomainUtils {
private static final Logger LOGGER = LoggerFactory.getLogger(UrlDomainUtils.class);
/**
* 获取主域名，即URL头
* @param url
* @return
*/
public static String getDomainHost(String url){
String pattern = "^((http://)|(https://))?([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,6}(/)";
Pattern p = Pattern.compile(pattern);
String line = url;
Matcher m = p.matcher(line);
if(m.find()){
//匹配结果
String domain = m.group();
LOGGER.info("解析的URL主域名是------------>{} 原始url is {}" ,domain,url);
domain = domain.replace("https","http");
LOGGER.info("修改解析出的URL主域名的协议成http------------>{} 原始url is {}" ,domain,url);// domain = domain.replace("http://","");
// LOGGER.info("修改解析出的URL主域名后去掉协议------------>{} 原始url is {}" ,domain,url);
return domain;
}
LOGGER.info("未找到的URL主域名 原始url is {}" ,url);
return null;
}
/**
* 获取主域名，即URL头
* @param url
* @param key url中的参数key
* @return
*/
public static Map<String, String> parseURLParam(String URL, String key) {
Map<String, String> mapRequest = new HashMap<String, String>();String[] arrSplit = null;
String strUrlParam = TruncateUrlPage(URL);
if (strUrlParam == null) {
return mapRequest;
}
//每个键值为一组
arrSplit = strUrlParam.split("[&]");
for (String strSplit : arrSplit) {
String[] arrSplitEqual = null;
arrSplitEqual = strSplit.split("[=]");
//解析出键值
if (arrSplitEqual.length > 1) {
//正确解析
if(key.equals(arrSplitEqual[0])){
mapRequest.put(arrSplitEqual[0], arrSplitEqual[1]);
break;
}
} else {
if (arrSplitEqual[0] != "") {
//只有参数没有值，不加入
mapRequest.put(arrSplitEqual[0], "");
}
}
}
return mapRequest;
}
/**
* 截取URL中的？之后的部分
* @param strUrl
* @return
*/
private static String TruncateUrlPage(String strURL) {
String strAllParam = null;
String[] arrSplit = null;
strURL = strURL.trim();
arrSplit = strURL.split("[?]");
if (strURL.length() > 1) {
if (arrSplit.length > 1) {
if (arrSplit[1] != null) {
strAllParam = arrSplit[1];
}
}
}
return strAllParam;
}
public static void main(String[] args) {
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E7%9A%84%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E7%9A%84%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E5%9E%8B%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E5%9E%8B%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
getDomainHost(url);
}String[] arrSplit = null;
String strUrlParam = TruncateUrlPage(URL);
if (strUrlParam == null) {
return mapRequest;
}
//每个键值为一组
arrSplit = strUrlParam.split("[&]");
for (String strSplit : arrSplit) {
String[] arrSplitEqual = null;
arrSplitEqual = strSplit.split("[=]");
//解析出键值
if (arrSplitEqual.length > 1) {
//正确解析
if(key.equals(arrSplitEqual[0])){
mapRequest.put(arrSplitEqual[0], arrSplitEqual[1]);
break;
}
} else {
if (arrSplitEqual[0] != "") {
//只有参数没有值，不加入
mapRequest.put(arrSplitEqual[0], "");
}
}
}
return mapRequest;
}
/**
* 截取URL中的？之后的部分
* @param strUrl
* @return
*/
private static String TruncateUrlPage(String strURL) {
String strAllParam = null;
String[] arrSplit = null;
strURL = strURL.trim();
arrSplit = strURL.split("[?]");
if (strURL.length() > 1) {
if (arrSplit.length > 1) {
if (arrSplit[1] != null) {
strAllParam = arrSplit[1];
}
}
}
return strAllParam;
}
public static void main(String[] args) {
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E7%9A%84%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E7%9A%84%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E5%9E%8B%E8%8D%AF%7C%2B14%E2%91%A392%E2%91%A438V%7C";
String url = "https://developer.baidu.com/forum/search?keyword=%E5%90%AC%E8%AF%9D%E5%9E%8B%E8%8D%AF%E6%B0%B4%7C%2B14%E2%91%A392%E2%91%A438V%7C";
getDomainHost(url);
}}
一，Spirng与Web集成
1.1 ApplicationContext应用上下文获取方式#
应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ，这样的弊端是配置文件加载多次，应用上下文对象创建多次。
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。
1.2 Spring提供获取应用上下文的工具#
上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。
所以我们需要做的只有两件事：
在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
使用WebApplicationContextUtils获得应用上下文对象ApplicationContext
1.3 Spring与Web集成实现#
1.导入spring-web坐标，其他的spring坐标也需要导入
复制代码
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>复制代码
2.配置ContextLoaderListener监听器在web项目的web.xml文件配置中配置。
复制代码
contextConfigLocation
classpath:applicationContext.xml
<!--这里配置spring监听器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>复制代码
3.测试
复制代码
package com.itcast.web;
import com.itcast.service.UserService;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;import javax.jws.WebService;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;@WebServlet("/user")
public class UserServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取servletContext域
ServletContext servletContext = this.getServletContext();
// 从servletContext域中获取上下文对象
WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
// 从容器中获取对象
UserService userService = (UserService) applicationContext.getBean("userService");
System.out.println(userService);
userService.save();
resp.getWriter().write("aaaa");
}}
复制代码
二，SpringMVC简介
2.1 SpringMVC概述#
SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于SpringFrameWork 的后续产品，已经融合在 Spring Web Flow 中。
SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。
SpringMVC优点：
无需事先任何接口，实现操作方便
支持RESTFUL编程风格
2.2 SpirngMVC实现#
1.坐标导入
复制代码
org.springframework
spring-context
5.0.5.RELEASE<!--集成的web坐标-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<!--spring-webmvc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
<scope>provided</scope>
</dependency>复制代码
2.在web.xml文件中配置SpirngMVC的核心控制器
复制代码
DispatcherServlet
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:spring-mvc.xml
1
DispatcherServlet
/
复制代码
3.启动组件扫描在spring-mvc.xml文件中配置，该配置文件放在resources下
复制代码
<context:component-scan base-package="com.itcast"></context:component-scan>
复制代码
4.测试：
编写controller和业务方法
复制代码
@Controller
public class QuickController {
// 页码跳转返回
// 返回字符串形式
@RequestMapping("/quick")
public String quickMethod(){
System.out.println("quickMethod running .....");
return "index";
}
}
复制代码
可以通过浏览器进行该路径访问：例：localhost:8080/mvc/quick
mvc为虚拟路径
quick为RequestMapping的参数
2.3 SpringMVC流程图#
三，SpringMVC组件解析
3.1 SpringMVC的执行流程#
复制代码
1.用户发送请求至前端控制器DispatcherServlet。
2.DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3.处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4.DispatcherServlet调用HandlerAdapter处理器适配器。
5.HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
6.Controller执行完成返回ModelAndView。
7.HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
8.DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
9.ViewReslover解析后返回具体View。
10DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户。
复制代码
3.2 组件解析#
复制代码
- 前端控制器：DispatcherServlet
用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由
它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性。 - 处理器映射器：HandlerMapping
HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的
映射方式，例如：配置文件方式，实现接口方式，注解方式等。 - 处理器适配器：HandlerAdapter
通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理
器进行执行。 - 处理器：Handler
它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由
Handler 对具体的用户请求进行处理。 - 视图解析器：View Resolver
View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，
再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。 - 视图：View
SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面
复制代码
3.3 注解解析#
复制代码
@RequestMapping
作用：用于建立请求 URL 和处理请求方法之间的对应关系
位置：
类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径
属性：
value：用于指定请求的URL。它和path属性的作用是一样的
method：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
例如：
params = {"accountName"}，表示请求参数必须有accountName
params = {"moeny!100"}，表示请求参数中money不能是100
复制代码
复制代码 - mvc命名空间引入
命名空间：xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
约束地址：http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsd - 组件扫描
SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，
就需要使用<context:component-scan base-package=“com.itheima.controller"/>进行组件扫描。
复制代码
3.4 XML配置解析# - 视图解析器
SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，
该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
翻看该解析器源码，可以看到该解析器的默认设置，如下：
REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀
视图解析器
我们可以通过属性注入的方式修改视图的的前后缀