XML 文件的解析常见的解析工具有 DOM4j、JDOM 等，为了标准化 XML 文件解析，Java 中提出了 JAXP 规范，使用的解析模型有
优点：操作方便，可以对文档进行 CRUD 的所有操作
缺点：一次性加载进入内存形成 DOM 树，非常消耗资源
优点：不消耗资源
缺点：只能读取，不能增删改
public class Test2
{
public static void main(String\[] args) throws Exception
{
SAXParserFactory parserFactory = SAXParserFactory.newInstance();
SAXParser saxParser = parserFactory.newSAXParser();
final List < Student > studentList = new ArrayList < Student > ();
//因为 SAX 解析并不缓存数据， 所以解析过程中的数据需要自行编程实现存储
saxParser.parse("xml02/students.xml", new DefaultHandler()
{
private Student student = null;
private int flag = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException
{
if("student".equals(qName))
{
student = new Student();
String id = attributes.getValue("id"); //获取当前标签的指定名称的属性 if(id!=null && id.trim().length()>0) student.setId(id);
}
else if("name".equals(qName)) flag = 1;
else if("age".equals(qName)) flag = 2;
else if("sex".equals(qName)) flag = 3;
}
@Override
public void characters(char\[] ch, int start, int length) throws SAXException
{
String tmp = new String(ch, start, length);
if(tmp != null && tmp.trim().length() > 0)
{
if(flag == 1) student.setName(tmp.trim());
else if(flag == 2)
{
Integer kk = Integer.parseInt(tmp.trim());
student.setAge(kk);
}
else if(flag == 3) student.setSex(tmp.trim());
}
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException
{
flag = 0;
if("student".equals(qName)) studentList.add(student);
}
});
studentList.forEach(System.out::println);
}
}
早期数据传输使用 xml 作为交互格式，例如 webservice 技术，但是由于 xml 解析比较麻烦，所以现在在项目开发中，在接口与接口之间以及前后端之间数据的传输都使用 Json 格式，在 Spring Boot 中接口返回 Json 格式的数据很简单，在 Controller 中使用@RestController 注解即可返回 Json 格式的数据，@RestController 也是 Spring Boot 新增的一个复合注解。
源代码：其中 Target、Retention 和 Documented 是元注解
@Target({ElementType.TYPE}) 用于声明注解可以使用在什么地方，Type 表示可以使用在类上
@Retention(RetentionPolicy.RUNTIME) 用于声明注解需要保持到什么阶段，Runtime 表示注解在编译生成的字节码中一直保持到运行时
@Documented
@Controller
@ResponseBody
public @interface RestController { String value() default “”; }
可以看出 @RestController 注解包含了原来的 @Controller 和 @ResponseBody 注解，使用过 Spring 对 @Controller 注解用于声明当前类是控制器类，@ResponseBody 注解是将返回的数据结构转换为 Json 格式。所以在默认情况下，使用了@RestController 注解即可将返回的数据结构转换成 Json 格式，Spring Boot 中默认使用的 Json 解析技术框架是 jackson。点开 pom.xml 中的 spring-boot-starter-web 依赖，可以看到一个 spring-boot-starter-json 依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<scope>compile</scope> </dependency>
Spring Boot 中对依赖都做了很好的封装，可以看到很多 spring-boot-starter-xxx 系列的依赖，这是 Spring Boot 的特点之一，不需要人为去引入很多相关的依赖了，starter-xxx 系列直接都包含了所必要的依赖，所以再次点进去上面这个 spring-boot-starter-json 依赖，可以看到：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jdk8</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-parameter-names</artifactId>
<scope>compile</scope>
</dependency>
Spring Boot 中默认使用的 json 解析框架是 jackson。默认的 jackson 框架对常用数据类型的转 Json 处理。
1.Spring Boot 默认对 Json 的处理
在实际项目中，常用的数据结构无非有类对象、List 对象、Map 对象，默认的 jackson 框架对这三个常用的数据结构都可以转成 json 的格式。
1.1 创建 User 实体类需要创建一个实体类 User。
public class User
{
private Long id;
private String username;
private String password;
/\* 省略 get、set 和带参构造方法 \*/
}
1.2 创建 Controller 类然后创建一个 Controller，分别返回 User 对象、List和 Map<String, Object>。
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("/json")
public class JsonController {
@RequestMapping("/user")
public User getUser() {
return new User(1, "闫峻", "123456");
}
@RequestMapping("/list")
public List<User> getUserList() {
List<User> userList = new ArrayList<>();
User user1 = new User(1, "闫峻", "123456");
User user2 = new User(2, "死胖子", "123456");
userList.add(user1);
userList.add(user2);
return userList;
}
@RequestMapping("/map")
public Map<String, Object> getMap() {
Map<String, Object> map = new HashMap<>(3);
User user = new User(1, "闫峻", "123456");
map.put("作者信息", user);
map.put("博客地址", "http://blog.yan.com");
map.put("CSDN 地址", "http://blog.csdn.net/yanjun");
map.put("粉丝数量", 4153);
return map;
}
}
1.3 测试不同数据类型返回的 json
写好了接口，分别返回了一个 User 对象、一个 List 集合和一个 Map 集合，其中 Map 集合中的 value 存的是不同的数据类型
在浏览器中输入：localhost:8080/json/user 返回 json：
{“id”:1,“username”:“闫峻”,“password”:“123456”}
在浏览器中输入：localhost:8080/json/list 返回 json：
[{“id”:1, “username”:“闫峻”, “password”:“123456”}, {“id”:2, “username”:“死胖子”, “password”:“123456”}]
在浏览器中输入：`localhost:8080/json/map 返回 json：
{" 作 者 信 息 " : {“id”:1, “username”:" 闫 峻 ", “password”:“123456”}, "CSDN 地 址 " :
“http://blog.csdn.net/yanjun”, “粉丝数量”:4153, “博客地址”:“http://blog.yan.com”}
可以看出 map 中不管是什么数据类型，都可以转成相应的 json 格式，这样就非常方便。
1.4 jackson 中对 null 的处理
在实际项目中，难免会遇到一些 null 值出现，转 json 时是不希望有这些 null 出现的，比如期望所有的 null 在转 json 时都变成""这种空字符串，那怎么做呢？在 Spring Boot 中做一下配置即可，新建一个 jackson 的配置类：
```java
```
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import java.io.IOException;
@Configuration //用于声明当前类是一个配置类，最新的注解为
@SpringBootConfiguration
public class JacksonConfig {
@Bean
//用于在配置类中,表示方法的返回值是一个受管 bean
@Primary
//如果多个配置，则以当前的为主
@ConditionalOnMissingBean(ObjectMapper.class)
//条件注解，表示如果受管 bean中没有,ObjectMapper类型的对象，则需要构建
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
ObjectMapper objectMapper = builder.createXmlMapper(false).build();
objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
@Override
public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
throws IOException {
jsonGenerator.writeString("");
//针对 null 内容输出空字符串
}
});
return objectMapper;
}
}
然后修改一下上面返回 map 的接口， 将几个值改成 null 测试一下：
@RequestMapping("/map")
public Map<String, Object> getMap()
{
Map<String, Object> map=new HashMap<>(3);
User user=new User(1,"闫峻",null);
map.put("作者信息",user);
map.put("博客地址","<http://blog.yan.com>");
map.put("CSDN 地址",null);
map.put("粉丝数量",4153);
return map;
}
重启项目再次输入 localhost:8080/json/map，可以看到 jackson 已经将所有 null 字段转成了空字符串了。例如返回数据为
{“作者信息”:{“id”:1,“username”:“闫峻”,“password”:“”},“CSDN 地址”:“”,“粉丝数量”:4153,“博客地址”:“http://blog.yan.com”}
配置属性不参与映射输出
@JsonIgnore 指定该属性不参与 JSON 字符串的映射
private String password;
配置日期类型数据的映射格式:
@JsonFormat(pattern = "yyyy-MM-dd")
private Date birth=new Date();
2.整合通用 Mapper 的开发方法
通用 mapper 就是基于 mybatis 的一款 MyBatis 增强插件，可以提供一些常用增、删、改、查的操作，不需要重复写一些常用的 sql。简化操作，精简代码，并且达到代码风格统一的目的。它的出现不是为了替代 mybatis，而是让 mybatis 的开发更方便。
添加依赖：
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>4.2.2</version> </dependency>
使用通用 mapper 的开发方式，采用注解定义映射关系，自动生成常见的 SQL 语句，不需要 xml 映射元文件
1.表名默认使用类名,驼峰转下划线(只对大写字母进行处理),如 TestUser 默认对应的表名为 test_user 2.表名可以使用@Table(name = “tableName”)进行指定,对不符合第一条默认规则的可以通过这种方式指定表名.
3.字段默认和@Column 一样,都会作为表字段,表字段默认为 Java 对象的 Field 名字驼峰转下划线形式.
4.可以使用@Column(name = “fieldName”)指定不符合第 3 条规则的字段名
5.使用@Transient 注解可以忽略字段,添加该注解的字段不会作为表字段使用.
6.建议一定是有一个@Id 注解作为主键的字段,可以有多个@Id 注解的字段作为联合主键.
7.默认情况下,实体类中如果不存在包含@Id 注解的字段,所有的字段都会作为主键字段进行使用(这种效率极低).
8.实体类可以继承使用,可以参考测试代码中的 tk.mybatis.mapper.model.UserLogin2 类.
9.由于基本类型,如 int 作为实体类字段时会有默认值 0,而且无法消除,所以实体类中建议不要使用基本类型.
10.@NameStyle 注解，用来配置对象名/字段和表名/字段之间的转换方式，该注解优先于全局配置 style，可选值：
normal:使用实体类名/属性名作为表名/字段名 camelhump:这是默认值，驼峰转换为下划线形式 uppercase:转换为大写 lowercase:转换为小写
@Entity //用于声明当前类是一个实体类
@Table(name = "tbl_users") // 用于声明当前类所对应的表名称
public class User implements Serializable {
@Id //用于声明标识属性，对应表中的主键
@GeneratedValue(strategy = GenerationType.IDENTITY)
声明主键生成策略
private Long id;
@Column //如果属性名称和列名称不一致，则需要通过@Column 进行配置对应的列名称
private String username;
private String password;
private Date birth;
private Boolean sex;
}
定义 mapper 接口
public interface UserMapper extends BaseMapper<User> { }
针对 mapper 接口进行注册，一般是依赖自动扫描实现。可以在主类或者配置上添加一个注解配置
SpringBoot 针对 Junit 的单元测试有很好的支持
@SpringBootTest
class CommonMapperApplicationTests
{
@Autowired
private UserMapper userMapper;
@Test
void contextLoads()
{}
@Test
void testCreate()
{
User user = new User();
user.setUsername("张三丰");
user.setPassword("333333");
user.setSex(true);
int len = userMapper.insertSelective(user);
Assertions.assertEquals(1, len);
}
}
需要控制器调用业务，业务再通过 Mapper 访问数据库，最终返回 JSON 字符串
3.使用阿里巴巴 FastJson 的设置
3.1 jackson 和 fastJson 的对比
有很多人已经习惯于使用阿里巴巴的 fastJson 来做项目中 json 转换的相关工作，比如目前项目中使用的就是
阿里的 fastJson
| 选项 | fastJson | Jackson |
|---|---|---|
| 上手难易程度 | 容易 | 中等 |
| 高级特性支持 | 中等 | 丰富 |
| 官方文档、Example 支持 | 中文 | 英文 |
| 处理 json 速度 | 略快 | 快 |
关于 fastJson 和 jackson 的对比，网上有很多资料可以查看，主要是根据自己实际项目情况来选择合适的框架。从扩展上来看，fastJson 没有 jackson 灵活，从速度或者上手难度来看，fastJson 可以考虑，项目中目前使用的是阿里的 fastJson，挺方便的。
3.2 fastJson 依赖导入使用 fastJson 需要导入依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
3.3 使用 fastJson 处理 null 使用 fastJson 时，对 null 的处理和 jackson 有些不同，需要继承 WebMvcConfigurationSupport 类或者实现 WebMvcConfiguration 接口，然后覆盖 configureMessageConverters 方法，在方法中可以选择对要实现 null 转换的场景，配置好即可。
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class fastJsonConfig extends WebMvcConfigurationSupport {
//使用阿里 FastJson 作为 JSON MessageConverter
@Override
public void configureMessageConverters(List\ <HttpMessageConverter\ <?>>converters) {
FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
FastJsonConfig config = new FastJsonConfig();
config.setSerializerFeatures(SerializerFeature.WriteMapNullValue, // 保留 map 空的字段
SerializerFeature.WriteNullStringAsEmpty, // 将 String 类型的 null 转成""
SerializerFeature.WriteNullNumberAsZero, // 将 Number 类型的 null 转成 0
SerializerFeature.WriteNullListAsEmpty, // 将 List 类型的 null 转成[]
SerializerFeature.WriteNullBooleanAsFalse, // 将 Boolean 类型的 null 转成 false
SerializerFeature.DisableCircularReferenceDetect); // 避免循环引用
converter.setFastJsonConfig(config);
converter.setDefaultCharset(Charset.forName("UTF-8"));
List<MediaType> mediaTypeList = new ArrayList<>();
// 解决中文乱码问题，相当于在 Controller 上的@RequestMapping 中加了个属性 produces = "application/json" mediaTypeList.add(MediaType.APPLICATION_JSON); converter.setSupportedMediaTypes(mediaTypeList); converters.add(converter);
}
}
测试工具 postman
如果直接测试，则需要编写页面和 js 代码才能进行验证，可以使用 postman 避免这些繁琐的操作
这里针对日期类型数据的格式转换会有报错。最终提交数据为
{“username”:“谢逊”,“sex”:“true”,“birth”:“1989-02-03”,“password”:“666666”}
在实际项目中，除了要封装数据之外，往往需要在返回的 json 中添加一些其他信息，比如返回一些状态码 code 【注意不是 response 的响应状态码】，返回一些 msg 给调用者，这样调用者可以根据 code 或者 msg 做一些逻辑判断。所以在实际项目中，需要封装一个统一的 json 返回结构存储返回信息。
4.1 定义统一的 json 结构
由于封装的 json 数据的类型不确定，所以在定义统一的 json 结构时需要用到泛型。统一的 json 结构中属性包括数据、状态码、提示信息即可，构造方法可以根据实际业务需求做相应的添加即可，一般来说，应该有默认的返回结构，也应该有用户指定的返回结构。
public class JsonResult<T> {
private T data; //需要传递的数据
private int code; //用户自定义相应码，注意不是服务器响应状态码。如果不需要传递详细信息还可以使用 boolean success;
private String msg; // 服务器回传信息
public JsonResult() {
//若没有数据返回，默认状态码为 0，提示信息为：操作成功！
this.code = 0;
this.msg = "操作成功！";
}
public JsonResult(int code, String msg) {
//若没有数据返回，可以人为指定状态码和提示信息
this.code = code;
this.msg = msg;
}
public JsonResult(T data) {
//有数据返回时，状态码为 0，默认提示信息为：操作成功！
this.data = data;
this.code = 0;
this.msg = "操作成功！";
}
public JsonResult(T data, String msg) {
//有数据返回，状态码为 0，人为指定提示信息
this.data = data;
this.code = 0;
this.msg = msg;
}
// 省略 get 和 set 方法
}
4.2 修改 Controller 中的返回值类型及测试
由于 JsonResult 使用了泛型，所以所有的返回值类型都可以使用该统一结构，在具体的场景将泛型替换成具体的数据类型即可，非常方便，也便于维护。在实际项目中，还可以继续封装，比如状态码和提示信息可以定义一个枚举类型，以后只需要维护这个枚举类型中的数据即可。根据以上的 JsonResult 可以改写一下 Controller
@RestController
@RequestMapping("/jsonresult")
public class JsonResultController {
@RequestMapping("/user")
public JsonResult<User> getUser() {
User user = new User(1, "闫峻", "123456");
return new JsonResult<>(user);
}
@RequestMapping("/list")
public JsonResult<List> getUserList() {
List<User> userList = new ArrayList<>();
User user1 = new User(1, "闫峻", "123456");
User user2 = new User(2, "死胖子", "123456");
userList.add(user1);
userList.add(user2);
return new JsonResult<>(userList, "获取用户列表成功");
}
@RequestMapping("/map")
public JsonResult<Map> getMap() {
Map<String, Object > map = new HashMap<>(3);
User user = new User(1, "闫峻", null);
map.put("作者信息", user);
map.put("博客地址", "<http://blog.yan.com>");
map.put("CSDN 地址", null);
map.put("粉丝数量", 4153);
return new JsonResult<>(map);
}
}
重新在浏览器中输入：localhost:8080/jsonresult/user 返回 json：
{“code”:0,“data”:{“id”:1,“password”:“123456”,“username”:“闫峻”},“msg”:“操作成功！”} 输入：localhost:8080/jsonresult/list，返回 json 格式：
{“code”:0, “data”:[{“id”:1, “password”:“123456”, “username”:" 闫峻 "}, {“id”:2, “password”:“123456”,
“username”:“死胖子”}], “msg”:“获取用户列表成功”} 输入：localhost:8080/jsonresult/map，返回 json 格式：
{“code”:“0”, “data”:{“作者信息”:{“id”:1, “password”:“”,“username”:“闫峻”},“CSDN 地址”:null,“粉丝数量”:4153,“博客地址”:“http://blog.yan.com”},“msg”:“操作成功！”}
通过封装，不但将数据通过 json 传给前端或者其他接口，还带上了状态码和提示信息，这在实际项目场景中应用非常广泛。
这里主要是对 Spring Boot 中 json 数据的返回做了详细的分析，从 Spring Boot 默认的 jackson 框架到阿里的 fastJson 框架，分别对它们的配置做了相应的描述。另外，结合实际项目情况，总结了实际项目中使用的 json 封装结构体，加入了状态码和提示信息，使得返回的 json 数据信息更加完整。