SSM

SpringMVC: First

张天宇 on 2020-04-11

SpringMVC第一篇,简单工程的创建。

三层架构

表现层

也就是我们常说的web层。它负责接收客户端请求,向客户端响应结果,通常客户端使用http协议请求web 层,web 需要接收 http 请求,完成 http 响应。表现层包括展示层和控制层:控制层负责接收请求,展示层负责结果的展示。表现层依赖业务层,接收到客户端请求一般会调用业务层进行业务处理,并将处理结果响应给客户端。表现层的设计一般都使用 MVC 模型。(MVC 是表现层的设计模型,和其他层没有关系)

业务层

也就是我们常说的 service 层。它负责业务逻辑处理,和我们开发项目的需求息息相关。web 层依赖业务层,但是业务层不依赖 web 层。业务层在业务处理时可能会依赖持久层,如果要对数据持久化需要保证事务一致性。(也就是我们说的,事务应该放到业务层来控制)

持久层

也就是我们是常说的 dao 层。负责数据持久化,包括数据层即数据库和数据访问层,数据库是对数据进行持久化的载体,数据访问层是业务层和持久层交互的接口,业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲,持久层就是和数据库交互,对数据库表进行曾删改查的。

SpringMVC

基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架。

优势

  1. 清晰的角色划分:
    前端控制器(DispatcherServlet)
    请求到处理器映射(HandlerMapping)
    处理器适配器(HandlerAdapter)
    视图解析器(ViewResolver)
    处理器或页面控制器(Controller)
    验证器( Validator)
    命令对象(Command 请求参数绑定到的对象就叫命令对象)
    表单对象(Form Object 提供给表单展示和提交到的对象就叫表单对象)。

  2. 分工明确,而且扩展点相当灵活,可以很容易扩展,虽然几乎不需要。

  3. 由于命令对象就是一个 POJO,无需继承框架特定 API,可以使用命令对象直接作为业务对象。

  4. 和 Spring 其他框架无缝集成,是其它 Web 框架所不具备的。

  5. 可适配,通过 HandlerAdapter 可以支持任意的类作为处理器。

  6. 可定制性,HandlerMapping、ViewResolver 等能够非常简单的定制。

  7. 功能强大的数据验证、格式化、绑定机制。

  8. 利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试。

  9. 本地化、主题的解析的支持,使我们更容易进行国际化和主题的切换。

  10. 强大的 JSP 标签库,使 JSP 编写更容易。

    ………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配
    置支持等等。

和Structs2的比较

  • 共同点:
    它们都是表现层框架,都是基于 MVC 模型编写的。
    它们的底层都离不开原始 ServletAPI。
    它们处理请求的机制都是一个核心控制器。
  • 区别:
    Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter
    Spring MVC 是基于方法设计的,而 Struts2 是基于类,Struts2 每次执行都会创建一个动作类。所
    以 Spring MVC 会稍微比 Struts2 快些。
    Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便
    (JSR303 是一套 JavaBean 参数校验的标准,它定义了很多常用的校验注解,我们可以直接将这些注
    解加在我们 JavaBean 的属性上面,就可以在需要校验的时候进行校验了。)
    Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些,但执行效率并没有比 JSTL 提
    升,尤其是 struts2 的表单标签,远没有 html 执行效率高。

简单工程的创建

  1. 导入配置坐标

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    <!-- 版本锁定:指定Spring版本 -->
    <properties>
    <spring.version>5.0.2.RELEASE</spring.version>
    </properties>

    <!-- 依赖坐标 -->
    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
    </dependency>
    <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
    </dependency>
    <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
    </dependency>
    </dependencies>
  2. 核心控制器基本配置web.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <!DOCTYPE web-app PUBLIC
    "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd" >

    <web-app>
    <display-name>Archetype Created Web Application</display-name>
    <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
    </servlet-mapping>
    </web-app>
  3. 配置springmvc.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    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
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.itheima"></context:component-scan>
    <!-- 配置视图解析器 -->
    <bean id="viewResolver"
    class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/pages/"></property>
    <property name="suffix" value=".jsp"></property>
    </bean>
    <!-- 配置spring开启注解mvc的支持
    <mvc:annotation-driven></mvc:annotation-driven>-->
    </beans>
  4. 其他

    1
    2
    3
    4
    <body>
    <h3>入门案例</h3>
    <a href="hello">入门案例</a>
    </body>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @Controller
    public class HelloController {
    /**
    * 接收请求
    * @return
    */
    @RequestMapping(path="/hello")
    public String sayHello() {
    System.out.println("Hello SpringMVC!!");
    return "success";
    }
    }
  5. 在WEB-INF目录下创建pages文件夹,编写success.jsp的成功页面

执行过程分析

  1. 入门案例的执行流程
  2. 当启动Tomcat服务器的时候,因为配置了load-on-startup标签,所以会创建DispatcherServlet对象,
    就会加载springmvc.xml配置文件
  3. 开启了注解扫描,那么HelloController对象就会被创建
  4. 从index.jsp发送请求,请求会先到达DispatcherServlet核心控制器,根据配置@RequestMapping注解
    找到执行的具体方法
  5. 根据执行方法的返回值,再根据配置的视图解析器,去指定的目录下查找指定名称的JSP文件
  6. Tomcat服务器渲染页面,做出响应

RequestMapping注解

  1. RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
  2. RequestMapping注解可以作用在方法和类上
    1. 作用在类上:第一级的访问目录
    2. 作用在方法上:第二级的访问目录
    3. 细节:路径可以不编写 / 表示应用的根目录开始
    4. 细节:${ pageContext.request.contextPath }也可以省略不写,但是路径上不能写 /
  3. RequestMapping的属性
    1. path 指定请求路径的url
    2. value value属性和path属性是一样的
    3. method 指定该方法的请求方式
    4. params 指定限制请求参数的条件
    5. headers 发送的请求中必须包含的请求头

请求参数的绑定

支持数据类型

  • 基本类型参数 :
    包括基本类型和 String 类型

  • POJO 类型参数 :
    包括实体类,以及关联的实体类

  • 数组和集合类型参数 :
    包括 List 结构和 Map 结构的集合(包括数组)

SpringMVC 绑定请求参数是自动实现的,但是要想使用,必须遵循使用要求。

基本类型的绑定

1
<a href="param/testParam?username=hehe">请求参数绑定</a>
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/param")
public class ParamController {
@RequestMapping("/testParam")
public String testParam(String username){
System.out.println("执行了"+username);
return "success";
}
}

实体类的绑定

1
2
3
4
5
6
7
8
9
<!-- Account属性中包含User类 -->
<form action="param/saveAccount" method="post">
姓名:<input type="text" name="username"/><br>
密码:<input type="text" name="password"/><br>
金额:<input type="text" name="money"/><br>
用户姓名:<input type="text" name="user.uname"/><br>
用户年龄:<input type="text" name="user.age"/><br>
<input type="submit" value="提交"/><br>
</form>
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/param")
public class ParamController {
@RequestMapping("/saveAccount")
public String savaAccount(Account account){
System.out.println("执行了"+account.getUsername()+account.getUser().getUname());
return "success";
}
}

集合的绑定

1
2
3
4
5
6
7
8
9
10
11
12
<form action="param/saveAccount" method="post">
姓名:<input type="text" name="username"/><br>
密码:<input type="text" name="password"/><br>
金额:<input type="text" name="money"/><br>

用户姓名:<input type="text" name="list[0].uname"/><br>
用户年龄:<input type="text" name="list[0].age"/><br>

用户姓名:<input type="text" name="map['one'].uname"/><br>
用户年龄:<input type="text" name="map['one'].age"/><br>
<input type="submit" value="提交"/><br>
</form>
1
2
3
4
5
6
7
8
public class Account implements Serializable {
private String username;
private String password;
private Double money;
private List<User> list;
private Map<String, User> map;
//...
}
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/param")
public class ParamController {
@RequestMapping("/saveAccount")
public String savaAccount(Account account){
System.out.println("执行了"+account.getUsername()+" "+account.getList().get(0).getUname()+" "+account.getMap().get("one"));
return "success";
}
}

自定义类型转换器

表单提交的任何数据类型全部都是字符串类型,但是后台定义Integer类型,数据也可以封装上,说明Spring框架内部会默认进行数据类型转换。如果想自定义数据类型转换,可以实现Converter的接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class StringToDateConverter implements Converter<String, Date> {
@Override
public Date convert(String source) {
if (source == null){
throw new RuntimeException("传入数据为空");
}
SimpleDateFormat df =new SimpleDateFormat("yyyy-MM-dd");
try {
return df.parse(source);
} catch (Exception e) {
throw new RuntimeException("转换失败");
}
}
}
1
2
3
4
5
6
7
8
9
10
<!-- springmvc.xml主配置文件中配置自定义类型转换器 -->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters" >
<set>
<bean class="top.tyzhang.utils.StringToDateConverter"></bean>
</set>
</property>
</bean>
<!-- 启用 -->
<mvc:annotation-driven conversion-service="conversionService"/>

补充

Post请求中文乱码问题

1
request.setCharaterEncoding("UTF-8");

SpringMVC中的过滤器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!--解决中文乱码过滤器,写在servlet注释前-->
<filter>
<filter-name>characterEncodingFilter</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>
<!-- 启动过滤器 -->
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
1
2
3
4
5
在 springmvc 的配置文件中可以配置,静态资源不过滤:
<!-- location 表示路径,mapping 表示文件,**表示该目录下的文件以及子目录的文件 -->
<mvc:resources location="/css/" mapping="/css/**"/>
<mvc:resources location="/images/" mapping="/images/**"/>
<mvc:resources location="/scripts/" mapping="/javascript/**"/>

Get请求方式

Tomcat 对 GET和 POST 请求处理方式是不同的,GET请求的编码问题,要改 tomcat 的 server.xml
配置文件,如下:

1
2
3
<Connector connectionTimeout="20000" port="8080"
protocol="HTTP/1.1" redirectPort="8443"
useBodyEncodingForURI="true"/>

如果遇到 ajax 请求仍然乱码,useBodyEncodingForURI="true"改为URIEncoding="UTF-8"即可。

常用注解

@RequestParam

  • 作用:
    把请求中指定名称的参数给控制器中的形参赋值。
  • 属性:
    value:请求参数中的名称。
    required:请求参数中是否必须提供此参数。默认值:true。表示必须提供,如果不提供将报错。
1
<a href="anno/testRequestParam?name=haha">RequestParam</a>
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/anno")
public class AnnoController {
@RequestMapping("/testRequestParam")
public String testRequestParam(@RequestParam(name="name") String username, @RequestParam(value="age",required=false)Integer age){
System.out.println("执行了"+username);
return "success";
}
}

@RequestBody

  • 作用:
    用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。
    get 请求方式不适用。
  • 属性:
    required:是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值
    为 false,get 请求得到是 null。
1
2
3
4
5
6
<form action="springmvc/useRequestBody" method="post">
用户名称:<input type="text" name="username" ><br/>
用户密码:<input type="password" name="password" ><br/>
用户年龄:<input type="text" name="age" ><br/>
<input type="submit" value=" 保存 ">
</form>
1
2
3
4
5
@RequestMapping("/useRequestBody")
public String useRequestBody(@RequestBody(required=false) String body){
System.out.println(body);
return "success";
}

@PathVaribale

  • 作用:
    用于绑定 url 中的占位符。例如:请求 url 中 /delete/{id},这个{id}就是 url 占位符。
    url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志。
  • 属性:
    value:用于指定 url 中占位符名称。
    required:是否必须提供占位符。
  • 参见下文REST风格URL
1
<a href="springmvc/usePathVariable/100">pathVariable注解</a>
1
2
3
4
5
@RequestMapping("/usePathVariable/{id}")
public String usePathVariable(@PathVariable("id") Integer userid){
System.out.println(id);
return "success";
}

@HiddentHttpMethodFilter

  • 作用:
    由于浏览器 form 表单只支持 GET 与 POST 请求,而 DELETE、PUT 等 method 并不支持,Spring3.0 添
    加了一个过滤器,可以将浏览器请求改为指定的请求方式,发送给我们的控制器方法,使得支持 GET、POST、PUT
    与 DELETE 请求。
  • 使用方法:
    第一步:在 web.xml 中配置该过滤器。
    第二步:请求方式必须使用 post 请求。
    第三步:按照要求提供_method 请求参数,该参数的取值就是我们需要的请求方式。
  • 比较麻烦,了解即可
1
2
3
4
5
<!-- 删除 -->
<form action="springmvc/testRestDELETE/1" method="post">
<input type="hidden" name="_method" value="DELETE">
<input type="submit" value=" 删除 ">
</form>
1
2
3
4
5
@RequestMapping(value="/testRestDELETE/{id}",method=RequestMethod.DELETE)
public String testRestfulURLDELETE(@PathVariable("id")Integer id){
System.out.println("rest delete "+id);
return "success";
}

@RequestHeader

  • 作用:
    用于获取请求消息头。
  • 属性:
    value:提供消息头名称
    required:是否必须有此消息头
  • 注:
    在实际开发中一般不怎么用。
1
<a href="springmvc/useRequestHeader">获取请求消息头</a>
1
2
3
4
5
@RequestMapping("/useRequestHeader")
public String useRequestHeader(@RequestHeader(value="Accept-Language", required=false)String requestHeader){
System.out.println(requestHeader);
return "success";
}

@CookieValue

  • 作用:
    用于把指定 cookie 名称的值传入控制器方法参数。
  • 属性:
    value:指定 cookie 的名称。
    required:是否必须有此 cookie。
1
<a href="springmvc/useCookieValue">绑定 cookie 的值</a>
1
2
3
4
5
@RequestMapping("/useCookieValue")
public String useCookieValue(@CookieValue(value="JSESSIONID",required=false) String cookieValue){
System.out.println(cookieValue);
return "success";
}

@ModelAttribute

  • 作用:
    该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数。
    出现在方法上,表示当前方法会在控制器的方法执行之前,先执行。它可以修饰没有返回值的方法,也可
    以修饰有具体返回值的方法。
    出现在参数上,获取指定的数据给参数赋值。
  • 属性:
    value:用于获取数据的 key。key 可以是 POJO 的属性名称,也可以是 map 结构的 key。
  • 应用场景:
    当表单提交数据不是完整的实体类数据时,保证没有提交数据的字段使用数据库对象原来的数据。
    例如:
    我们在编辑一个用户时,用户有一个创建信息字段,该字段的值是不允许被修改的。在提交表单数
    据是肯定没有此字段的内容,一旦更新会把该字段内容置为 null,此时就可以使用此注解解决问题。
  1. 基于 POJO 属性的基本使用

    1
    <a href="springmvc/testModelAttribute?username=test">测试 modelattribute</a>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @ModelAttribute
    public void showModel(User user) {
    System.out.println("执行了 showModel 方法"+user.getUsername());
    }
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(User user) {
    System.out.println("执行了控制器的方法"+user.getUsername());
    return "success";
    }
    /*结果
    执行了 showModel 方法test
    执行了控制器的方法test
    */
  2. 基于 Map 的应用场景示例

    1. ModelAttribute 修饰方法带返回值
    1
    2
    3
    4
    5
    6
    <!-- 修改用户信息,要求不修改用户密码 -->
    <form action="springmvc/updateUser" method="post">
    用户名称:<input type="text" name="username" ><br/>
    用户年龄:<input type="text" name="age" ><br/>
    <input type="submit" value=" 保存 ">
    </form>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @ModelAttribute
    public User showModel(String username) {
    //模拟去数据库查询
    User abc = findUserByName(username);
    System.out.println("执行了 showModel 方法"+abc);
    return abc;
    }
    @RequestMapping("/updateUser")
    public String testModelAttribute(User user) {
    System.out.println("控制器中处理请求的方法:修改用户:"+user);
    return "success";
    }
    1. 不带返回值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      @ModelAttribute
      public void showModel(String username,Map<String,User> map) {
      //模拟去数据库查询
      User user = findUserByName(username);
      System.out.println("执行了 showModel 方法"+user);
      map.put("abc",user);
      }
      @RequestMapping("/updateUser")
      public String testModelAttribute(@ModelAttribute("abc")User user) {
      System.out.println("控制器中处理请求的方法:修改用户:"+user);
      return "success";
      }

@SessionAttribute

  • 作用:
    用于多次执行控制器方法间的参数共享。
  • 属性:
    value:用于指定存入的属性名称
    type:用于指定存入的数据类型。
1
2
3
<a href="springmvc/testPut">存入 SessionAttribute</a>
<a href="springmvc/testGet">取出 SessionAttribute</a>
<a href="springmvc/testClean">清除 SessionAttribute</a>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@Controller("sessionAttributeController")
@RequestMapping("/springmvc")
@SessionAttributes(value ={"username","password"},types={Integer.class})
public class SessionAttributeController {
/**
* 把数据存入 SessionAttribute
* @param model
* @return
* Model 是 spring 提供的一个接口,该接口有一个实现类 ExtendedModelMap
* 该类继承了 ModelMap,而 ModelMap 就是 LinkedHashMap 子类
*/
@RequestMapping("/testPut")
public String testPut(Model model){
model.addAttribute("username", "泰斯特");
model.addAttribute("password","123456");
model.addAttribute("age", 31);
//跳转之前将数据保存到 username、password 和 age 中,因为注解@SessionAttribute 中有
这几个参数
return "success";
}
@RequestMapping("/testGet")
public String testGet(ModelMap model){
System.out.println(model.get("username")+";"+model.get("password")+";"+model.get("a
ge"));
return "success";
}
@RequestMapping("/testClean")
public String complete(SessionStatus sessionStatus){
sessionStatus.setComplete();
return "success";
}
}

REST 风格 URL

什么是 rest

REST(英文:Representational State Transfer,简称 REST)描述了一个架构样式的网络系统,比如 web 应用程序。它首次出现在 2000 年 Roy Fielding 的博士论文中,他是 HTTP 规范的主要编写者之一。在目前主流的三种 Web 服务交互方案中,REST 相比于 SOAP(Simple Object Access protocol,简单对象访问协议)以及 XML-RPC 更加简单明了,无论是对 URL 的处理还是对 Payload 的编码,REST 都倾向于用更加简单轻量的方法设计和实现。值得注意的是 REST 并没有一个明确的标准,而更像是一种设计的风格。它本身并没有什么实用性,其核心价值在于如何设计出符合 REST 风格的网络接口。

restful 的优点

它结构清晰、符合标准、易于理解、扩展方便,所以正得到越来越多网站的采用。

restful 的特性

资源( Resources):网络上的一个实体,或者说是网络上的一个具体信息。它可以是一段文本、一张图片、一首歌曲、一种服务,总之就是一个具体的存在。可以用一个 URI(统一资源定位符)指向它,每种资源对应一个特定的 URI 。要
获取这个资源,访问它的 URI 就可以,因此 URI 即为每一个资源的独一无二的识别符。
表现层( Representation):把资源具体呈现出来的形式,叫做它的表现层 ( Representation)。比如,文本可以用 txt 格式表现,也可以用 HTML 格式、XML 格式、JSON 格式表现,甚至可以采用二进制格式。
状态转化( State Transfer):每 发出一个请求,就代表了客户端和服务器的一次交互过程。HTTP 协议,是一个无状态协议,即所有的状态都保存在服务器端。因此,如果客户端想要操作服务器,必须通过某种手段,让服务器端发生 “状态转化 ”( State Tran sfer)。而这种转化是建立在表现层之上的,所以就是 “表现层状态转化 ”。具体说,就是 HTTP 协议里面,四个表示操作方式的动词: GET、 POST、 PUT、DELETE。它们分别对应四种基本操作: GET 用来获取资源, POST 用来新建资源, PUT 用来更新资源, DELETE 用来删除资源。

restful 的示例

/account/1 HTTP GET : 得到 id = 1 的 account
/account/1 HTTP DELETE: 删除 id = 1 的 account
/account/1 HTTP PUT: 更新 id = 1 的 account