响应式编程

pom.xml引入

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

Mono

public class Test {

    public static void main(String[] args) {
        //只能有1个元素
        Mono<Integer> mono=Mono.just(18);
        //消费订阅
        mono.subscribe(x -> {
            //打印18
            System.out.println(x);
        });

    }
}

Flux

public class Test {

    public static void main(String[] args) {
        //可以有多个元素
        Flux<Integer>flux= Flux.just(1,2,3,4,5);
        //消费 订阅
        flux.subscribe(x->{
            //打印1 2 3 4 5
            System.out.println(x);
        });

    }
}

缓冲区

public class Test {

    public static void main(String[] args) {
        //生成1到10的数据
        Flux.range(1,10)
                //缓冲区最大放2个
                .buffer(2)
                //订阅消费
                .subscribe(x->{
                    //2个一组 打印
//                    [1, 2]
//                    [3, 4]
//                    [5, 6]
//                    [7, 8]
//                    [9, 10]
                    System.out.println(x);
                });
    }
}

generate

public class Test {

    public static void main(String[] args) {
       //创建 sink 接收端 通道
       Flux<Integer>flux=Flux.generate(()->0,(state,sink)->{
           if(state==10){
               //如果=10的时候  结束 退出
               sink.complete();
           }else {
               //否则 一直发送数据
               sink.next(state);
           }
           //生成数据自动+1
           return state+1;
       });

       flux.subscribe(x->{
           System.out.println(x);
       });
    }
}

asd

public class Test {

    public static void main(String[] args) {
        //多线程环境下用create 创建流
        Flux.create(x->{
            MyListener myListener=new MyListener(x);
            for (int i = 0; i <5 ; i++) {
                myListener.shangxian("用户:"+i);
            }
        }).subscribe(x->{
            //拿到每一个name
            System.out.println("=========="+x);
        });
    }
}

create

package com.dmg.authserver.controller;

import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;

//自定义监听器
public class MyListener {

    private FluxSink<Object> flux;
    public MyListener(FluxSink<Object>flux){
        this.flux=flux;
    }

    public void shangxian(String name){
        System.out.println(name+"上线了");
        //继续获取数据
        flux.next(name);
    }

}

handle

public class Test {

    public static void main(String[] args) {
        Flux.range(1,5)
                //自定义处理程序
                .handle((value,sink)->{
                    System.out.println("v:"+ value);
                    //修改数据 在发送出去
                    sink.next("李四:"+value);
                })
                .subscribe(x->{
                    System.out.println("=========="+x);
                });
    }
}

 

zipWith

public class Test {

    public static void main(String[] args) {
        Flux.range(1,5)
                //把数字和字母进行压缩成1对, 不匹配的不显示
                .zipWith(Flux.just("a","b","c"))
                .subscribe(x->{
//                    [1,a]
//                    [2,b]
//                    [3,c]
                    System.out.println(x);
                });
    }
}

sse

媒体类型要设置

@RestController
public class TestController {



    @GetMapping(value = "/aa",produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<Integer> aa(){
        //生成1到10的数据
        return Flux.range(1,10)
                //延迟1秒1次
                .delayElements(Duration.ofSeconds(1))
                ;
    }
}

浏览器访问 http://localhost:8084/aa

异步展示内容，不会一下子就返回

next

public class Test {

    public static void main(String[] args) {
        Integer block = Flux.range(1, 10)
                //只返回第一个数据 也就是1
                .next()
                //返回对应的结果类型
                . block()
                ;
        System.out.println(block);
    }
}

concatMap

public class Test {

    public static void main(String[] args) {

        Flux.just(1,2,3)
                //拼接多个内容
                .concatMap(x->Flux.just("a"+x,"b"+x))
                .subscribe(x->{
                    System.out.println(x);
                });
    }
}