Spring Boot REST XML 教程|极客教程

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 的春季启动支持，使我们能够打包可执行的 JAR 或 WAR 档案。它的spring-boot:run目标运行春季启动应用。

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 REST XML 教程

RESTFul 应用

Spring Boot REST XML 示例

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

Spring Boot 教程

回顶部

RESTFul 应用

Spring Boot REST XML 示例

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

Spring Boot 教程

回顶部

切换注册登录

用户名或邮箱

密码

切换登录注册

昵称

邮箱