Java 返回xml响应的步骤spring反应式web应用程序

我正在尝试sprint反应式web应用程序的春季操场教程

我希望响应是xml格式的，但是当我将@XmlRootElement提供给Person类并调用 只有存储库中的第一个人才能获取响应

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<person>
    <age>41</age>
    <id>58a47bf7832db7039db3a287</id>
    <name>Stephine maldini</name>
</person>

41
58a47bf7832db7039db3a287
斯蒂芬·马尔蒂尼

但是删除@XmlRootElement会以Json格式返回所有Person [ { “id”：“58a47bf7832db7039db3a287”， “姓名”：“斯蒂芬·马尔蒂尼”， “年龄”：41 }, { “id”：“58a47bf8832db7039db3a288”， “名称”：“Arjen Poutsma”， “年龄”：10岁 }, { “id”：“58a47bf8832db7039db3a289”， “姓名”：“Josh long”， “年龄”：81 }, { “id”：“58a47bf8832db7039db3a28a”， “姓名”：“Rossen Stoyanchev”， “年龄”：2 }, { “id”：“58a47bf8832db7039db3a28b”， “名称”：“Sebastin Deleuse”， “年龄”：72 }, { “id”：“58a47c03832db7039ebcfbc6”， “姓名”：“斯蒂芬·马尔蒂尼”， “年龄”：63 }, { “id”：“58a47c03832db7039ebcfbc7”， “名称”：“Arjen Poutsma”， “年龄”：83 } ]

课程和POM如下所示

package com.playground;

import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.stereotype.Component;

import javax.xml.bind.annotation.XmlRootElement;

import org.springframework.data.annotation.Id;
@Component
@XmlRootElement 
@Document

public class Person {
@Id
  private String id;

  private String name;

  private int age;

  public Person(){

  }
  public String getId() {
    return id;
}
public void setId(String id) {
    this.id = id;
}
public Person ( String name, int age) {
      this.name = name;
      this.age= age;
  }

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
@Override
public String toString() {
    return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}


package com.playground;

import java.util.concurrent.CompletableFuture;
import java.util.stream.Stream;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;





public interface PersonRepository extends MongoRepository<Person, String> {

    @Query("{}")
    Stream<Person> all();

    CompletableFuture<Person> findById(String id);
}
package com.playground;

import java.util.Optional;

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.Request;
import org.springframework.web.reactive.function.Response;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Component
public class PersonHandler {

    private final PersonRepository personRepository;

    public PersonHandler(PersonRepository personRepository) {

        this.personRepository = personRepository;
    }

    Response<Flux<Person>> all(Request request) {

        Flux<Person> flux =  Flux.fromStream(this.personRepository.all());
        return Response.ok().body(BodyInserters.fromPublisher(flux, Person.class));
    }

    Response<Mono<Person>> byId(Request request) {
    Optional<String> optional = request.pathVariable("id");
    return optional.map(id -> this.personRepository.findById(id))
            .map(person -> Mono.fromFuture(person))
            .map(mono -> Response.ok().body( BodyInserters.fromPublisher(mono, Person.class)))

            .orElseThrow(() -> new IllegalStateException("Oops"));
    }

}





   package com.playground;

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;

    import org.springframework.context.annotation.Bean;

    import org.springframework.http.server.reactive.HttpHandler;
    import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;

    import org.springframework.web.reactive.function.RouterFunction;
    import org.springframework.web.reactive.function.RouterFunctions;


    import reactor.ipc.netty.http.server.HttpServer;

    import static org.springframework.web.reactive.function.RequestPredicates.GET;

    import java.io.IOException;

    @SpringBootApplication
    public class SpringReactiveLearninAdithiApplication {

        @Bean
        RouterFunction<?> router (PersonHandler handler) {
            return RouterFunctions.route( GET ("/persons"), handler::all)
                    .and(RouterFunctions.route (GET("/persons/{id}"), handler::byId));
        }

        @Bean
        public  HttpServer startReactorServer(RouterFunction<?> router) throws InterruptedException {
            HttpHandler httpHandler = RouterFunctions.toHttpHandler(router);
            ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
            HttpServer server = HttpServer.create(8090);
            server.newHandler(adapter).block();
            return server;
        }
        public static void main(String[] args) throws IOException {
            SpringApplication.run(SpringReactiveLearninAdithiApplication.class, args);
            System.out.println("Press ENTER to exit.");
            System.in.read();

        }
    }



<?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.reactor.xample</groupId>
    <artifactId>reactive-learning</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-reactive-learnin</name>
    <description> project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.BUILD-SNAPSHOT</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web-reactive</artifactId>
            <version>5.0.0.M2</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-buffer</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectreactor.spring</groupId>
            <artifactId>reactor-spring-context</artifactId>
            <version>1.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>io.projectreactor.ipc</groupId>
            <artifactId>reactor-netty</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot.experimental</groupId>
                <artifactId>spring-boot-dependencies-web-reactive</artifactId>
                <version>0.1.0.BUILD-SNAPSHOT</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

package.com；
导入org.springframework.data.mongodb.core.mapping.Document；
导入org.springframework.stereotype.Component；
导入javax.xml.bind.annotation.XmlRootElement；
导入org.springframework.data.annotation.Id；
@组成部分
@XmlRootElement
@文件
公共阶层人士{
@身份证
私有字符串id；
私有字符串名称；
私人互联网；
公众人士（）{
}
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公众人物（字符串名称，整数年龄）{
this.name=名称；
这个。年龄=年龄；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共整数getAge（）{
回归年龄；
}
公共无效设置（整数）{
这个。年龄=年龄；
}
@凌驾
公共字符串toString（）{
返回“Person[id=“+id+”，name=“+name+”，age=“+age+””；
}
}
包com.playder；
导入java.util.concurrent.CompletableFuture；
导入java.util.stream.stream；
导入org.springframework.data.mongodb.repository.MongoRepository；
导入org.springframework.data.mongodb.repository.Query；
公共接口PersonRepository扩展了MongoRepository{
@查询（“{}”）
流全部（）；
CompletableFuture findById（字符串id）；
}
包com.playder；
导入java.util.Optional；
导入org.springframework.stereotype.Component；
导入org.springframework.web.reactive.function.BodyInserters；
导入org.springframework.web.reactive.function.Request；
导入org.springframework.web.reactive.function.Response；
导入reactor.core.publisher.Flux；
导入reactor.core.publisher.Mono；
@组成部分
公共类PersonHandler{
私人最终个人储存库个人储存库；
公共PersonHandler（PersonRepository PersonRepository）{
this.personRepository=personRepository；
}
全部响应（请求）{
Flux-Flux=Flux.fromStream（this.personRepository.all（））；
返回Response.ok（）.body（BodyInserters.fromPublisher（flux，Person.class））；
}
响应byId（请求）{
可选=request.pathVariable（“id”）；
返回可选的.map（id->this.personRepository.findById（id））
.map（person->Mono.fromfourture（person））
.map（mono->Response.ok（）.body（BodyInserters.fromPublisher（mono，Person.class）））
.orElseThrow（（）->新的非法状态例外（“Oops”）；
}
}
包com.playder；
导入org.springframework.boot.SpringApplication；
导入org.springframework.boot.autoconfigure.springboot应用程序；
导入org.springframework.context.annotation.Bean；
导入org.springframework.http.server.reactive.HttpHandler；
导入org.springframework.http.server.reactive.ReactorHttpHandlerAdapter；
导入org.springframework.web.reactive.function.RouterFunction；
导入org.springframework.web.reactive.function.RouterFunctions；
导入reactor.ipc.netty.http.server.HttpServer；
导入静态org.springframework.web.reactive.function.RequestPredicates.GET；
导入java.io.IOException；
@SpringBoot应用程序
公共类SpringReactiveLearnInAditiApplication{
@豆子
路由器功能路由器（PersonHandler）{
returnrouterfunctions.route（GET（“/persons”），handler:：all）
.and（RouterFunctions.route（GET（“/persons/{id}”），handler:：byId））；
}
@豆子
公共HttpServer StartActorServer（RouterFunction路由器）引发中断异常{
HttpHandler HttpHandler=RouterFunctions.toHttpHandler（路由器）；
ReactorHttpHandlerAdapter=新的ReactorHttpHandlerAdapter（httpHandler）；
HttpServer-server=HttpServer.create（8090）；
newHandler（适配器）.block（）；
返回服务器；
}
公共静态void main（字符串[]args）引发IOException{
run（SpringReactiveLearninAdithiApplication.class，args）；
System.out.println（“按回车键退出”）；
System.in.read（）；
}
}
4.0.0
com.reactor.example
反应式学习
0.0.1-快照
罐子
弹簧反应性学习素
springboot项目
org.springframework.boot
spring启动程序父级
2.0.0.1构建快照
UTF-8
UTF-8
1.8
org.springframework.boot
弹簧靴起动器
org.springframework.boot
spring引导启动器数据mongodb
org.springframework
弹簧网反应式
5.0.0.2平方米
伊奥·内蒂
网状缓冲器
org.projectreactor.spring
反应堆弹簧环境
1.1.3.1发布
io.projec