小胖学编程
小胖学编程

响应式编程Reactor3

相关的maven依赖


    
        io.projectreactor
        reactor-core 
        
    
    
        io.projectreactor
        reactor-test 
        test

Reactor [riˈæktə(r)]有两种类型：

  1. Flux和Mono。Flux可以触发0到多个事件，并根据实际情况结束或触发错误。
  2. Mono最多触发一个事件，所以可以把Mono用于在异步任务完成时发出通知。

反应式编程来源于数据流和变化的传播，意味着由底层的执行模型负责通过数据流来自动传播变化。

在传统编程范式中，我们一般通过迭代器（Iterator）模式来遍历一个序列。这种遍历方式是由调用者来控制节奏的，采用的是拉的方式。每次调用者通过next()方法来获取序列的下一个值。反应试流采用的则是推的方式，即常见的发布者-订阅者模式。当发布者有新的数据产生时，这些数据会被推送到订阅者来进行处理。

在反应式流上可以添加各种不同的操作来对数据进行处理，形成数据处理链。这个以声明式的方式添加的处理链只在订阅者进行订阅操作时才会真正执行。

背压(backpressure)

在基本的消息推送模式中，当消息发布者产生的数据速度过快时，会使得消息订阅者的处理速度无法跟上产生的速度，从而给订阅者造成很大的压力。当压力过大时，有可能造成订阅者本身的崩溃，所产生的的级联效应甚至可能操作整个系统的崩溃。背压的作用在于提供一种从订阅者到生产者的反馈渠道。订阅者可以通过request()方法来声明其一次所能够处理的消息数量，而生产者就只会产生相应数量的消息，直到下一次request()方法的调用。这实际上变成了推拉结合的模式。

Flux和Mono

Flux和Mono是Reactor中两个基本概念。

Flux表示是包含0到N个元素的异步队列。在该序列中可以包含三种不同的类型消息通知：正常的包含元素的消息，序列结束的消息和序列出错的消息。当消息通知产生时，订阅者中对应的方法：onNext()，onComplete()，onError()会被调用。

Mono表示0或者1个元素的异步队列，该队列中同样包含于Flux相同的三种类型的消息通知。Flux和Mono之间可以进行转换。对一个Flux序列进行计数操作，得到的结果是一个Mono对象。把两个Mono序列合并在一起，得到的是一个Flux对象。

2. 创建Flux

2.1 Flux的静态方法

第一种方法是通过Flux类的静态方法

just() ： 指定序列中包含的所有元素。创建出来的Flux序列在发布这些元素之后会自动结束。

fromArray()，fromIterable()和 fromStream()：可以从一个数组、Iterable 对象或 Stream 对象中创建 Flux 对象。

empty()：创建一个不包含任何元素，只发布结束消息的序列。

error(Throwable error)：创建一个只包含错误消息的序列。

never()：创建一个不包含任何消息通知的序列。

range(int start, int count)：创建包含从 start 起始的 count 个数量的 Integer 对象的序列。

interval(Duration period)和 interval(Duration delay, Duration period)：创建一个包含了从 0 开始递增的 Long 对象的序列。其中包含的元素按照指定的间隔来发布。除了间隔时间之外，还可以指定起始元素发布之前的延迟时间。

清单1：

Flux.just("Hello", "World");
Flux.fromArray(new Integer[] {1, 2, 3});
Flux.empty();
Flux.range(1, 10);
Flux.interval(Duration.ofMillis(1000)).toStream().forEach(System.out::println);

上面这些静态方法适合简单的序列生成，当序列生成需要复杂逻辑时，则使用generate()或者create()方法。

注：清单1中5按照1000ms的间隔生成序列，toStream()方法将Flux序列转换成jdk8中的Stream对象，在通过forEach方法进行输出。这是因为序列是异步生成的，而转换成Stream对象可以保证主线程在序列生成完成之前不会退出，从而可以正确的输出所有的元素。

2.2 generate()方法

generate()方法通过同步和逐一的方式来产生Flux序列，序列的产生时通过调用所提供的SynchronousSink对象的next()、complete()和error(Throwable)方法来完成的。逐一生成的含义是在具体的生成逻辑中，next()方法只能最多被调用一次。

在有些情况下，序列的生成可能是有状态的，需要用到某些状态对象。此时可以使用 generate()方法的另外一种形式 generate(Callable stateSupplier, BiFunction,S> generator)其中 stateSupplier 用来提供初始的状态对象。在进行序列生成时，状态对象会作为 generator 使用的第一个参数传入，可以在对应的逻辑中对该状态对象进行修改以供下一次生成时使用。

    public Flux getFlux(){
        //请求参数，泛型便是返回值或者操作的某个值
       return Flux.generate(synchronousSink -> {
            synchronousSink.next("hello");
            synchronousSink.complete();
        });

//        Flux.generate(new Consumer>() {
//            @Override
//            public void accept(SynchronousSink synchronousSink) {
//                synchronousSink.next("hello");
//                synchronousSink.complete();
//            }
//        });
    }

2.3 create()方法

create()方法和generate()方法的不同之处在于使用的是FluxSink对象。FluxSink支持同步和异步的消息产生，并且在一次调用中产生多个元素。

    public Flux getFluxSink() {
        return Flux.create(fluxSink -> {
            for (int i = 0; i < 10; i++)
                fluxSink.next(i + " ");
            fluxSink.complete();
        });
    }

3. 创建Mono

Mono创建方式与之前介绍的Flux类似，Mono类中也包含了与Flux类中相同的静态方法。这些方法包括just()、never()、empty()。还有一些独有的方法。

分别从 Callable、CompletionStage、CompletableFuture、Runnable 和 Supplier 中创建 Mono。
fromCallable()、fromCompletionStage()、fromFuture()、fromRunnable()和 fromSupplier()

创建一个 Mono 序列，在指定的延迟时间之后，产生数字 0 作为唯一值。
delay(Duration duration)和 delayMillis(long duration)

创建一个 Mono 序列，忽略作为源的 Publisher 中的所有元素，只产生结束消息。
ignoreElements(Publisher source)

从一个 Optional 对象或可能为 null 的对象中创建 Mono。只有 Optional 对象中包含值或对象不为 null 时，Mono 序列才产生对应的元素。
justOrEmpty(Optional data)和 justOrEmpty(T data)

举例：

Mono.fromSupplier(() -> "Hello").subscribe(System.out::println);
Mono.justOrEmpty(Optional.of("Hello")).subscribe(System.out::println);
Mono.create(sink -> sink.success("Hello")).subscribe(System.out::println);

4. 操作符

Reactor强大之处在于可以在反应式流上通过声明式的方式添加多种不同的操作符。

4.1 buffer和bufferTimeout

把当前流中的元素收集到集合（List）中，并把集合对象作为流中新的元素。在进行收集的同时可以指定不同的条件：所包含的元素最大数量或收集的时间间隔。

方法 buffer()仅使用一个条件（集合包含对象的最大数量），而 bufferTimeout()可以同时指定两个条件。指定时间间隔时可以使用 Duration 对象或毫秒数。（集合包含对象的最大数量或者是最大的时间间隔）

除了元素数量和时间间隔之外，还可以通过 bufferUntil 和 bufferWhile 操作符来进行收集。这两个操作符的参数是表示每个集合中的元素所要满足的条件的 Predicate 对象。bufferUntil 会一直收集直到 Predicate 返回为 true。使得 Predicate 返回 true 的那个元素可以选择添加到当前集合或下一个集合中；bufferWhile 则只有当 Predicate 返回 true 时才会收集。一旦值为 false，会立即开始下一次收集。

buffer定义元素的最大数量

    @Test
    public void testBuffer(){
        Flux.range(1,100).buffer(20).subscribe(System.out::println);
    }
输出结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
[41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]
[61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80]
[81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

bufferUntil

每当遇到一个偶数就会结束当前的收集。

    @Test
    public void testBufferUntil() {
        Flux.range(0, 10).bufferUntil(integer -> integer % 2 == 0).subscribe(System.out::println);
    }

输出结果：
[0]
[1, 2]
[3, 4]
[5, 6]
[7, 8]
[9]

bufferWhile

数组里面包含的只有偶数

    @Test
    public void testBufferWhile() {
        Flux.range(0, 10).bufferWhile(integer -> integer % 2 == 0).subscribe(System.out::println);
    }

输出结果：
[0]
[2]
[4]
[6]
[8]

bufferTimeout(int maxSize, Duration maxTime)

 Flux.interval(Duration.ofMillis(100))
.bufferTimeout(20,Duration.ofMillis(1000)).take(2)
.toStream().forEach(System.out::println);

每间隔100ms生成一个序列号（1,2,3...n）。集合最大长度为20，或者集合收集时间1000ms（此处是到达maxTime后便终止收集）。take(2)是获取的集合数量。

输出结果：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

4.2 filter

对流中包含的元素进行过滤，只留下满足Predicate指定条件的元素。

代码中语句输出1到10中的所有偶数。

    @Test
    public void testFilter() {
        Flux.range(1, 10).filter(integer -> integer % 2 == 0).subscribe(System.out::println);
    }

4.3 window

window操作符的作用类似于buffer，所不同的就是window操作符是把当前流中的元素收集到另外的Flux序列中，因此返回值类型是Flux。

    @Test
    public void testWindow(){
        Flux.range(1,100).window(20).subscribe(System.out::println);
        Flux.interval(Duration.ofMillis(100)).window(Duration.ofMillis(1001)).take(2).toStream().forEach(System.out::println);
    }

两行语句的输出结果分别是 5 个和 2 个 UnicastProcessor 字符。这是因为 window 操作符所产生的流中包含的是 UnicastProcessor 类的对象，而 UnicastProcessor 类的 toString 方法输出的就是 UnicastProcessor 字符。

4.4 zipWith

zipWith操作符把当前流中的元素与另外一个流中的元素按照1对1的方式进行合并。在合并时可以不做任何处理，由此得到的是一个元素类型为Tuple2的流。

  1. BiFunction函数对合并的元素进行处理，所得到的流的元素类型为该函数的返回值。
    @Test
    public void testZipWith() {
        Flux.just("a", "b").zipWith(Flux.just("c", "d")).subscribe(System.out::println);
        System.out.println();
        Flux.just("a", "b").zipWith(Flux.just("c", "d"), (s1, s2) ->
                String.format("%s-%s", s1, s2)
        ).subscribe(System.out::println);
    }

输出结果
[a,c]
[b,d]

a-c
b-d

4.5 take

take系统操作符用来从当前流中提取元素，提取的方式可以有很多种。

按照指定的数量或时间间隔来提取。
take(long n)，take(Duration timespan)

提取流中的最后 N 个元素
takeLast(long n)

提取元素直到 Predicate 返回 true
takeUntil(Predicate predicate)

当 Predicate 返回 true 时才进行提取
takeWhile(Predicate continuePredicate)

提取元素直到另外一个流开始产生元素
takeUntilOther(Publisher other)

takeWhile返回true时才会进行提取

    @Test
    public void testTake(){
       Flux.range(0,100).takeWhile(integer -> integer<10).subscribe(System.out::println);
    }

提取元素直到返回true

    @Test
    public void testTaskUntil(){
        Flux.range(0,100).takeUntil(integer -> integer==10).subscribe(System.out::println);
    }

4.6 reduce和reduceWith

reduce和reduceWith操作符对流中包含的所有元素进行累积操作，得到一个包含计算结果的Mono序列。累积操作是通过一个BiFunction来表示。在操作时可以指定一个初始值。如果没有初始值，则序列的第一个元素作为初始值。

对流中的元素进行相加操作，结果为5050；

    @Test
    public void testReduce() {
        //第一个参数类型，第二个参数类型，返回结果类型
        Flux.range(1, 100).reduce(new BiFunction() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        }).subscribe(System.out::println);
        //lambda表达式
        Flux.range(1,100).reduce(((integer, integer2) -> {
            return integer+integer2;
        })).subscribe(System.out::println);
    }

同样也是进行相加操作，不过通过一个Supplier给出初始值为100，所以结果为5150。

    @Test
    public void testReduceWith(){
        Flux.range(1,100).reduceWith(new Supplier(){
            @Override
            public Integer get() {
                return 100;
            }
        },(x,y)->x+y).subscribe(System.out::println);
        //lambda
        Flux.range(1,100).reduceWith(()->"100",(x,y)->x+y).subscribe(System.out::println);
    }

4.7 merge和mergeSequential

merge和mergeSequential操作符用来把多个流合并成一个Flux序列。不同的是merge 按照所有流中元素的实际产生顺序来合并，而 mergeSequential 则按照所有流被订阅的顺序，以流为单位进行合并。

进行合并的流都是每隔100ms产生一个元素，不过第二个流每个元素的产生都第一个流要延迟50ms。

在使用 merge 的结果流中，来自两个流的元素是按照时间顺序交织在一起；

    @Test
    public void testMerge() {
        Flux.merge(Flux.interval(Duration.ofMillis(100)).take(5), Flux.interval(Duration.ofMillis(50),Duration.ofMillis(100)).take(5))
                .toStream().forEach(System.out::println);
    }

使用 mergeSequential 的结果流则是首先产生第一个流中的全部元素，再产生第二个流中的全部元素。

    @Test
    public void testMergeSequential(){
        Flux.mergeSequential(Flux.interval(Duration.ofMillis(100)).take(5), Flux.interval(Duration.ofMillis(50),Duration.ofMillis(100)).take(5))
                .toStream().forEach(System.out::println);
    }

4.8 flatMap和flatMapSequential

flatMap 和 flatMapSequential 操作符把流中的每个元素转换成一个流，再把所有流中的元素进行合并。

流中的元素被转换成每隔 100 毫秒产生的数量不同的流，再进行合并。由于第一个流中包含的元素数量较少，所以在结果流中一开始是两个流的元素交织在一起，然后就只有第二个流中的元素。

    @Test
    public void testFlat() {
        //第一个流输出5个元素，第二个流输出10个元素。
        Flux.just(5, 10).flatMap(x -> Flux.interval(Duration.ofMillis(x * 10), Duration.ofMillis(100)).take(x))
                .toStream().forEach(System.out::println);
    }

4.9 concatMap(concatenate)

concatMap操作符的作用也是把流中的每个元素转换成一个流，再把所有流进行合并。与flatMap不同的是，concatMap会根据原始流中的元素按顺序依次把转换之后的流进行合并；与 flatMapSequential 不同的是，concatMap 对转换之后的流的订阅是动态进行的，而 flatMapSequential 在合并之前就已经订阅了所有的流。

流中依次包含了第一个流和第二个流中的全部元素。

    @Test
    public void testConcatMap() {
        //第一个流输出5个元素，第二个流输出10个元素。
        Flux.just(5, 10).concatMap(x -> Flux.interval(Duration.ofMillis(x * 10), Duration.ofMillis(100)).take(x))
                .toStream().forEach(System.out::println);
    }

4.10 combineLatest

combineLatest操作符把所有流中最新产生的元素合并为一个元素，作为返回结果流中的元素。只要其中任何一个流产生了元素，合并操作都会被执行一次。（若是一个流未产生元素，另一个流产生元素，不会进行合并操作）。

流最新产生的元素会被收集到一个数组中，通过Array.toString方法来把数组转换为String类型。

    @Test
    public void testCombineLatest() {
        Flux.combineLatest(
                Arrays::toString,
                Flux.interval(Duration.ofMillis(100)).take(5),
                Flux.interval(Duration.ofMillis(1000)).take(5)
        ).toStream().forEach(System.out::println);
    }
输出结果
[4, 0]
[4, 1]
[4, 2]
[4, 3]
[4, 4]

5. 消息处理

当需要处理Flux和Mono消息时，如之前的代码逻辑，可以通过subscribe方法来添加相应的订阅逻辑。在调用subscribe方法时可以指定需要处理的消息类型。可以只处理其中包含的正常消息，也可以同时处理错误消息和完成消息。

通过subscribe()方法处理正常和错误消息：

    @Test
    public void testMonoError(){
        Flux.just(1,2).concatWith(Mono.error(new IllegalAccessError())).subscribe(System.out::println,System.out::println);
    }

5.1 错误的不同处理策略

1. 使用onErrorReture()方法返回默认值。

出现错误时，会返回默认值0；

    @Test
    public void testOnErrorReturn(){
        Flux.just(1,2).concatWith(Mono.error(new NullPointerException())).onErrorReturn(0).subscribe(System.out::println);
    }

2. 使用onErrorResume根据不同的异常类型来产生不同的流

    @Test
    public void testOnErrorResume() {
        Flux.just(1, 2)
                .concatWith(Mono.error(new NullPointerException()))
                .onErrorResume(e->{
                    if(e instanceof IllegalStateException){
                        return Mono.justOrEmpty(0);
                    }else if(e instanceof  NullPointerException){
                        return Mono.just(1);
                    }
                    return Mono.empty();
                }).subscribe(System.out::println);
    }

5.2 重试机制

当出现错误时，还可以通过 retry 操作符来进行重试。重试的动作是通过重新订阅序列来实现的。

在使用 retry 操作符时可以指定重试的次数。代码中指定了重试次数为 1，所输出的结果是 1，2，1，2 和错误信息。

    @Test
    public void testRetry(){
        Flux.just(1,2).concatWith(Mono.error(new NullPointerException()))
                      .retry(1).subscribe(System.out::println);
    }

6. 调度器

通过调度器（Scheduler）可以指定这些操作的方式和所在的线程，有下列几种不同的调度器实现：

方法 描述
Schedulers.immediate() 当前线程
Schedulers.single() 单一可复用线程
Schedulers.elastic() 适用于IO操作，弹性线程池，线程是可以复用的，线程闲置太久，则被销毁
Schedulers.parallel() 并行操作优化的线程池，线程此行数量取决于CPU数量，适合计算密集型任务
Schedulers.timer() 支持任务调度
Schedulers.fromExecutorService() 从已有的ExecutorService对象创建调度器

注：某些操作符默认就已经使用了特定类型的调度器，比如interval()方法的创建的流使用了Schedulers.timer()创建的调度器。

使用create()方法创建了一个新的Flux对象，其中包含的唯一元素就是当前线程的名字。借助是publishOn方法——切换执行时的调度器，map方法——把当前线程名称作为前缀添加，subscribeOn方法——改变Flux流订阅时的执行方式。

    @Test
    public void testScheduler(){
        Flux.create(fluxSink -> {
           fluxSink.next("Flux:"+Thread.currentThread().getName());
           fluxSink.complete();
           //x应该就是Flux中的元素
        }).publishOn(Schedulers.single()).map(x->String.format("[%s]-%s",Thread.currentThread().getName(),x))
                .publishOn(Schedulers.elastic()).map(x->String.format("[%s]-%s",Thread.currentThread().getName(),x))
                .subscribeOn(Schedulers.parallel())
                .toStream().forEach(System.out::println);
    }
结果：
[elastic-2]-[single-1]-Flux:parallel-1

需要注意的是：

    @Test
    public void testScheduler(){

        Flux.create(fluxSink -> {
           fluxSink.next("Flux:"+Thread.currentThread().getName());
           fluxSink.complete();
           //x应该就是Flux中的元素
        }).publishOn(Schedulers.single()).map(x->String.format("[%s]-%s",Thread.currentThread().getName(),x))
                .publishOn(Schedulers.elastic()).map(x->String.format("[%s]-%s",Thread.currentThread().getName(),x))
//                .subscribeOn(Schedulers.parallel())
                .toStream().forEach(System.out::println);
    }
输出结果：
[elastic-2]-[single-1]-Flux:main

测试

对Rector的代码进行测试时，需要加入下面依赖。

        
            io.projectreactor
            reactor-test
            test

1. 使用 StepVerifier

1.1 验证序列

验证异步序列Flux中锁包含的元素是否符合预期，StepVerifier的作用可以对序列中包含的元素进行逐一验证。

  1. StepVerifier.create()方法：对一个流进行包装之后再进行验证。
  2. expectNext()方法：用来声明测试时所期待的流中的下一个元素的值。
  3. verifyComplete()方法：则验证流是否正常结束。
  4. verifyError()方法：来验证流由于错误而终止。
    @Test
    public void testStepVerifier(){
        StepVerifier.create(Flux.just("a","b")).expectNext("a").expectNext("b").verifyComplete();
    }

1.1 虚拟时间

有些序列的生成是有时间要求的，比如1分钟才产生一个新的元素。在进行测试中，不可能花费实际的时间来等待每一个元素的生成。此时需要用到StepVerifier提供的虚拟时间功能。

需要验证的流中包含两个产生间隔为一天的元素，并且第一个元素产生的延迟时间为4个小时。在通过 StepVerifier.withVirtualTime()方法包装流之后，expectNoEvent()方法用来验证4个小时之内没有任何消息产生，然后验证第一个元素0的产生；thenAwait()方法来让虚拟时钟前进一天，然后验证第二个元素1的产生；最后验证流正常结束。

    @Test
    public void testVirtualTime(){
        StepVerifier.withVirtualTime(()->Flux.interval(Duration.ofHours(4),Duration.ofDays(1)).take(2))
                .expectSubscription().expectNoEvent(Duration.ofHours(4))
                .expectNext(0L)
                .thenAwait(Duration.ofDays(1))
                .expectNext(1L)
                .verifyComplete();
    }

2. 使用TestPublisher

TestPublisher的作用在于可以控制流中元素的产生，甚至违反反应流规范的情况下。

通过 create()方法创建一个新的 TestPublisher 对象，然后使用 next()方法来产生元素，使用 complete()方法来结束流。TestPublisher 主要用来测试开发人员自己创建的操作符。

    @Test
    public void testTestPublisher(){
        TestPublisher publisher = TestPublisher.create();
        publisher.next("a");
        publisher.next("b");
        publisher.complete();
        StepVerifier.create(publisher).expectNext("a").expectNext("b").expectComplete();
    }

使用检测点

通过checkpoint操作符来对特定的流处理链启用调试模式。

例：在 map 操作符之后添加了一个名为 test 的检查点。当出现错误时，检查点名称会出现在异常堆栈信息中。对于程序中复杂或重要的流处理链，可以在关键的位置上启用检测点来帮助定位问题。

    @Test
    public void testCheckPoint() {
        Flux.just(1, 0).map(x -> 1 / x).checkpoint("test").subscribe(System.out::println);
    }

日志记录

在开发和调试中的另外一项实用功能是把流相关的事件记录在日志中。这可以通过添加 log 操作符来实现。

添加了 log 操作符并指定了日志分类的名称。

    @Test
    public void testLog(){
        Flux.just(1,0).log("Range").subscribe(System.out::println);
    }

对应输出：

09:46:31.864 [main] DEBUG reactor.util.Loggers$LoggerFactory - Using Slf4j logging framework
09:46:31.893 [main] INFO Range - | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)
09:46:31.898 [main] INFO Range - | request(unbounded)
09:46:31.899 [main] INFO Range - | onNext(1)
1
09:46:31.899 [main] INFO Range - | onNext(0)
0
09:46:31.900 [main] INFO Range - | onComplete()

"冷" 与 "热" 序列

之前代码中所创建的均是冷序列：即不论订阅者在何时订阅该序列，总能收到序列中产生的全部消息。
而对应的热序列：则是持续不断的产生消息，订阅者只能获取到在其订阅之后产生的消息。

原始序列是中包含了10个间隔为1s的元素。

  1. publish()方法：把一个Flux对象转化为ConnectableFlux对象。
  2. autoConnect()方法：当ConnectionFlux对象有一个订阅者时就开始产生消息。
  3. source.subscribe()：订阅该ConnectionFlux对象，让产生消息。
    然后是当前线程睡眠5s。
    第二个订阅者此时只能获取到该序列中的后5个元素。
    @Test
    public void testAutoConnect() throws InterruptedException {
        Flux source = Flux.interval(Duration.ofMillis(1000)).take(10).publish().autoConnect();
        source.subscribe();
        Thread.sleep(5000);
        source.toStream().forEach(System.out::println);
    }
输出结果：
5
6
7
8
9

你可能感兴趣的:(响应式编程Reactor3)

  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • ref 和 reactive 区别 有一个好名字 Vuevue.jsjavascript前端
    前言ref和reactive是Vue3中响应式编程的核心。在Vue中，响应式编程是一种使数据与UI保持同步的方式。当数据变化时，UI会自动更新，反之亦然。这种机制大大简化了前端开发，使我们能够专注于数据和用户界面的交互，而不必手动处理DOM更新。refref是Vue3中的一个简单响应式API，用于创建一个包装基本数据类型的响应式引用(也可以包装复杂类型，只不过底层还是由reactive的方式实现的
  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码 快乐非自愿 javaspring
    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
  • java reactor框架_关于java:Java反应式框架Reactor中的Mono和Flux 中一贝爷 javareactor框架
    1.前言最近写对于响应式编程的货色有点多，很多同学反映对Flux和Mono这两个Reactor中的概念有点懵逼。然而目前Java响应式编程中咱们对这两个对象的接触又最多，诸如SpringWebFlux、RSocket、R2DBC。我开始也对这两个对象头疼，所以明天咱们就简略来探讨一下它们。2.响应流的特点要搞清楚这两个概念，必须说一下响应流标准。它是响应式编程的基石。他具备以下特点：响应流必须是无
  • 2024最新最全的React面试题 二丫骑士qq react.js前端前端框架
    1.react和vue的区别？(1)设计理念:React:更倾向于函数式编程思想，推崇组件的不可变性和单向数据流。Vue:结合了响应式编程和模板系统，致力于简化开发过程。(2)核心库与生态系统:React:React本身只关注UI层，但它有一个庞大的生态系统，例如Redux、MobX等用于状态管理，以及ReactRouter用于路由处理。Vue:Vue是一个更完整的解决方案，它的核心库除了视图层，
  • ①flutter简介和环境构建① paiidds flutter
    一、flutter简介1.flutter是什么？  flutter是一款接近原生安卓的移动应用程序开发框架,采用dart语言(强类型)开发，提高了丰富的UI和组件库,支持响应式编程、热加载程序(无需重启就能加载)。底层dart语言和java语言类似，具备面向对象编程开发的特性。flutter可以包含不同平台之间的差异，共同复用同一套代码，交付出具有原生体验的高性能不同平台应用。2.为什么要学习fl
  • 拥抱单向数据流：Android 开发中的 MVI 架构详解 yan_chenglong android架构
    MVI构建响应式应用在现代Android开发中，架构模式对于构建可维护、可测试和可扩展的应用至关重要。MVI（Model-View-Intent）是一种架构模式，它在前端开发中逐渐流行起来，特别是被广泛应用于响应式编程中。本文将深入探讨MVI架构，包括其核心概念、优缺点、使用场景，以及一个简单的代码示例。MVI架构概念MVI架构由三个主要部分组成：Model、View和Intent。它建立在单一的
  • 响应式编程要点 (Java) 与遨游于天地 java开发语言
    整体学习概览前置知识函数式编程+Lambda表达式实践、Java8StreamApi的使用响应式编程的原理和思想ReactiveStream的思想和Api实践Reactor思想和Api实践WebFlux的使用SpringDataR2DBC前置知识：函数式编程函数式编程要点-CSDN博客响应式编程原理和思想全链路无阻塞负压模式消息驱动事件驱动观察者模式函数式+声明式编程+链式调用可编排装配流水线Re
  • 包教包会的Kotlin Flow教程
    原文链接包教包会的KotlinFlow教程公众号「稀有猿诉」Kotlin中的Flow是专门用于处理异步数据流的API，是函数响应式编程范式(FunctionalReactiveProgrammingFRP)在Kotlin上的一个实现，并且深度融合了Kotlin的协程。是Kotlin中处理异步数据流问题的首先方案。今天就来认识一下Flow并学会如何使用它。Hello,Flow!老规矩，新学习一个新东
  • Gateway服务网关 钢铁小宝宝 gatewayjavaspringcloud后端spring
    SpringCloudGateway是SpringCloud的一个全新项目，该项目是基于Spring5.0，SpringBoot2.0和ProjectReactor等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的API路由管理方式。3.1.为什么需要网关Gateway网关是我们服务的守门神，所有微服务的统一入口。网关的核心功能特性：将用户请求路由到微服务、并实现负载均
  • 【Spring学习】Spring Data Redis：RedisTemplate、Repository、Cache注解 兔兔西 springredis
    1，spring-data-redis官网1）特点提供了对不同Redis客户端的整合（Lettuce和Jedis）提供了RedisTemplate统一API来操作Redis支持Redis的发布订阅模型支持Redis哨兵和Redis集群支持基于Lettuce的响应式编程支持基于JDK、JSON、字符串、Spring独享的数据序列化及反序列化支持基于Redis的JDKCollection实现2，Red
  • 扬帆起航：从命令式编程到函数响应式编程 编码的哲哲
    前言：在大学时期，我用Ionic写过一个查看校园信息的app，利用投放广告盈利的方式，我赚到了一台MacBookPro。在之后的日子里，无论是工作，学习还是生活，它都给我带来极大的便捷。我至今仍心存感激。所以我对Ionic的核心框架Angular充满好感。即使现在的工作中用react居多，但是闲暇时还是会追一追Angular的文档，写一写笔记。随着工作经验愈发丰富，Angular越来越演变成一种信
  • 2021-01-29 同分异构脑
    Combine之Subjects在响应式编程的世界中，Subject不太好翻译。在Combine中，存在两个Subjects，本质上，他们就是一种特殊的publisher。之所以称他们是特殊的，是因为他们不仅包含publisher通用的一些特性，还具有独特的地方，接下来，我们逐个解释。先看看Subject的定义：///Apublisherthatexposesamethodforoutsideca
  • 得物自研API网关实践之路 架构
    一、业务背景老网关使用SpringCloudGateway（下称SCG）技术框架搭建，SCG基于webflux编程范式，webflux是一种响应式编程理念，响应式编程对于提升系统吞吐率和性能有很大帮助;webflux的底层构建在netty之上性能表现优秀；SCG属于spring生态的产物，具备开箱即用的特点，以较低的使用成本助力得物早期的业务快速发展；但是随着公司业务的快速发展，流量越来越大，网关
  • 响应式编程和RxJS介绍 oWSQo
    响应式编程是一种面向数据流和变化传播的编程范式。面向变化传播的编程就是看最初的数据是否会随着后续对应变量的变化而变化。比如当变量B的数值改变后，变量C的数值也随之变动。面向数据流的编程是当监听一系列事件流并对这一系列事件流进行映射、过滤和合并等处理后，再响应整个事件流的回调的过程。例如在ReactiveX编程范式中，数据流被封装在一个叫Observable的对象实例中，通过观察者模式，对数据流进行
  • RxJava-使用详解与背压原理2 Laughing_G
    一、RxJava1与RxJava2的区别前提：RxJava是响应式编程，基于事件流开发。区别：1.RxJava2不再支持null值，如果传入一个null会抛出NullPointerException；2.Observable.just(null)不支持；3.RxJava2所有的函数接口（Function、Action、Consumer）均设计为可抛出Exception，同时支持自己去解决编译异常需
  • 响应式编程详解(持续更新) GNG JAVA提高javarxjava
    响应式编程1.多维度看全景1.1响应式编程(ReactiveProgramming)1.2函数式编程（FunctionalProgramming,简称FP）1.3技术演进1.4Rx是什么1.5[响应式宣言](https://www.reactivemanifesto.org/zh-CN)2.钻进去看本质2.1名称解释(rajava)2.2观察者模式2.3HelloWorld2.4Observabl
  • 手把手带你入门神秘的RxJava 可以写但没有必要
    近两年来国内的技术圈子中越来越多的开始提及RxJava，越来越多的应用和面试中都会有RxJava，而就目前的情况，Android的网络库基本被Retrofit+OkHttp一统天下了，而配合上响应式编程RxJava可谓如鱼得水。什么是RxJava•Rx是ReactiveExtensions的简写，翻译为响应的扩展。也就是通过由一方发出信息，另一方响应信息并作出处理的核心框架代码。•该框架由微软的架
  • Spring赌上未来：响应式 WebFlux 框架更优雅，性能更强！ ღ᭄陽先生꧔ꦿ᭄ spring数据库java
    目录Spring-webflux简介什么是“响应式”Spring-webflux的响应式API选择Spring-webmvc还是Spring-webflux呢并发模型webflux代码示例Spring-webflux简介spring-webflux是spring在5.0版本后提供的一套响应式编程风格的web开发框架。这个框架包含了spring-framework和springmvc，它可以运行在N
  • Swift Combine 管道 从入门到精通三 AI架构师易筋 iOSswift开发语言ioscombinechannel
    Combine系列SwiftCombine从入门到精通一SwiftCombine发布者订阅者操作者从入门到精通二1.用弹珠图描述管道函数响应式编程的管道可能难以理解。发布者生成和发送数据，操作符对该数据做出响应并有可能更改它，订阅者请求并接收这些数据。这本身就很复杂，但Combine的一些操作符还可能改变事件发生的时序——引入延迟、将多个值合并成一个值等等。由于这些比较复杂可能难以理解，因此函数响
  • Swift Combine 从入门到精通一 AI架构师易筋 iOSswift开发语言combineswiftUI
    1.Combine简介用Apple官方的话来说，Combine是:adeclarativeSwiftAPIforprocessingvaluesovertime.Combine是Apple用来实现函数响应式编程的库，类似于RxSwift。RxSwift是ReactiveX对Swift语言的实现。Combine使用了许多可以在其他语言和库中找到的相同的函数响应式概念，并将Swift的静态类型特性应用
  • RxSwift的使用详解 adaodao3056
    RxSwift的使用详解一.RxSwift简介推荐:RxSwift官方文档中文:RxSwift官方文档的中文翻译RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#,Java和JS也有，Rx.Net、RxJava、rxjsRxSwift的目的是让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程1.RxSw
  • 通过 Vue 类比理解 Mobx VioletJack
    因为之前一直用的Vue全家桶，所以转React的时候我就采用类比的方式来理解Mobx了。建议熟悉Vue全家桶并且简单看了Mobx文档的同学入手，便于快速理解。Mobx是什么？一个函数响应式编程的React库。作用呢？使用函数响应式编程的方式来进行状态管理。划重点：React使用虚拟DOM提供了优化UI的渲染机制。Mobx提供了优化应用状态与React组件同步机制。所以作用是：存储和更新状态。根据状
  • （七）springboot实战——springboot3集成R2DBC实现webflux响应式编程服务案例 厉害哥哥吖 #springbootATP应用测试平台springboot
    前言本节主要内容是关于使用新版springboot3集成响应式数据库R2DBC,完成响应式web服务案例。需要注意的是，此次项目使用的JDK版本是JDK17，springboot版本使用3.2.2版本，数据库使用关系型数据库mysql。WebFlux是一个基于响应式编程模型的框架，适用于构建异步、非阻塞的高性能Web应用程序。它具有高并发能力、函数式编程风格、与其他Spring框架的集成能力等优势
  • iOS -RAC使用 搬砖的crystal
    一、简介ReactiveCocoa可以说是结合了函数式编程和响应式编程的框架，也可称其为函数响应式编程（FRP）框架，强调一点，RAC最大的优点是提供了一个单一的、统一的方法去处理异步的行为，包括delegate方法，blocks回调，target-action机制，notifications和KVO。导入在项目的podfile文件中添加#RACpod'ReactiveObjC'在使用时导入#im
  • Vue3实现响应式编程 &ACE& vue.jsjavascript前端
    Vue3中实现响应式编程的方式有以下几种：使用ref函数：Vue3中引入了一个新的ref函数，用于创建一个响应式的数据对象。通过ref函数创建的变量是一个引用，可以通过.value访问和修改它的值。当变量的值发生变化时，依赖于该变量的组件会自动重新渲染。import{ref}from'vue'//创建一个响应式变量constcount=ref(0)//访问和修改变量的值console.log(co
  • Unity3D UniRx ReactiveX响应式编程初探1 双击的检测 暗光之痕 UniRxunity3dRxUniRx响应式编程双击
    版本：unity5.6语言：C#UniRx版本：5.5总起：ReactiveX并不是个新技术，百度上一搜就有很多中文的资料，但唯独没有针对Unity的UniRx资料，我这边就开个坑进行介绍。UniRx的GitHub地址如下：https://github.com/neuecc/UniRx。我这边在csdn上传一份Unity商店中的包：http://download.csdn.net/detail/u
  • FluxMQ：新一代的高性能MQTT代理服务器 程序媛之Lemon 网关物联网Mqtt网络MQTT物联网
    FluxMQ：新一代的高性能MQTT代理服务器前言FLuxMQ是一款基于java开发，支持无限设备连接的云原生分布式物联网接入平台。FluxMQ基于Netty开发，底层采用Reactor3反应堆模型，具备低延迟，高吞吐量，千万、亿级别设备连接；方便企业快速构建其物联网平台与应用。FluxMQ官网：https://www.fluxmq.comFluxMQ演示系统：http://demo.fluxmq
  • 响应式编程之手写Reactor pq217
    前言前文提到了响应式编程，响应式规范Reactivestreams，以及响应式扩展Reactor的简单使用在使用Reactor时我一直很好奇，它是怎么做到的？好奇心驱使我想要自己去写一个Reactivestreams的实现，并参照Reactor源码来看看大神是如何实现的话不多说，开始写代码(本文比较啰嗦，因为掺杂了自己的实现思路)简单序列的发布者看一下Reactor的一个简单例子Flux.just
  • 【Kotlin学习】协程的基本概念(3)——Flow Panic Lin Kotlin学习android学习kotlin
    kotlinflow介绍它是kotlin协程与响应式编程模型结合的产物flow的使用flow的基本使用方式flow能够返回多个异步计算的值如果熟悉RxJava，可以吧collect()对应subscribe()，而emit()对应onNext()另外的创建flow方式1.flowOf()2.asFlow()3.channelFlow()channelFlowbuilder跟flowbuilder是
  • 强大的销售团队背后 竟然是大数据分析的身影 蓝儿唯美 数据分析
    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。 大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
  • Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡keepalivedhaproxy高可用
    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过 服务器资源 10.7
  • eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
  • 基础篇--resources资源 不懂事的小屁孩 android
    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml    字符串资源   涉及国际化问题  http://www.2cto.com/kf/201302/190394.html   string-array
  • 接上篇补上window平台自动上传证书文件的批处理问卷 酷的飞上天空 window
    @echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
  • 企业物联网大潮涌动：如何做好准备？ 蓝儿唯美 企业
    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。 尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
  • spring学习——数据库（mybatis持久化框架配置） a-john mybatis
    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
  • Java静态代理、动态代理实例 aijuans Java静态代理
    采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。 按照代理类的创建时期，可以分为：静态代理和动态代理。 所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。 所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。   一、静态代理类实例： 1、Serivce.ja
  • Struts1与Struts2的12点区别 asia007 Struts1与Struts2
    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
  • 初学者要多看看帮助文档 不要用js来写Jquery的代码 百合不是茶 jqueryjs
    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;   1, JQuery的赋值  有问题    代码如下: data.username 表示的是:  网易            $("#use
  • 经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
  • 如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenutreeRichfaces
    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
  • 【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
    开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
  • JSONObject转换JSON--将Date转换为指定格式 白糖_ JSONObject
    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：   {"nanos":0,"time":-27076233600000,
  • JavaScript语言精粹读书笔记 braveCS JavaScript
    【经典用法】：   //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出 bylijinnan 编程之美
    import java.util.LinkedList; public class FindInteger { /** * 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
  • 读书笔记 chengxuyuancsdn 读书笔记
    1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
  • [通讯与电力]光网城市建设的一些问题 comsci 问题
          信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系       我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........     
  • oracle 空间RESUMABLE daizj oracle空间不足RESUMABLE错误挂起
    空间RESUMABLE操作  转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。 这一篇简单介绍空间RESUMABLE的例子。 第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
  • 重构第一次写的线程池 dieslrae 线程池 python
    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
  • C语言学习六指针 dcj3sjt126com c
    初识指针，简单示例程序： /* 指针就是地址，地址就是指针 地址就是内存单元的编号 指针变量是存放地址的变量 指针和指针变量是两个不同的概念 但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
  • yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
    public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }  
  • timertask shuizhaosi888 timertask
    java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
  • Spring Security（13）——session管理 234390216 sessionSpring Security攻击保护超时
    session管理 目录   1.1     检测session超时 1.2     concurrency-control 1.3     session 固定攻击保护         
  • 公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodbsessionnodejs
        http://www.upopen.cn   一、前言         书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
  • pojo.vo.po.domain区别 LiaoJuncai javaVOPOJOjavabeandomain
    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。 　　 　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
  • Windows Error Code OhMyCC windows
    0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
  • 在storm集群环境下发布Topology roadrunners 集群stormtopologyspoutbolt
    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。   1、打包 打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
  • 为什么不允许代码里出现“魔数” tomcat_oracle java
    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
  • zoj 3511 Cake Robbery(线段树) 阿尔萨斯 线段树
    题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。 解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他