# Spring Boot REST XML 教程

> 原文： [http://zetcode.com/springboot/restxml/](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 格式的数据。

```java
$ 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`

```java
<?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`

```java
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`

```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 会创建这个实体表模式。

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

```

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

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

```

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

```java
@JacksonXmlProperty    
private String name;

@JacksonXmlProperty
private int population;

```

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

`Cities.java`

```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 输出。

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

```

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

`import.sql`

```java
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`

```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`

```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`

```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()`方法的实现。 我们使用存储库来处理数据。

```java
@Autowired
private CityRepository repository;

```

注入`CityRepository`。

```java
@Override
public Cities findAll() {

    var cities = (List<City>) repository.findAll();
    var mycities = new Cities();
    mycities.setCities(cities);

    return mycities;
}

```

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

`MyController.java`

```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 响应（通常）。

```java
@Autowired
private ICityService cityService;

```

我们在`countryService`字段中插入`ICityService`。

```java
@RequestMapping(value="/cities", produces=MediaType.APPLICATION_XML_VALUE)
public Cities findCities() {

    return cityService.findAll();
}

```

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

```java
@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`

```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`

```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`启用自动配置和组件扫描。

```java
$ mvn spring-boot:run

```

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

```java
$ 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`命令，我们可以获得所有城市。

```java
$ 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 教程](/articles/springbootcsv/)
*   [Spring Boot Jersey 教程](/springboot/jersey/)
*   [Spring Boot RestTemplate 教程](/springboot/resttemplate/)
*   [Spring Boot H2 REST 教程](/articles/springbootresth2/)
*   [Spring Boot Thymeleaf 教程](/articles/springbootthymeleaf/)
*   [Spring Boot Mustache 教程](/articles/springbootmustache/)
*   [Spring Boot Swing 集成教程](/articles/springbootswing/)
*   [Spring Web 应用介绍](/articles/springwebfirst/)
*   [Spring Boot RESTFul 应用](/articles/springbootrestsimple/)