Spring Boot REST XML 教程

原文： http://zetcode.com/springboot/restxml/

Spring Boot REST XML 教程展示了如何在 Spring Boot RESTFul 应用中提供 XML 数据。 我们为 RESTful 控制器创建测试方法。

Spring 是用于创建企业应用的流行 Java 应用框架。 Spring Boot 是 Spring 框架发展的下一步。 它有助于以最小的努力创建独立的，基于生产级的 Spring 应用。 它提倡在 XML 配置上使用约定而不是配置原则。

RESTFul 应用

RESTFul 应用遵循 REST 架构样式，该样式用于设计网络应用。 RESTful 应用生成对资源执行 CRUD（创建/读取/更新/删除）操作的 HTTP 请求。 RESTFul 应用通常以 JSON 或 XML 格式返回数据。

可扩展标记语言（XML）是一种标记语言，它定义了一组规则，用于以人类可读和机器可读的格式对文档进行编码。 XML 通常用于应用之间的数据交换。

Spring Boot REST XML 示例

以下应用是一个 Spring Boot RESTful 应用，它使用 Spring Data JPA 从 H2 数据库返回 XML 格式的数据。

$ tree
.
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── zetcode
    │   │           ├── Application.java
    │   │           ├── bean
    │   │           │   ├── Cities.java
    │   │           │   └── City.java
    │   │           ├── controller
    │   │           │   └── MyController.java
    │   │           ├── repository
    │   │           │   └── CityRepository.java
    │   │           └── service
    │   │               ├── CityService.java
    │   │               └── ICityService.java
    │   └── resources
    │       ├── application.yml
    │       └── import.sql
    └── test
        └── java
            └── com
                └── zetcode
                    └── test
                        └── RestControllerTest.java

这是项目结构。

pom.xml

<?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.zetcode</groupId>
    <artifactId>springbootrestxml</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
            <version>2.3.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

这是 Maven 构建文件。 h2依赖项包括 H2 数据库驱动程序。 jackson-dataformat-xml添加了 Jackson XML 序列化器和反序列化器。

Spring Boot 启动器是一组方便的依赖项描述符，可以极大地简化 Maven 配置。 spring-boot-starter-parent具有 Spring Boot 应用的一些常用配置。 spring-boot-starter-web是使用 Spring MVC（包括 RESTFul 应用）构建 Web 应用的入门工具。 它使用 Tomcat 作为默认的嵌入式容器。 spring-boot-starter-data-jpa是将 Spring Data JPA 与 Hibernate 结合使用的入门工具。 spring-boot-starter-test是使用包含 JUnit，Hamcrest 和 Mockito 的库测试 Spring Boot 应用的入门程序。

由于从 Java 11 中的 Java SE 中删除了 JAXB API，因此我们需要添加jaxb-api依赖项。

在spring-boot-maven-plugin提供了 Maven 的 Spring Boot 支持，使我们能够打包可执行的 JAR 或 WAR 档案。 它的spring-boot:run目标运行 Spring Boot 应用。

application.yml

server:
  port: 8086
  servlet:
    context-path: /rest
spring:
  main:
    banner-mode: "off"
jpa:
    database: h2
    hibernate:
    dialect: org.hibernate.dialect.H2Dialect
    ddl-auto: create-drop
logging:
  level:
    org:
    springframework: ERROR

在application.yml文件中，我们编写了 Spring Boot 应用的各种配置设置。 port设置服务器端口和context-path上下文路径（应用名称）。 完成这些设置后，我们可以通过localhost:8086/rest/访问该应用。 使用banner-mode属性，我们可以关闭 Spring 横幅。

JPA database值指定要操作的目标数据库。 在本例中，我们指定了 Hibernate 方言org.hibernate.dialect.H2Dialect。 ddl-auto是数据定义语言模式； create-drop选项将自动创建和删除数据库模式。

H2 数据库在内存中运行。 另外，我们将 spring 框架的日志记录级别设置为ERROR。 在application.yml文件位于中src/main/resources目录。

City.java

package com.zetcode.bean;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.io.Serializable;
import java.util.Objects;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "CITIES")
@JacksonXmlRootElement(localName = "City")
public class City implements Serializable {
    private static final long serialVersionUID = 21L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @JacksonXmlProperty(isAttribute = true)
    private Long id;
    @JacksonXmlProperty    
    private String name;
    @JacksonXmlProperty
    private int population;
    public City() {
    }
    public City(Long id, String name, int population) {
        this.id = id;
        this.name = name;
        this.population = population;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPopulation() {
        return population;
    }
    public void setPopulation(int population) {
        this.population = population;
    }
    @Override
    public String toString() {
        return "City{" + "id=" + id + ", name=" + name
                + ", population=" + population + '}';
    }
    @Override
    public int hashCode() {
        int hash = 5;
        hash = 37 * hash + Objects.hashCode(this.id);
        hash = 37 * hash + Objects.hashCode(this.name);
        hash = 37 * hash + this.population;
        return hash;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final City other = (City) obj;
        if (this.population != other.population) {
            return false;
        }
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        return Objects.equals(this.id, other.id);
    }
}

这是City实体。 每个实体必须至少定义两个注解：@Entity和@Id。 此前，我们已经设置了ddl-auto选项，create-drop这意味着 Hibernate 会创建这个实体表模式。

@Entity
@Table(name = "CITIES")
@JacksonXmlRootElement(localName = "City")
public class City implements Serializable {

@Entity注解指定该类是一个实体，并映射到数据库表。 @Table注解指定要用于映射的数据库表的名称。 使用@JacksonXmlRootElement(localName = "City")注解，我们为 XML 输出根元素设置了名称。

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@JacksonXmlProperty(isAttribute = true)
private Long id;

@Id注解指定实体的主键，@GeneratedValue提供生成主键值的策略。 使用@JacksonXmlProperty(isAttribute = true)，我们将id设置为 XML 输出中City元素的属性。

@JacksonXmlProperty    
private String name;
@JacksonXmlProperty
private int population;

使用@JacksonXmlProperty，我们将name和population属性设置为 XML 输出中 City 元素的属性。

Cities.java

package com.zetcode.bean;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
@JacksonXmlRootElement
public class Cities implements Serializable {
    private static final long serialVersionUID = 22L;
    @JacksonXmlProperty(localName = "City")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<City> cities = new ArrayList<>();
    public List<City> getCities() {
        return cities;
    }
    public void setCities(List<City> cities) {
        this.cities = cities;
    }
}

Cities bean 是一个帮助 bean，用于获取更好的 XML 输出。

@JacksonXmlProperty(localName = "City")
@JacksonXmlElementWrapper(useWrapping = false)
private List<City> cities = new ArrayList<>();

使用@JacksonXmlProperty和@JacksonXmlElementWrapper注解，我们确保Cities元素中嵌套了ArrayList城市对象的City元素。

import.sql

INSERT INTO CITIES(NAME, POPULATION) VALUES('Bratislava', 432000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Budapest', 1759000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Prague', 1280000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Warsaw', 1748000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Los Angeles', 3971000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('New York', 8550000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Edinburgh', 464000);
INSERT INTO CITIES(NAME, POPULATION) VALUES('Berlin', 3671000);

模式是由 Hibernate 自动创建的。 之后，执行import.sql文件以用数据填充 H2 表。

CityRepository.java

package com.zetcode.repository;
import com.zetcode.bean.City;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface CityRepository extends CrudRepository<City, Long> {
}

通过从 Spring CrudRepository扩展，我们将为我们的数据存储库实现一些方法，包括findAll()和findById()。 这样，我们节省了大量样板代码。

ICityService.java

package com.zetcode.service;
import com.zetcode.bean.City;
import com.zetcode.bean.Cities;
import java.util.Optional;
public interface ICityService {
    Cities findAll();
    Optional<City> findById(Long id);
}

ICityService提供了获取所有城市并通过其 ID 获得一个城市的契约方法。

CityService.java

package com.zetcode.service;
import com.zetcode.bean.Cities;
import com.zetcode.bean.City;
import com.zetcode.repository.CityRepository;
import java.util.List;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class CityService implements ICityService {
    @Autowired
    private CityRepository repository;
    @Override
    public Cities findAll() {
        var cities = (List<City>) repository.findAll();
        var mycities = new Cities();
        mycities.setCities(cities);
        return mycities;
    }
    @Override
    public Optional<City> findById(Long id) {
        var city = repository.findById(id);
        return city;
    }
}

CityService包含findAll()和findById()方法的实现。 我们使用存储库来处理数据。

@Autowired
private CityRepository repository;

注入CityRepository。

@Override
public Cities findAll() {
    var cities = (List<City>) repository.findAll();
    var mycities = new Cities();
    mycities.setCities(cities);
    return mycities;
}

注意，findAll()方法返回Cities bean。

MyController.java

package com.zetcode.controller;
import com.zetcode.bean.City;
import com.zetcode.bean.Cities;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import com.zetcode.service.ICityService;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MyController {
    @Autowired
    private ICityService cityService;
    @RequestMapping(value="/cities", produces=MediaType.APPLICATION_XML_VALUE)
    public Cities findCities() {
        return cityService.findAll();
    }
    @RequestMapping(value="/cities/{cityId}", produces=MediaType.APPLICATION_XML_VALUE)
    public City findCity(@PathVariable Long cityId) {
        var city = cityService.findById(cityId).get();
        return city;
    }
}

这是 Spring Boot RESTful 应用的控制器类。 @RestController注解创建一个 RESTful 控制器。 传统的 MVC 控制器使用ModelAndView，而 RESTful 控制器仅返回对象，并且对象数据通常以 JSON 或 XML 格式直接写入 HTTP 响应（通常）。

@Autowired
private ICityService cityService;

我们在countryService字段中插入ICityService。

@RequestMapping(value="/cities", produces=MediaType.APPLICATION_XML_VALUE)
public Cities findCities() {
    return cityService.findAll();
}

我们将带有/cities路径的请求映射到控制器的findCities()方法。 默认请求是 GET 请求。 通过使用MediaType.APPLICATION_XML_VALUE，Spring 使用了一个生成 XML 数据的消息转换器。

@RequestMapping(value="/cities/{cityId}", produces=MediaType.APPLICATION_XML_VALUE)
public City findCity(@PathVariable Long cityId) {
    var city = cityService.findById(cityId).get();
    return city;
}

在第二种方法中，我们返回一个特定的城市。 URL 路径包含要检索的城市的 ID； 我们使用@PathVariable注解将 URL 模板变量绑定到cityId参数。

RestControllerTest.java

package com.zetcode.test;
import java.util.List;
import com.zetcode.bean.City;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;
import org.springframework.test.context.junit4.SpringRunner;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Before;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.ParameterizedTypeReference;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class RestControllerTest {
    @Autowired
    private TestRestTemplate restTemplate;
    @Value("http://localhost:${local.server.port}/${server.servlet.context-path}/cities")
    private String appPath;
    private City c1, c2, c3;
    @Before
    public void setUp() {
        this.c1 = new City(1L, "Bratislava", 432000);
        this.c2 = new City(2L, "Budapest", 1759000);
        this.c3 = new City(3L, "Prague", 1280000);
    }
    @Test
    public void allCitiesTest() {
        var paramType = new ParameterizedTypeReference<List<City>>() { };
        var cities = restTemplate.exchange(appPath, HttpMethod.GET, null, paramType);
        assertThat(cities.getBody()).hasSize(8);
        assertThat(cities.getBody()).contains(this.c1, this.c2, this.c3);
    }
    @Test
    public void oneCity() {
        var city = this.restTemplate.getForObject(appPath + "/1/", City.class);
        assertThat(city).extracting("name", "population").containsExactly("Bratislava", 
                432000);
    }
}

RestControllerTest包含两种测试控制器方法的方法。

Application.java

package com.zetcode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Application设置 Spring Boot 应用。 @SpringBootApplication启用自动配置和组件扫描。

$ mvn spring-boot:run

使用mvn spring-boot:run命令，运行应用。 该应用部署在嵌入式 Tomcat 服务器上。

$ curl localhost:8086/rest/cities
<Cities>
<City id="1"><name>Bratislava</name><population>432000</population></City>
<City id="2"><name>Budapest</name><population>1759000</population></City>
<City id="3"><name>Prague</name><population>1280000</population></City>
<City id="4"><name>Warsaw</name><population>1748000</population></City>
<City id="5"><name>Los Angeles</name><population>3971000</population></City>
<City id="6"><name>New York</name><population>8550000</population></City>
<City id="7"><name>Edinburgh</name><population>464000</population></City>
<City id="8"><name>Berlin</name><population>3671000</population></City>
</Cities>

使用curl命令，我们可以获得所有城市。

$ curl localhost:8086/rest/cities/1
<City id="1"><name>Bratislava</name><population>432000</population></City>

在这里，我们得到了一个由其 ID 标识的城市。

在本教程中，我们已经从 Spring Boot RESTful 应用以 XML 格式将数据返回给客户端。 我们使用 Spring Data JPA 从 H2 数据库检索数据。 您可能也对相关教程感兴趣：

• Spring Boot CSV 教程
• Spring Boot Jersey 教程
• Spring Boot RestTemplate 教程
• Spring Boot H2 REST 教程
• Spring Boot Thymeleaf 教程
• Spring Boot Mustache 教程
• Spring Boot Swing 集成教程
• Spring Web 应用介绍
• Spring Boot RESTFul 应用