BlogJava-paulwong-随笔分类-REACTIVE STREAMS

SPRING CLOUD - REACTIVE FEIGN

paulwong — Wed, 01 Dec 2021 08:45:00 GMT

目前SPRING CLOUD(2020)尚未支持REACTIVE FEIGN，但官方推荐使用feign-reactive。

pom.xml

<dependency>
    <groupId>com.playtika.reactivefeigngroupId>
    <artifactId>feign-reactor-spring-cloud-starterartifactId>
    <version>3.1.2version>
    <type>pomtype>
dependency>

LoanDecisionClientReactive.java

package com.paul.testspringcloudstream.loancheck.service;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import com.paul.testspringcloudstream.common.model.Loan;

import reactivefeign.spring.config.ReactiveFeignClient;
import reactor.core.publisher.Mono;

@ReactiveFeignClient(name = "loan-decision")
public interface LoanDecisionClientReactive {

    @PostMapping("/loan-decision")
    public Mono getDecision(@RequestBody Loan loan);

}

LoanCheckConfiguration.java

@Configuration
@Import({
MongoDbConsumerConfiguration.class,
})
@EnableDiscoveryClient
@EnableReactiveFeignClients("com.paul.testspringcloudstream.loancheck.service")
public class LoanCheckConfiguration {
}

使用同feign

@Autowired
private LoanDecisionClientReactive loanDecisionClientReactive;

Reference
https://blog.csdn.net/LCBUSHIHAHA/article/details/113817966

官方SAMPLE
https://github.com/kptfh/feign-reactive-sample

paulwong 2021-12-01 16:45 发表评论

SPRING REACTOR 之Flux和Mono

paulwong — Tue, 23 Nov 2021 06:30:00 GMT

SPRING REACTOR 之Flux和Mono，有点象SPRING INTEGRATION的IntegrationFlow，有如下特点

定义了针对某种类型数据的处理流程
可以进行类型转换
长期运行，除非被要求中止
流程中的每种操作可以在新的线程中执行
可以正常中止，如果中途有异常，则该流程也会中止
要subscribe，流程才开始被启动
可以分割成各个子流程
可以聚合子流程
Mono发送一个数据，就发送中止信号
Flux发送任意数据，由程序决定何时发送中止信号

编程则比较简单，先根据不同的数据类型定义不同的Flux或Mono，业务操作用Function包装后，放在map/flatmap中，再调用subscribe启动流程。

paulwong 2021-11-23 14:30 发表评论

SPRING REACTOR 使用样例

paulwong — Tue, 23 Nov 2021 05:59:00 GMT

SpringReactorTest.java

package com.paul.testreactivestream.reactor;

import java.util.List;

import org.junit.jupiter.api.Test;

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

public class SpringReactorTest {

    private void subscribeAndEnd(Flux flux) {

        flux.map(c -> String.format("[%s] %s", Thread.currentThread().getName(), c))
            .subscribe(System.out::println);

        flux.blockLast();
    }

    @Test
    public void createAFlux_just() throws InterruptedException {
        Flux fruitFlux =
                Flux.just("Apple", "Orange", "Grape", "Banana", "Strawberry")
                    .log()
                    ;
        fruitFlux.subscribe(
                     f -> System.out.println(
                                 String.format("[%s] Here's some fruit: %s", Thread.currentThread().getName(), f)
                             )
                  )
                 ;
        fruitFlux.blockLast();

//        Thread.currentThread().join();
    }

    @Test
    public void zipFluxesToObject() {
        Flux characterFlux =
                Flux.just("Garfield", "Kojak", "Barbossa");

        Flux foodFlux =
                Flux.just("Lasagna", "Lollipops", "Apples");

        Flux zippedFlux =
                Flux.zip(characterFlux, foodFlux, (c, f) -> c + " eats " + f);

        this.subscribeAndEnd(zippedFlux);
    }

    @Test
    public void map() {
        Flux playerFlux =
                Flux.just("Michael Jordan", "Scottie Pippen", "Steve Kerr")
                    .map(n -> {
                        String[] split = n.split("\\s");
                        return new Player(split[0], split[1]);
                    })
                    ;
        this.subscribeAndEnd(playerFlux);
    }

    @Test
    public void flatMap() {
        Flux playerFlux =
                Flux.just("Michael Jordan", "Scottie Pippen", "Steve Kerr")
                    .flatMap(
                        n -> Mono.just(n)
                                 .map(p -> {
                                    String[] split = p.split("\\s");
                                    return new Player(split[0], split[1]);
                                  })
                                 .subscribeOn(Schedulers.parallel())
                     );
        this.subscribeAndEnd(playerFlux);
    }

    @Test
    public void buffer() {
        Flux> fruitFlux =
                Flux.just(
                        "apple", "orange", "banana", "kiwi", "strawberry"
                     )
                    .buffer(3);
        this.subscribeAndEnd(fruitFlux);
    }

    @Test
    public void bufferAsyn() {
        Flux flux =
            Flux.just(
                    "apple", "orange", "banana", "kiwi", "strawberry"
                 )
                .buffer(3)
                .flatMap(x ->
                    Flux.fromIterable(x)
                        .map(y -> y.toUpperCase())
                        .subscribeOn(Schedulers.parallel())
    //                    .log()
                 );
        this.subscribeAndEnd(flux);
    }

    @Test
    public void all() {
        Mono animalFlux =
                Flux.just(
                        "aardvark", "elephant", "koala", "eagle", "kangaroo"
                     )
                    .all(c -> c.contains("a"))
                    ;
        animalFlux.map(c -> String.format("[%s] %s", Thread.currentThread().getName(), c))
                  .subscribe(System.out::println);

    }

}

paulwong 2021-11-23 13:59 发表评论

SPRING REACTOR资源

paulwong — Tue, 23 Nov 2021 05:51:00 GMT

Spring Reactor 入门与实践
https://www.jianshu.com/p/7ee89f70dfe5

Project Reactor 核心原理解析
https://www.jianshu.com/p/df395eb28f69

Project Reactor 之 publishOn 与 subscribeOn
https://www.jianshu.com/p/769f6e9824fb

Spring响应式编程
 https://blog.csdn.net/get_set/category_7484996.html

paulwong 2021-11-23 13:51 发表评论

Java 9 Flow API 学习

paulwong — Thu, 02 Sep 2021 07:39:00 GMT

https://mrbird.cc/Java-9-Flow-API-Learn.html

paulwong 2021-09-02 15:39 发表评论