SpringMVC(2)：JSON

一，JSON 介绍

JSON (JavaScript Object Notation, JS 对象简谱) 是一种轻量级的数据交换格式。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

二，JSON 语法

1，JSON 语法规则

在 JS 语言中，一切都是对象。因此，任何支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。但是对象和数组是比较特殊且常用的两种类型

• 对象表示为键值对

• 数据由逗号分隔

• 花括号保存对象

• 方括号保存数组

2，JSON 键/值对

JSON 键值对是用来保存 JS 对象的一种方式，和 JS 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 " " 包裹，使用冒号 :  分隔，然后紧接着值

1 1 { "firstName" : "Json" } 等价于这条 JavaScript 语句：{ firstName : "Json" }

3，JSON 与 JS 对象的关系

很多人搞不清楚 JSON 和 JS对象的关系，甚至连谁是谁都不清楚。其实可以这么理解：JSON 是 JS 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串

1 var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
2
3 var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

4，JSON 和 JS 对象互转

要实现从JSON字符串转换为JS对象，使用 JSON.parse() 方法

1 var obj = JSON.parse('{"a": "Hello", "b": "World"}'); 2 //结果是 {a: 'Hello', b: 'World'}

要实现从JS对象转换为JSON字符串，使用 JSON.stringify() 方法

1 var json = JSON.stringify({a: 'Hello', b: 'World'}); 2 //结果是 '{"a": "Hello", "b": "World"}'

三，使用Controller实现返回JSON数据

1，搭建实验环境

配置springmvc-servlet.xml【注意：为了决解乱码问题，我们在配置文件中导入相关代码】

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xmlns:mvc="http://www.springframework.org/schema/mvc"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7         http://www.springframework.org/schema/beans/spring-beans.xsd
 8         http://www.springframework.org/schema/context
 9         http://www.springframework.org/schema/context/spring-context.xsd
10         http://www.springframework.org/schema/mvc
11         http://www.springframework.org/schema/mvc/spring-mvc.xsd">
12
13     <context:component-scan base-package="com.shandx.controller"/>
14     <mvc:default-servlet-handler/>
15     <mvc:annotation-driven>
16
17         <!--JSON格式乱码处理方式-->
18         <mvc:message-converters register-defaults="true">
19             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
20                 <constructor-arg value="UTF-8"/>
21             </bean>
22             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
23                 <property name="objectMapper">
24                     <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
25                         <property name="failOnEmptyBeans" value="false"/>
26                     </bean>
27                 </property>
28             </bean>
29         </mvc:message-converters>
30     </mvc:annotation-driven>
31     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
32         <property name="prefix" value="/WEB-INF/jsp/"/>
33         <property name="suffix" value=".jsp"/>
34     </bean>
35
36 </beans>

配置web.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3          xmlns="http://java.sun.com/xml/ns/javaee"
 4          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 5          http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 6          id="WebApp_ID" version="3.0">
 7
 8   <!--1.注册DispatcherServlet-->
 9   <servlet>
10     <servlet-name>SpringMVC</servlet-name>
11     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
12     <!--2.关联SpringMVC配置文件-->
13     <init-param>
14       <param-name>contextConfigLocation</param-name>
15       <param-value>classpath:springmvc-servlet.xml</param-value>
16     </init-param>
17
18     <!--3.这个东西要和服务器一起启动-->
19     <load-on-startup>1</load-on-startup>
20   </servlet>
21
22   <servlet-mapping>
23     <servlet-name>SpringMVC</servlet-name>
24     <url-pattern>/</url-pattern>
25   </servlet-mapping>
26
27 </web-app>

Jackson是目前比较好的json解析工具了，我们这里使用Jackson，使用它需要导入它的jar包

1 <dependency>
2       <groupId>com.fasterxml.jackson.core</groupId>
3       <artifactId>jackson-databind</artifactId>
4       <version>2.9.8</version>
5 </dependency>

2，编写User实体类

User实体类

 1 public class User {
 2
 3     private String name;
 4     private int age;
 5     private String sex;
 6
 7     public User() {
 8     }
 9
10     public User(String name, int age, String sex) {
11         this.name = name;
12         this.age = age;
13         this.sex = sex;
14     }
15
16     public String getName() {
17         return name;
18     }
19
20     public void setName(String name) {
21         this.name = name;
22     }
23
24     public int getAge() {
25         return age;
26     }
27
28     public void setAge(int age) {
29         this.age = age;
30     }
31
32     public String getSex() {
33         return sex;
34     }
35
36     public void setSex(String sex) {
37         this.sex = sex;
38     }
39
40     @Override
41     public String toString() {
42         return "User{" +
43                 "name='" + name + '\'' +
44                 ", age=" + age +
45                 ", sex='" + sex + '\'' +
46                 '}';
47     }
48
49 }

3，测试Controller

1，编写Controller时我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象

 1 @Controller
 2 public class UserController {
 3
 4     @RequestMapping("/json1")
 5     @ResponseBody
 6     public String getJson1() throws JsonProcessingException {
 7
 8         ObjectMapper mapper=new ObjectMapper();
 9         User user = new User("钢铁侠",52,"男");
10         String s = mapper.writeValueAsString(user);
11
12         return s;
13     }
14 }

运行结果

2，JSON还可以打印集合

 1 @Controller
 2 public class UserController {
 3
 4     @RequestMapping("/json2")
 5     @ResponseBody
 6     public String getJson2() throws JsonProcessingException {
 7
 8         ObjectMapper mapper=new ObjectMapper();
 9         List<User> list=new ArrayList<>();
10         User user1 = new User("钢铁侠",1,"男");
11         User user2 = new User("蜘蛛侠",2,"男");
12         User user3 = new User("闪电侠",3,"男");
13         list.add(user1);
14         list.add(user2);
15         list.add(user3);
16         String s = mapper.writeValueAsString(list);
17
18         return s;
19     }
20 }

运行结果

3，创建一个时间日期的对象

 1 @Controller
 2 public class UserController {
 3
 4     @RequestMapping("/json3")
 5     @ResponseBody
 6     public String getJson3() throws JsonProcessingException {
 7
 8         ObjectMapper mapper = new ObjectMapper();
 9         //1.如何让他不返回时间戳！所以我们要关闭它的时间戳功能
10         mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
11         //2.时间格式化问题！自定日期格式对象；
12         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
13         //3.让mapper指定时间日期格式为simpleDateFormat；
14         mapper.setDateFormat(sdf);
15
16         Date date = new Date();
17         String s = mapper.writeValueAsString(date);
18
19         return s;
20     }
21  }

运行结果

4，我们也可以把上面的代码封装成一个工具类

 1 public class JsonUtils {
 2
 3     public static String getJson(Object object) {
 4
 5         return getJson(object, "yyyy-MM-dd HH:mm:ss");
 6     }
 7
 8
 9     public static String getJson(Object object, String dateFormat) {
10         ObjectMapper mapper = new ObjectMapper();
11         mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
12         SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
13         mapper.setDateFormat(sdf);
14
15         try {
16             String s = mapper.writeValueAsString(object);
17             return s;
18         } catch (JsonProcessingException e) {
19             e.printStackTrace();
20         }
21         return null;
22     }
23 }

再次创建时间日期的对象时，我们只需要调方法即可

 1 @Controller
 2 public class UserController {
 3
 4     @RequestMapping("/json4")
 5     @ResponseBody
 6     public String getJson4() throws JsonProcessingException {
 7
 8         return JsonUtils.getJson(new Date());
 9
10     }
11  }