Spring MVC学习记录(基础)

1.SpringMVC概述
- 1.1 MVC介绍
- 1.2 Spring MVC介绍
- 1.3 Spring MVC 的核心组件
- 1.4 SpringMVC 工作原理
2.Spring MVC入门
- 2.1 入门案例
- 2.2 总结
3.RequestMapping注解
4.controller方法返回值
- 4.1 返回ModelAndView
- 4.2 返回字符串
- - 4.2.1 逻辑视图名
  - 4.2.2 Redirect重定向
  - 4.2.3 forward转发
5.参数接收
- 5.1 接收基本数据类型
- 5.2 接收实体类型
- 5.3 接收日期类型
- - 5.3.1 问题分析
  - 5.3.2 自定义类型转换器
- 5.4 restful风格
- - 5.4.1 restful风格URL
  - 5.4.2 @PathVaribale
- 5.5 请求参数乱码问题
- - 5.5.1 POST请求方式解决乱码问题
  - 5.5.2 GET请求方式解决乱码问题
- 5.6 使用ServletAPI接收参数
6.参数传递
- 6.1 ModelAndView传递
- 6.2 Model传递
- 6.3 ServletAPI传递
7.JSON数据处理
- 7.1 添加json依赖
- 7.2 接收json
- 7.3 传递json
- 7.4 案例
- 7.5 结论

1.SpringMVC概述

1.1 MVC介绍

MVC是一种设计模式，将软件按照模型、视图、控制器来划分：

M：Model，模型层，指工程中的JavaBean，作用是处理数据

JavaBean分为两类：
- 一类称为数据承载Bean：专门存储业务数据的，如 Student、User 等
- 一类称为业务处理Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。
V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

分层的目的是解耦合，按职责划分层次，易于扩展应用，提高开发效率

MVC的工作流程：

工作流程

用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器

1.2 Spring MVC介绍

Spring MVC 是Spring框架的一个模块，是一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。
SpringMVC 是 Spring 为控制层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目表述层开发的首选方案。

1.3 Spring MVC 的核心组件

记住了下面这些组件，也就记住了 SpringMVC 的工作原理。

DispatcherServlet：核心的中央处理器，负责接收请求、分发，并给予客户端响应。
HandlerMapping：处理器映射器，根据 URL 去匹配查找能处理的 Handler ，并会将请求涉及到的拦截器和 Handler 一起封装。
HandlerAdapter：处理器适配器，根据 HandlerMapping 找到的 Handler ，适配执行对应的 Handler;
Handler：请求处理器，处理实际请求的处理器。
ViewResolver：视图解析器，根据 Handler 返回的逻辑视图 / 视图，解析并渲染真正的视图，并传递给 DispatcherServlet 响应客户端。

1.4 SpringMVC 工作原理

Spring MVC 原理如下图所示：

流程说明（重要）：
1. 客户端（浏览器）发送请求， DispatcherServlet拦截请求。
2. DispatcherServlet 根据请求信息调用 HandlerMapping 。HandlerMapping 根据 URL 去匹配查找能处理的 Handler（也就是我们平常说的 Controller 控制器），并会将请求涉及到的拦截器和 Handler 一起封装。
3. DispatcherServlet 调用 HandlerAdapter适配器执行 Handler 。
4. Handler 完成对用户请求的处理后，会返回一个 ModelAndView 对象给DispatcherServlet，ModelAndView 顾名思义，包含了数据模型以及相应的视图的信息。Model 是返回的数据对象，View 是个逻辑上的 View。
5. ViewResolver 会根据逻辑 View 查找实际的 View。
6. DispaterServlet 把返回的 Model 传给 View（视图渲染）。
7. 把 View 返回给请求者（浏览器）

2.Spring MVC入门

因为SpringMVC是一个Web框架，将来是要替换Servlet,所以先来回顾下以前Servlet是如何进行开发的?

创建web工程(Maven结构)
设置tomcat服务器，加载web工程(tomcat插件)
导入坐标(Servlet)
定义处理请求的功能类(Servlet)
设置请求映射(配置映射关系)

SpringMVC的制作过程和上述流程几乎是一致的，具体的实现流程是什么?

创建web工程(Maven结构)
设置tomcat服务器，加载web工程(tomcat插件)
导入坐标(SpringMVC+Servlet)
定义处理请求的功能类(Controller)
设置请求映射(配置映射关系)
将SpringMVC设定加载到Tomcat容器中

2.1 入门案例

步骤1：创建工程

创建工程

步骤2：添加web支持

右键项目选择Add framework support...

在这里插入图片描述

添加web支持
效果

注意：

先添加框架支持，再设置打包方式
将web目录要拖拽到main目录下，并改名为webapp

步骤3：导入jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.by</groupId>
    <artifactId>SpringMVC_day01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包方式-->
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</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>
    <build>
        <plugins>
            <!-- 配置Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!--端口号-->
                    <port>8080</port>
                    <!--项目名-->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

步骤4：创建Controller类

//表示HelloController将交给spring容器管理，即在spring容器中会存在一个名字为"helloController"的对象
@Controller
public class HelloController {
	//将请求和处理请求的控制器方法关联起来,建立映射关系，Map<"/hello", hello()>
    @RequestMapping("/hello")
    public ModelAndView hello() {
        //ModelAndView对象封装了模型数据和视图名称
        ModelAndView mv = new ModelAndView();
        //添加数据，request.setAttribute(“hello”,”hello springmvc!!”)
        mv.addObject("hello", "欢迎你 springmvc");
        //设置逻辑视图路径
        mv.setViewName("success");
        //返回数据和视图
        return mv;
    }
}

步骤5：设置映射关系

配置springmvc.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" 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.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.by"></context:component-scan>

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--开启springmvc注解支持：配置HandlerMapping和HandlerAdapter-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

配置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">
    <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.xml</param-value>
        </init-param>
        <!-- 表示容器在启动时立即创建servlet对象 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

步骤6：创建view页面

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <a href="/hello">hello</a>
  </body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<h2>${msg}</h2>
</body>
</html>

步骤7：运行tomcat进行测试

访问：http://localhost:8080/hello

2.2 总结

一次性工作
- 创建工程，设置服务器，加载工程
- 导入坐标
- 创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
- SpringMVC核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
多次工作
- 定义处理请求的控制器类
- 定义处理请求的控制器方法，并配置映射路径（@RequestMapping)

3.RequestMapping注解

作用：用于建立请求URL和处理请求方法之间的对应关系。
使用位置：
- 类上：
  
  请求 URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。它出现的目的是为了使我们的 URL 可以按照模块化管理，例如：
  
  账户模块：
  
  /account/add
  
  /account/update
  
  /account/delete …
  
  订单模块：
  
  /order/add
  
  /order/update
  
  /order/delete
  
  红色的部分就是把RequsetMappding写在类上，使我们的URL更加精细。
- 方法上：
  
  请求URL的第二级访问目录，可以窄化请求路径
属性：

value：用于指定请求的URL。它和path属性的作用是一样的。

method：用于指定请求的方式。可用特定注解代替。如：

@RequestMapping(value = "/account",method = RequestMethod.GET)
//可替换成
@GetMapping("/account")

//其他请求方式同理
@PostMapping("/account")
...

注意：以上属性只要出现2个或以上时，他们的关系是与的关系。

示例

/*
* value：用于指定请求的URL。
* method：用于指定请求的方式。 
*/
@Controller
@RequestMapping("/account")
public class AccountController {
	//请求URL的第二级访问目录，可以窄化请求路径
    @RequestMapping("/findAccount")
    public ModelAndView findAccount() {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "欢迎你 springmvc");
        mv.setViewName("success");
        return mv;
    }
}

在index.jsp中测试

<a href="/account/findAccount">窄化路径</a>

4.controller方法返回值

4.1 返回ModelAndView

说明：controller方法中定义ModelAndView对象并返回，对象中可添加model数据、指定view

入门案例就是使用返回ModelAndView方式，不再举例说明。

4.2 返回字符串

4.2.1 逻辑视图名

说明：controller方法返回字符串可以指定逻辑视图名，通过视图解析器解析为物理视图地址。

跳转到指定页面

@Controller
@RequestMapping("/account")
public class AccountController {
  @RequestMapping(value = "/findAccount2")
  public String findAccount2(Model model) {
      //添加数据
      model.addAttribute("msg", "欢迎你 springmvc");
      //返回视图名（jsp页面名）
      return "success";
  }
}

4.2.2 Redirect重定向

说明：
- Contrller方法返回结果重定向到一个url地址，如下商品修改提交后重定向到商品查询方法，参数无法带到商品查询方法中。
- redirect方式相当于response.sendRedirect()，转发后浏览器的地址栏变为转发后的地址，因为转发即执行了一个新的request和response。
- 由于新发起一个request原来的参数在转发时就不能传递到下一个url，如果要传参数可以/item/queryItem后边加参数，如下：/item/queryItem?...&…..

重定向

  @Controller
  @RequestMapping("/account")
  public class AccountController {
      
      @RequestMapping(value = "/findAccount3")
      public String findAccount3() {
      	//redirect:设置重定向
          return "redirect:/account/findAccount4";
      }
  
      @RequestMapping(value = "/findAccount4")
      public String findAccount4(Model model) {
          //添加数据
          model.addAttribute("msg", "这是springmvc的重定向");
          return "success";
      }
  }

4.2.3 forward转发

说明：
- controller方法执行后继续执行另一个controller方法，如商品修改提交后转向到商品查询页面，修改商品的id参数可以带到商品查询方法中。
- forward方式相当于request.getRequestDispatcher().forward(request,response)，转发后浏览器地址栏还是原来的地址。
  转发并没有执行新的request和response，而是和转发前的请求共用一个request和response。所以转发前请求的参数在转发后仍然可以读取到。

重定向

@Controller
@RequestMapping("/account")
public class AccountController {
  
  @RequestMapping(value = "/findAccount3")
  public String findAccount3() {
  	//forward:设置转发
      return "forward:/account/findAccount4";
  }

  @RequestMapping(value = "/findAccount4")
  public String findAccount4(Model model) {
      //添加数据
      model.addAttribute("msg", "这是springmvc的重定向");
      return "success";
  }
}

5.参数接收

Springmvc中，接收页面提交的数据是通过方法形参来接收：

处理器适配器调用springmvc使用反射将前端提交的参数传递给controller方法的形参
springmvc接收的参数都是String类型，所以spirngmvc提供了很多converter（转换器）在特殊情况下需要自定义converter，如对日期数据

5.1 接收基本数据类型

编写controller

@Controller
@RequestMapping("/account")
public class AccountController {

  @RequestMapping("/findAccount5")
  public String findAccount5(String username,Model model){
      model.addAttribute("msg", username);
      return "success";
  }
  
  @RequestMapping("/findAccount6")
  public String findAccount6(String username,Integer age,Model model){
      model.addAttribute("msg", username+" "+age);
      return "success";
  }
}

在index.jsp里面定义超链接

<a href="/account/findAccount5?username=eric">参数接收-基本数据类型</a>
<a href="/account/findAccount6?username=eric&age=22">参数接收-多个基本数据类型</a>

5.2 接收实体类型

编写pojo

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    private Address address;
   //省略get set toString方法
 }

public class Address implements Serializable {
    private String provinceName;
    private String cityName;
     //省略get set toString方法
 }

编写controller

package com.by.controller;

import com.by.pojo.Account;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/saveAccount")
    public String saveAccount(Account account, Model model){
        model.addAttribute("msg", account);
        return "success";
    }
}

在index.jsp里面添加表单

<form action="account/saveAccount" method="post">
    账户名称：<input type="text" name="name"><br/>
    账户金额：<input type="text" name="money"><br/>
    账户省份：<input type="text" name="address.provinceName"><br/>
    账户城市：<input type="text" name="address.cityName"><br/>
    <input type="submit" value="保存">
</form>

5.3 接收日期类型

5.3.1 问题分析

在index.jsp里面添加日期类型

    <form action="account/saveAccount" method="post">
      账户名称：<input type="text" name="name"><br/>
      账户金额：<input type="text" name="money"><br/>
      账户省份：<input type="text" name="address.provinceName"><br/>
      账户城市：<input type="text" name="address.cityName"><br/>
      开户日期：<input type="text" name="date"><br/>
      <input type="submit" value="保存">
    </form>

在pojo里面添加日期类型

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;
    private Address address;
    //添加日期类型
    private Date date;
    //省略get set toString方法
}

测试

400报错

原因

我们前台传递的是字符串类型的参数，但是后台使用的是Date类型接收的。我们期望springmvc可以帮我们做数据类型的自动转换，显然没有做，所以我们需要自己自定义类型转换器。

5.3.2 自定义类型转换器

Converter接口说明：

定义一个类，实现Converter接口

public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        try {
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            return format.parse(source);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

在 springmvc.xml配置文件中配置类型转换器

<!--开启springmvc注解支持-->
<mvc:annotation-driven conversion-service="cs"></mvc:annotation-driven>
<!-- 配置类型转换器工厂 -->
<bean id="cs"
      class="org.springframework.context.support.ConversionServiceFactoryBean">
    <!-- 给工厂注入一个新的类型转换器 -->
    <property name="converters">
        <set>
            <!-- 配置自定义类型转换器 -->
            <bean class="com.by.converter.DateConverter"></bean>
        </set>
    </property>
</bean>

5.4 restful风格

restful(Representational State Transfer)表现层状态转移：URL定位资源时，用HTTP动词（GET，POST，DELETE，PUT）描述操作

5.4.1 restful风格URL

在Restful之前的操作：

http://127.0.0.1/user/query?id=1根据用户id查询用户数据
http://127.0.0.1/user/getUser?id=1根据用户id查询用户数据
http://127.0.0.1/user/selectUser?id=1根据用户id查询用户数据
http://127.0.0.1/user/save新增用户
http://127.0.0.1/user/addUser新增用户
http://127.0.0.1/user/insertUser新增用户
http://127.0.0.1/user/update?id=1修改用户信息
http://127.0.0.1/user/delete?id=1删除用户信息
RESTful用法：

http://127.0.0.1/user/1GET根据用户id查询用户数据
http://127.0.0.1/userPOST新增用户
http://127.0.0.1/userPUT修改用户信息
http://127.0.0.1/user/1DELETE删除用户信息
RESTful总结：

Restful风格就是请求url统一，根据不同的请求方式，请求不同的后台方法。如果需要携带参数，在url上使用/{}占位符。

5.4.2 @PathVaribale

作用：

用于绑定url中的占位符。例如：/account/{id}，这个{id}就是url占位符

url支持占位符是spring3.0之后加入的，是springmvc支持rest风格url的重要标志。

示例

@Controller
@RequestMapping("/account")
public class AccountController {
    
	@RequestMapping(value="/findAccount7/{id}")
    public String findAccount11(@PathVariable Integer id, Model model){
        model.addAttribute("msg", id);
        return "success";
    }
}

测试：在index.jsp里面定义超链接

<a href="/account/findAccount7/123">restful传参</a><br>

5.5 请求参数乱码问题

5.5.1 POST请求方式解决乱码问题

在web.xml里面设置编码过滤器

<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>
</filter>
<!-- 过滤所有请求 -->
<filter-mapping>
  <filter-name>CharacterEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

5.5.2 GET请求方式解决乱码问题

tomcat对GET和POST请求处理方式是不同的，GET请求的编码问题，要改tomcat的配置信息，pom.xml添加如下代码：

<plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <version>2.2</version>
    <configuration>
        <port>8080</port>
        <path>/</path>
        <!--按UTF-8进行编码-->
        <uriEncoding>UTF-8</uriEncoding>
    </configuration>
</plugin>

5.6 使用ServletAPI接收参数

@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/findAccount8")
    public String findAccount8(HttpServletRequest request, 
                               HttpServletResponse response){
        String username = request.getParameter("name");
        String age = request.getParameter("age");
        request.setAttribute("msg",username+" "+age);
        return "success";
    }
}

6.参数传递

6.1 ModelAndView传递

@Controller
@RequestMapping("/account")
public class AccountController {

    //也可以不创建ModelAndView，直接在参数中指定
    @RequestMapping(value = "/findAccount9")
    public ModelAndView findAccount9(ModelAndView mv) {
    	//设置参数
        mv.addObject("msg", "欢迎你 springmvc");
        //跳转页面
        mv.setViewName("success");
        return mv;
    }
}

6.2 Model传递

@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping(value = "/findAccount10")
    public String findAccount10(Model model) {
    	//设置参数
        model.addAttribute("msg", "欢迎你 springmvc");
        //跳转页面
        return "success";
    }
}

6.3 ServletAPI传递

@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/findAccount11")
    public String findAccount11(HttpServletRequest request, 
                                HttpServletResponse response){
		//设置参数
        request.setAttribute("msg","欢迎你 springmvc");	
        //跳转页面
        return "success";
    }
}

7.JSON数据处理

7.1 添加json依赖

springmvc 默认使用jackson作为json类库,不需要修改applicationContext-servlet.xml任何配置，只需引入以下类库springmvc就可以处理json数据：

<!--spring-json依赖-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

7.2 接收json

@RequestBody

该注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到要返回的对象上，再把HttpMessageConverter返回的对象数据绑定到 controller中方法的参数上。

简单来说就是接收前端ajax传递给后端的json字符串，并将json格式的数据转为java对象。

接收方式：

使用对象

public AjaxResult findAccount(@RequestBody Account account){}

使用Map

public AjaxResult findAccount(@RequestBody Map map){}

7.3 传递json

@ResponseBody

该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区

作用于方法上，将java对象转为json格式的数据传递给前台ajax。

传递方式：

使用对象

@ResponseBody
public AjaxResult findAccount(){}

使用Map

@ResponseBody
public Map findAccount(){}

7.4 案例

编写controller

@Controller
@RequestMapping("/account")
public class AccountController {

    @RequestMapping("/saveAccount2")
    @ResponseBody
    public Map saveAccount2(@RequestBody Account account){
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("status",200);
        map.put("msg",account);
        return map;
    }
}

在index.jsp里面定义ajax请求

添加按钮

<input type="button" value="测试ajax请求json和响应json" id="testJson"/>

引入js库文件

	<script src="http://libs.baidu.com/jquery/1.9.0/jquery.js"></script>

编写ajax代码

  <script type="text/javascript">
    $(function(){
      $("#testJson").click(function(){
        $.ajax({
          type:"post",
          url:"/account/saveAccount2",
          contentType:"application/json;charset=UTF-8",
          data:'{"id":1,"name":"张二狗","money":999.0}',
          success:function(data){
            if(data.status == 200){
              alert(data.msg.name);
              alert(data.msg.money);
            }
          }
        })
      });
    })
  </script>