顶级架构师学习——第二十四阶段：SpringMVC架构来了~

淡淡的烟草味﹌ 2021-09-28 06:50 316阅读 0赞

架构师的学习前后半年了，下周应该就可以结束了，下周的内容主要就是实战练习了~~

最后几天，控制住自己！！！fighting~

很抱歉的吃掉上一篇立下的flag，我想把那次实战挪到下周去~

**目录**

一、入门

二、SpringMVC架构

三、RESTful支持

--------------------

# 一、入门 #

Spring web mvc和Struts2都属于表现层的框架，它是Spring框架的一部分，我们可以从Spring的整体结构中看得出来，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70][]

SpringMVC的处理流程可以用下面这张图来概括：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 1][]

给一个使用SpringMVC的入门程序，不没这节的入门标题才好~

1.我们先建立一个web工程然后把jar包全部导进去，这一步太简单，相信大家都会，就不多说了！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 2][]

2.创建config资源文件夹，存放SpringMVC的核心配置文件springmvc.xml

SpringMVC本身就是Spring的子项目，对Spring兼容性很好，不需要做很多配置。这里只配置一个Controller扫描就可以了，让Spring对页面控制层Controller进行管理。

<?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:p="http://www.springframework.org/schema/p"
    	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-4.0.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    	
    	<context:component-scan base-package="com.lbfl.springmvc.controller" />
    
    </beans>

3.在web.xml中配置SpringMVC的前端控制器DispatcherServlet

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns="http://java.sun.com/xml/ns/javaee"
    	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    	id="WebApp_ID" version="2.5">
    	<display-name>springmvc-first</display-name>
    	<welcome-file-list>
    		<welcome-file>index.html</welcome-file>
    		<welcome-file>index.htm</welcome-file>
    		<welcome-file>index.jsp</welcome-file>
    		<welcome-file>default.html</welcome-file>
    		<welcome-file>default.htm</welcome-file>
    		<welcome-file>default.jsp</welcome-file>
    	</welcome-file-list>
    
    	
    	<servlet>
    		<servlet-name>springmvc-first</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		
    		
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:springmvc.xml</param-value>
    		</init-param>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>springmvc-first</servlet-name>
    		
    		<url-pattern>*.action</url-pattern>
    	</servlet-mapping>
    
    </web-app>

4.在WEB-INF下建立jsp包，添加前端显示的jsp页面itemList.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>查询商品列表</title>
    </head>
    <body> 
    <form action="${pageContext.request.contextPath }/item/queryitem.action" method="post">
    查询条件：
    <table width="100%" border=1>
    <tr>
    <td><input type="submit" value="查询"/></td>
    </tr>
    </table>
    商品列表：
    <table width="100%" border=1>
    <tr>
    	<td>商品名称</td>
    	<td>商品价格</td>
    	<td>生产日期</td>
    	<td>商品描述</td>
    	<td>操作</td>
    </tr>
    <c:forEach items="${itemList }" var="item">
    <tr>
    	<td>${item.name }</td>
    	<td>${item.price }</td>
    	<td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
    	<td>${item.detail }</td>
    	
    	<td><a href="${pageContext.request.contextPath }/itemEdit.action?id=${item.id}">修改</a></td>
    
    </tr>
    </c:forEach>
    
    </table>
    </form>
    </body>
    
    </html>

5.分析前端需要的信息，我们创建商品pojo类~

import java.util.Date;
    
    public class Items {
        private Integer id;
    
        private String name;
    
        private Float price;
    
        private String pic;
    
        private Date createtime;
    
        private String detail;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name == null ? null : name.trim();
        }
    
        public Float getPrice() {
            return price;
        }
    
        public void setPrice(Float price) {
            this.price = price;
        }
    
        public String getPic() {
            return pic;
        }
    
        public void setPic(String pic) {
            this.pic = pic == null ? null : pic.trim();
        }
    
        public Date getCreatetime() {
            return createtime;
        }
    
        public void setCreatetime(Date createtime) {
            this.createtime = createtime;
        }
    
        public String getDetail() {
            return detail;
        }
    
        public void setDetail(String detail) {
            this.detail = detail == null ? null : detail.trim();
        }
    }

6.创建一个ItemController类

ItemController是一个普通的java类，不需要实现任何接口。需要在类上添加@Controller注解，把Controller交由Spring管理；在方法上面添加@RequestMapping注解，里面指定请求的url。

@Controller
    public class ItemController {
    
    	// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配
    	// action可以写也可以不写
    	@RequestMapping("/itemList.action")
    	public ModelAndView queryItemList() {
    		// 创建页面需要显示的商品数据
    		List<Item> list = new ArrayList<>();
    		list.add(new Item(1, "1华为 荣耀8", 2399, new Date(), "质量好！1"));
    		list.add(new Item(2, "2华为 荣耀8", 2399, new Date(), "质量好！2"));
    		list.add(new Item(3, "3华为 荣耀8", 2399, new Date(), "质量好！3"));
    		list.add(new Item(4, "4华为 荣耀8", 2399, new Date(), "质量好！4"));
    		list.add(new Item(5, "5华为 荣耀8", 2399, new Date(), "质量好！5"));
    		list.add(new Item(6, "6华为 荣耀8", 2399, new Date(), "质量好！6"));
    
    		// 创建ModelAndView，用来存放数据和视图
    		ModelAndView modelAndView = new ModelAndView();
    		// 设置数据到模型中
    		modelAndView.addObject("list", list);
    		// 设置视图jsp，需要设置视图的物理地址
    		modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");
    
    		return modelAndView;
    	}
    }

7.启动项目测试~~

启动项目，浏览器访问地址：http://127.0.0.1:8080/springmvc-first/itemList.action。效果如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 3][]

# 二、SpringMVC架构 #

1、框架结构

SpringMVC的架构图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 4][]

1.  用户发送请求至前端控制器DispatcherServlet
2.  DispatcherServlet收到请求调用HandlerMapping处理器映射器。
3.  处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
4.  DispatcherServlet通过HandlerAdapter处理器适配器调用处理器
5.  执行处理器(Controller，也叫后端控制器)。
6.  Controller执行完成返回ModelAndView
7.  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
8.  DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9.  ViewReslover解析后返回具体View
10. DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。
11. DispatcherServlet响应用户

2、组件说明

以下组件通常使用框架提供实现：

1.DispatcherServlet：前端控制器

用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

2.HandlerMapping：处理器映射器

HandlerMapping负责根据用户请求url找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3.Handler：处理器

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

4.HandlAdapter：处理器适配器

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

5.ViewResolver：视图解析器

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

6.View：视图

springmvc框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView、pdfView等。我们最常用的视图就是jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

说明：在springmvc的各个组件中，处理器映射器、处理器适配器、视图解析器称为springmvc的三大组件。

我们不需要写任何东西就可以使用它们，因为它们是SpringMVC的默认组件，它们在Dispatcher.proeprties文件中有说明~

3、注解映射器和适配器

1.配置处理器映射器

注解式处理器映射器，对类中标记了**@ResquestMapping（**定义请求url到处理器功能方法的映射**）**的方法进行映射。根据@ResquestMapping定义的url匹配@ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器。HandlerMethod对象中封装url对应的方法Method。

从spring3.1版本开始，废除了DefaultAnnotationHandlerMapping的使用，推荐使用**RequestMappingHandlerMapping**完成注解式处理器映射。

在**springmvc.xml**配置文件中配置如下：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping" />

2.配置处理器适配器

注解式处理器适配器，对标记@ResquestMapping的方法进行适配。

从spring3.1版本开始，废除了AnnotationMethodHandlerAdapter的使用，推荐使用**RequestMappingHandlerAdapter**完成注解式处理器适配。

在**springmvc.xml**配置文件中配置如下：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter" />

3.注解驱动

直接配置处理器映射器和处理器适配器比较麻烦，可以使用注解驱动来加载。

SpringMVC使用**<mvc:annotation-driven>**自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter

可以在springmvc.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置。

<mvc:annotation-driven />

4、视图解析器

视图解析器使用SpringMVC框架默认的InternalResourceViewResolver，这个视图解析器支持JSP视图解析。

在springmvc.xml配置文件中配置如下：

<bean
    		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    		
    		<property name="prefix" value="/WEB-INF/jsp/" />
    		
    		<property name="suffix" value=".jsp" />
    	</bean>

逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为ItemList，则最终返回的jsp视图地址：“WEB-INF/jsp/itemList.jsp”。所以，最终jsp物理地址：前缀+**逻辑视图名**\+后缀

我们还需修改ItemController：

// @RequestMapping：里面放的是请求的url，和用户请求的url进行匹配
    // action可以写也可以不写
    @RequestMapping("/itemList.action")
    public ModelAndView queryItemList() {
    	// 创建页面需要显示的商品数据
    	List<Item> list = new ArrayList<>();
    	list.add(new Item(1, "1华为 荣耀8", 2399, new Date(), "质量好！1"));
    	list.add(new Item(2, "2华为 荣耀8", 2399, new Date(), "质量好！2"));
    	list.add(new Item(3, "3华为 荣耀8", 2399, new Date(), "质量好！3"));
    	list.add(new Item(4, "4华为 荣耀8", 2399, new Date(), "质量好！4"));
    	list.add(new Item(5, "5华为 荣耀8", 2399, new Date(), "质量好！5"));
    	list.add(new Item(6, "6华为 荣耀8", 2399, new Date(), "质量好！6"));
    
    	// 创建ModelAndView，用来存放数据和视图
    	ModelAndView modelAndView = new ModelAndView();
    	// 设置数据到模型中
    	modelAndView.addObject("itemList", list);
    	// 设置视图jsp，需要设置视图的物理地址
    	// modelAndView.setViewName("/WEB-INF/jsp/itemList.jsp");
    	// 配置好视图解析器前缀和后缀，这里只需要设置逻辑视图就可以了。
    	// 视图解析器根据前缀+逻辑视图名+后缀拼接出来物理路径
    	modelAndView.setViewName("itemList");// 此即逻辑视图名
    
    	return modelAndView;
    }

5、参数绑定

SpringMVC默认支持有HttpServletRequest、HttpServletResponse、HttpSession等，我们在传递参数的过程中除了使用ModelAndView以外，也可以直接使用Model对象或者它的子类（如ModelMap）以及用String类型代替View来实现。

当请求的参数名称和处理器形参名称一致时会将请求参数与形参进行绑定。这样，从Request取参数的方法就可以进一步简化。

参数类型推荐使用包装数据类型，因为基础数据类型不可以为null。

整形：Integer、int

字符串：String

单精度：Float、float

双精度：Double、double

布尔型：Boolean、boolean

我们可以使用@RequestParam来进行简单类型的绑定~比如：

@RequestMapping("/itemEdit")
    public String queryItemById(@RequestParam(value = "itemId", required = true, defaultValue = "1") Integer id, ModelMap modelMap) {
        ...
    }

value：参数名字，即入参的请求参数名字，如value=“itemId”表示请求的参数区中的名字为itemId的参数的值将传入；

required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报错；

defaultValue：默认值，表示如果请求中没有同名参数时的默认值。

传递参数，可以是简单类型的参数，如上；也可以是pojo类，通过实例化来实现参数的传递。

我们在测试的过程中，POST提交时发现保存操作虽然成功，但是**返回**的确是一串**乱码**。那么解决这个问题也很简单，我们在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>

我们使用在前面AOP编程当中曾经提到过的filter来实现过滤功能，让编码后的数据流入SpringMVC部分。至于GET乱码问题，请参照以前的文章来解决吧~

6、异常处理器

springmvc在处理请求过程中出现异常信息交由异常处理器进行处理，自定义异常处理器可以实现一个系统的异常处理逻辑。

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。

系统的dao、service、controller出现都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 5][]

为了区别不同的异常,通常根据异常类型进行区分，这里我们创建一个自定义系统异常。

如果controller、service、dao抛出此类异常说明是系统预期处理的异常信息。

public class MyException extends Exception {
    	// 异常信息
    	private String message;
    
    	public MyException() {
    		super();
    	}
    
    	public MyException(String message) {
    		super();
    		this.message = message;
    	}
    
    	public String getMessage() {
    		return message;
    	}
    
    	public void setMessage(String message) {
    		this.message = message;
    	}
    
    }

再接着自定义一个异常处理器~

public class CustomHandleException implements HandlerExceptionResolver {
    
    	@Override
    	public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
    			Exception exception) {
    		// 定义异常信息
    		String msg;
    
    		// 判断异常类型
    		if (exception instanceof MyException) {
    			// 如果是自定义异常，读取异常信息
    			msg = exception.getMessage();
    		} else {
    			// 如果是运行时异常，则取错误堆栈，从堆栈中获取异常信息
    			Writer out = new StringWriter();
    			PrintWriter s = new PrintWriter(out);
    			exception.printStackTrace(s);
    			msg = out.toString();
    
    		}
    
    		// 把错误信息发给相关人员,邮件,短信等方式
    		// TODO
    
    		// 返回错误页面，给用户友好页面显示错误信息
    		ModelAndView modelAndView = new ModelAndView();
    		modelAndView.addObject("msg", msg);
    		modelAndView.setViewName("error");
    
    		return modelAndView;
    	}
    }

将我们的异常处理器配置到springmvc.xml文件当中

<bean id="customHandleException" class="com.lbfl.ssm.exception.CustomHandleException" />

为了在页面中显示异常信息，我们给出jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    
    	<h1>系统发生异常了！</h1>
    	<br />
    	<h1>异常信息</h1>
    	<br />
    	<h2>${msg }</h2>
    
    </body>
    </html>

现在进行测试~~修改**ItemController**的方法“queryItemList”，抛出异常：

/**
     * 查询商品列表
     * 
     * @return
     * @throws Exception
     */
    @RequestMapping(value = { "itemList", "itemListAll" })
    public ModelAndView queryItemList() throws Exception {
    	// 自定义异常
    	if (true) {
    		throw new MyException("自定义异常出现了~");
    	}
    
    	// 运行时异常
    	int a = 1 / 0;
    
    	// 查询商品数据
    	List<Item> list = this.itemService.queryItemList();
    	// 创建ModelAndView,设置逻辑视图名
    	ModelAndView mv = new ModelAndView("itemList");
    	// 把商品数据放到模型中
    	mv.addObject("itemList", list);
    
    	return mv;
    }

7、拦截器

Spring Web MVC 的处理器拦截器类似于Servlet 开发中的过滤器Filter，用于对处理器进行预处理和后处理。

直接给一个范例，不再多讲~

public class HandlerInterceptor1 implements HandlerInterceptor {
    	// controller执行后且视图返回后调用此方法
    	// 这里可得到执行controller时的异常信息
    	// 这里可记录操作日志
    	@Override
    	public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
    			throws Exception {
    		System.out.println("HandlerInterceptor1....afterCompletion");
    	}
    
    	// controller执行后但未返回视图前调用此方法
    	// 这里可在返回用户前对模型数据进行加工处理，比如这里加入公用信息以便页面显示
    	@Override
    	public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
    			throws Exception {
    		System.out.println("HandlerInterceptor1....postHandle");
    	}
    
    	// Controller执行前调用此方法
    	// 返回true表示继续执行，返回false中止执行
    	// 这里可以加入登录校验、权限拦截等
    	@Override
    	public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
    		System.out.println("HandlerInterceptor1....preHandle");
    		// 设置为true，测试使用
    		return true;
    	}
    }

在springmvc.xml文件当中配置拦截器即可~

<mvc:interceptors>
    	<mvc:interceptor>
    		
    		<mvc:mapping path="/**" />
    		
    		<bean class="cn.itcast.ssm.interceptor.HandlerInterceptor1" />
    	</mvc:interceptor>
    </mvc:interceptors>

拦截器的调用有下面这几个特点：

1.  preHandle按拦截器定义顺序调用
2.  postHandler按拦截器定义逆序调用
3.  afterCompletion按拦截器定义逆序调用
4.  postHandler在拦截器链内所有拦截器返成功调用
5.  afterCompletion只有preHandle返回true才调用

8、JSON数据交互

1.@RequestBody

@RequestBody注解用于读取http请求的内容(字符串)，通过springmvc提供的HttpMessageConverter接口将读到的内容（json数据）转换为java对象并绑定到Controller方法的参数上。

传统的请求参数：itemEdit.action?id=1&name=zhangsan&age=12

现在的请求参数：使用POST请求，在请求体里面加入json数据。

应用：@RequestBody注解实现接收http请求的json数据，将json数据转换为java对象进行绑定。

2.@ResponseBody

@ResponseBody注解用于将Controller的方法返回的对象，通过springmvc提供的HttpMessageConverter接口转换为指定格式的数据如：json，xml等，通过Response响应给客户端。

应用：@ResponseBody注解实现将Controller方法返回java对象转换为json响应给客户端。

如果需要springMVC支持json，必须加入json的处理jar

我们使用Jackson这个jar，如下图：

![20190309194859386.png][]

同时，我们还需要配置json转换器（如果使用注解驱动<mvc:annotation-driven />的话就不用自己配置了）：在springmvc.xml配置文件中，给处理器适配器加入json转换器：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    		<property name="messageConverters">
    		<list>
    			<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
    		</list>
    		</property>
    	</bean>

# 三、RESTful支持 #

这里额外介绍一下RESTful这个东西~

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、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方式实现商品信息查询，返回json数据！！！

1.使用RESTful风格开发的接口，根据id查询商品，接口地址是：http://127.0.0.1/item/1

2.从url上获取商品id：使用注解@RequestMapping("item/\{id\}")声明请求的url，\{xxx\}叫做占位符，请求的URL可以是“item /1”或“item/2”；使用(@PathVariable() Integer id)获取url上的数据

3.在ItemController.java中添加下面的代码：

/**
     * 使用RESTful风格开发接口，实现根据id查询商品
     * 
     * @param id
     * @return
     */
    @RequestMapping("item/{id}")
    @ResponseBody
    public Item queryItemById(@PathVariable() Integer id) {
    	Item item = this.itemService.queryItemById(id);
    	return item;
    }

如果@RequestMapping中表示为"item/\{id\}"，id和形参名称一致，@PathVariable不用指定名称。如果不一致，例如"item/\{ItemId\}"则需要指定名称@PathVariable("itemId")。

--------------------

所有的努力，都是为了一个更加美好的家，为所有在城市之中拼搏的孩子们——打Call~~

我是小昶，明天见~

欢迎关注我们的公众号：落饼枫林

![20190309200330639.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70]: /images/20210923/1870617589ec4751a3a0de19f7555675.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 1]: /images/20210923/49eee449794d4764ba3b9090c00675a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 2]: /images/20210923/4613fa403aa44950880190ab7fa31c94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 3]: /images/20210923/786cfc0adefd4e34b31bdec547dae80d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 4]: /images/20210923/b8db9ece022340c08787130106124e1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzkxMTky_size_16_color_FFFFFF_t_70 5]: /images/20210923/00223c24374643beb54c0a4515872bee.png
[20190309194859386.png]: /images/20210923/df953094c248464cb1ef3ff8c77c6f80.png
[20190309200330639.png]: /images/20210923/9d5759f158814edab9059cbdb001403c.png