Java 如何使用springreactor比较两个通量值

目前我是反应式编程新手， 我已经在两个文档中添加了数据，所以目前我尝试只将这些数据返回给在这两个文档中tokenIdentifier相同的客户机

请参考以下代码：

我有两个收藏

package com.mainApp;

import java.util.Date;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(value = "Token")
public class TokenData {

    @Id
    private String id;
    
    private String tokenIdentifier;
    
    private Date todayDate;
    
    
    public TokenData(String id, String tokenIdentifier, Date todayDate) {
        super();
        this.id = id;
        this.tokenIdentifier = tokenIdentifier;
        this.todayDate = todayDate;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTokenIdentifier() {
        return tokenIdentifier;
    }

    public void setTokenIdentifier(String tokenIdentifier) {
        this.tokenIdentifier = tokenIdentifier;
    }

    public Date getTodayDate() {
        return todayDate;
    }

    public void setTodayDate(Date todayDate) {
        this.todayDate = todayDate;
    }

    
    

}

我有一个控制器，它将只返回那些tokenData.GetTokenInIdentifier（）==TURCollection.GetTokenInIdentifier（）的tokenData

所以

@GetMapping（value=“/getAllToken”）
公共交通{
/*List returnData=new ArrayList（）；
List tokenData=tokenDataRepository.findAll（）.collectList（）.block（）；
List-turCollection=turRepository.findAll（）.collectList（）.block（）；
turCollection.forEach（tur->{
for（TokenData数据：TokenData）{
if（tur.getTokenIdentifier（）.equals（data.getTokenIdentifier（）））{
returnData.add（数据）；
}
}
});*/

但是block（）代码在反应式编程中不起作用

---

有谁能帮助我以反应方式比较两个通量的值吗？

您可以使用flux.collectList和Mono.flatMap的组合

Mono<List<TokenData>> tokenData = tokenDataRepository.findAll().collectList();
Mono<List<TURCollection>> turCollection = turRepository.findAll().collectList();
Mono<List<TokenData>> result = turCollection.flatMap(turs ->
  Set<String> ids = turs.stream().map(TURCollection::getId).collect(toSet());
  return tokenData.map(tokens ->
    tokens.stream().filter(token -> ids.contains(token.getId())).collect(toList())
  );
);

Mono-tokenData=tokenDataRepository.findAll（）.collectList（）；
Mono turCollection=turRepository.findAll（）.collectList（）；
Mono结果=turCollection.flatMap（turs->
Set id=turs.stream（）.map（TURCollection:：getId）.collect（toSet（））；
返回tokenData.map（令牌->
tokens.stream（）.filter（token->id.contains（token.getId（）））.collect（toList（））
);
);

谢谢你的回复，但使用这个方法，它只会给出那些getTokenIdentifier（）在给定位置相同的记录，就像如果getTokenIdentifier（）在第二个索引处相同，那么它只会给出。我的要求是让tokenDataRepository.findAll（）有3个getTokenIdentifier（）的记录是xyz和turRepository。findAll（）有1条记录，其getTokenIdentifier（）是xyz。因此，在结果中我应该得到3条记录。简言之，搜索令牌标识符与TURCOllection数据相同的令牌文档中的所有记录。它应该返回令牌文档的所有数据。@FarahnaazPathan检查更新的答案。

@GetMapping(value = "/getAllToken")
    public Flux<TokenData> getToken(){
        /*List<TokenData> returnData = new ArrayList<TokenData>();
        List<TokenData> tokenData = tokenDataRepository.findAll().collectList().block();
        
        List<TURCollection> turCollection = turRepository.findAll().collectList().block();
        
        turCollection.forEach(tur -> {
            for(TokenData data : tokenData) {
                if(tur.getTokenIdentifier().equals(data.getTokenIdentifier())) {
                    returnData.add(data);
                }
            }
        });*/

Mono<List<TokenData>> tokenData = tokenDataRepository.findAll().collectList();
Mono<List<TURCollection>> turCollection = turRepository.findAll().collectList();
Mono<List<TokenData>> result = turCollection.flatMap(turs ->
  Set<String> ids = turs.stream().map(TURCollection::getId).collect(toSet());
  return tokenData.map(tokens ->
    tokens.stream().filter(token -> ids.contains(token.getId())).collect(toList())
  );
);