【深入解析spring cloud gateway】08 Reactor 知识扫盲

一、响应式编程概述

1.1 背景知识

为了应对高并发服务器端开发场景，在2009 年，微软提出了一个更优雅地实现异步编程的方式——Reactive Programming，我们称之为响应式编程。随后，Netflix 和LightBend 公司提供了RxJava 和Akka Stream 等技术，使得Java 平台也有了能够实现响应式编程的框架。
在2017 年9 月28 日，Spring 5 正式发布。Spring 5 发布最大的意义在于，它将响应式编程技术的普及向前推进了一大步。而同时，作为在背后支持Spring 5 响应式编程的框架Spring Reactor，也进入了里程碑式的3.1.0 版本。

1.2 什么是响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
响应式编程基于reactor（Reactor 是一个运行在 Java8 之上的响应式框架）的思想，当你做一个带有一定延迟的才能够返回的io操作时，不会阻塞，而是立刻返回一个流，并且订阅这个流，当这个流上产生了返回数据，可以立刻得到通知并调用回调函数处理数据。
电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。
响应式传播核心特点之一：变化传播：一个单元格变化之后，会像多米诺骨牌一样，导致直接和间接引用它的其他单元格均发生相应变化。

1.3 基于 Reactor 实现

Reactor 是一个运行在 Java8 之上满足 Reactice 规范的响应式框架，它提供了一组响应式风格的 API。
Reactor 有两个核心类： Flux 和 Mono，这两个类都实现 Publisher 接口。
Flux 类似 RxJava 的 Observable，它可以触发零到多个事件，并根据实际情况结束处理或触发错误。
Mono 最多只触发一个事件，所以可以把 Mono 用于在异步任务完成时发出通知。
Flux 和 Mono 都是数据流的发布者，使用 Flux 和 Mono 都可以发出三种数据信号：元素值，错误信号，完成信号；错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者。
三种信号的特点：
错误信号和完成信号都是终止信号，不能共存
如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流
如果没有错误信号，也没有完成信号，表示是无限数据流

Mono 原理图如下：
在这里插入图片描述

Flux原理图如下：
在这里插入图片描述

结合上面两个图，发现Mono和Flux非常相似。只是Mono只接收一个元素，而Flux接收多个元素

二、示例代码

2.1 Mono

package com.reactor.demo;import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import reactor.core.publisher.Mono;import java.time.Duration;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;@Slf4j
public class MonoTest {@Testpublic void test1() {//just用法Mono.just("hello world").subscribe(System.out::println);//runnable创建monoMono<Void> sinkMono = Mono.fromRunnable(() -> System.out.println("runnable"));//这句不会输出sinkMono.doOnNext(unused -> System.out.println("void success"));//这句也不会输出sinkMono.subscribe(o -> System.out.println("void result" + o));//创建一个不包含任何元素，只发布结束消息的序列。，这里的hello empty是不会输出的。Mono.empty()//输出“empty的入参是null”.doOnSuccess(o -> System.out.println("empty的入参是" + o))//这句不会输出.subscribe(o -> System.out.println("hello empty"));//empty里面至少还有一个结束消息，而never则是真的啥都没有。"never的入参是"不会输出 ，这里的hello never也不会输出Mono.never().doOnSuccess(o -> System.out.println("never的入参是" + o)).subscribe(o -> System.out.println("hello never"));}@Testpublic void test2() {//传入supplierMono.fromSupplier(() -> "Hello supplier").subscribe(System.out::println);//传入optionalMono.justOrEmpty(Optional.of("Hello optional")).subscribe(System.out::println);//通过sink来创建一个正常执行的MonoMono.create(sink -> sink.success("Hello sink")).subscribe(System.out::println);//通过sink来创建一个抛出异常的MonoMono.create(sink -> sink.error(new RuntimeException("sink error"))).subscribe(System.out::println);//defer的入参实际上是一个Mono工厂Mono.defer(() -> Mono.just("hello defer")).subscribe(System.out::println);}@Testpublic void test3() {//callable，有返回值Mono.fromCallable(() -> "callable").subscribe(System.out::println);//runnable无返回值Mono<Void> mono = Mono.fromRunnable(() -> System.out.println("run"));//下面的hello runnable是不会输出的。因为subscribe一个Mono<Void>,不会产生任何结果mono.subscribe(o -> System.out.println("hello runnable"));}@Testpublic void test4() {//延迟3秒输出Mono.delay(Duration.ofSeconds(3)).doOnNext(new Consumer<Long>() {@Overridepublic void accept(Long aLong) {System.out.println(aLong);}}).block();}@Testpublic void test5() {//直接输出了异常Mono.error(new RuntimeException("这是一个异常")).subscribe(new Consumer<Object>() {@Overridepublic void accept(Object o) {System.out.println("error:" + o);}});Mono.defer(() -> {return Mono.error(new RuntimeException("这是第二个异常"));}).subscribe(new Consumer<Object>() {@Overridepublic void accept(Object o) {System.out.println("defer error:" + o);}});}@Testpublic void test6() {//通过map可以对元素进行转换Mono.just("just one").map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return 1;}}).doOnNext(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println("转换后的结果：" + integer);}}).subscribe();}
}

2.1 Flux

package com.reactor.demo;import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;import java.time.Duration;
import java.util.Arrays;
import java.util.function.Consumer;public class FluxTest {/*** 基本用法*/@Testpublic void test1() {//通过just传入可变的参数，依次输出Flux.just("hello", "world", "just").doOnNext(System.out::println).doOnComplete(() -> System.out.println("just over")).subscribe();//传入一个范围Flux.range(100, 10).doOnNext(System.out::println).doOnComplete(() -> System.out.println("OK")).subscribe();//传入listFlux.fromIterable(Arrays.asList("01", "02", "03")).doOnNext(System.out::println).subscribe();//传入一个数组Flux.fromArray(new Object[]{"obj1", "obj2"}).doOnNext(System.out::println).subscribe();}/*** 处理空值*/@Testpublic void testEmpty() {//如果序列是个空的，就给个默认值Flux.empty().defaultIfEmpty(1).doOnNext(System.out::println).subscribe();//如果序列是空的，就用新序列代替Flux.empty().switchIfEmpty(Mono.just("100")).doOnNext(System.out::println).subscribe();}/*** 序列在执行时的一些监听方法doOnXXXX*/@Testpublic void testDoOn() {System.out.println("----------");Flux.range(100, 10).doOnNext(System.out::println).doOnComplete(() -> System.out.println("OK"));System.out.println("----------");Flux.range(100, 10).doFirst(() -> System.out.println("第一个执行开始")).subscribe();System.out.println("----------");Flux.range(100, 10).doFinally(it -> System.out.println("终止信号的类型为" + it.name())).subscribe();System.out.println("----------");Flux.range(100, 10).doOnSubscribe(it -> System.out.println("该序列已被订阅")).subscribe();System.out.println("----------");Flux.range(100, 10).doOnRequest(value -> System.out.println("doOnRequest:" + value)).subscribe();//在完成或者error时，也就是序列终止时执行runnableSystem.out.println("----------");Flux.range(100, 10).doOnTerminate(() -> System.out.println("doOnTerminate")).subscribe();//doOnEach每次向下游传播，都会得到一个信号类型，可以根据该信号类型执行一些操作System.out.println("----------");Flux.range(100, 10).doOnEach(it -> System.out.println("doOnEach:" + it)).subscribe();}/*** filter用法*/@Testpublic void testFilter() {System.out.println("----------");//将上游的数据进行类型判断，符合该类型的数据将流向下游Flux.just(new Object(), "Hello", 1).ofType(String.class).doOnNext(System.out::println).doOnComplete(() -> System.out.println("过滤String示例")).subscribe();System.out.println("----------");//过滤数据Flux.range(100, 10).filter(it -> it > 105).doOnComplete(() -> System.out.println("取出大于105示例")).subscribe();System.out.println("----------");//将重复数据过滤,重复数据在整个序列中只保留一个Flux.range(100, 10).concatWith(Flux.just(100, 100, 100)).distinct().doOnNext(System.out::println).doOnComplete(() -> System.out.println("去除重复数字示例")).subscribe();System.out.println("----------");//将后来的重复数据过滤，如下，第二个flux拼接到第一个序列时，只会把第二个元素本身的重复元素过滤Flux.range(100, 10).concatWith(Flux.just(100, 100, 100)).distinctUntilChanged().doOnNext(System.out::println).doOnComplete(() -> System.out.println("将后来的重复数据过滤")).subscribe();System.out.println("----------");//在序列的开始获取5个元素，// limitRequest为true时，则不管该序列会发射多少元素，该参数会向上传递背压，则上游序列只会发出设定的5个元素//为false时，则不控制上有元素可以发出N个元素Flux.range(100, 10).take(5, false).doOnComplete(() -> System.out.println("在序列的开始获取5个元素")).subscribe();System.out.println("----------");//参数为时间单位，意味着take获取元素，只会在该时间限制内获取。Flux.range(100, 10).take(Duration.ofSeconds(10)).doOnNext(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println("当前时间戳为：" + System.currentTimeMillis() + "，数字为：" + integer);}}).doOnComplete(() -> System.out.println("在指定时间内获取元素")).subscribe(System.out::println);System.out.println("----------");//获取最后的N位元素Flux.range(100, 10).takeLast(2).doOnComplete(() -> System.out.println("获取最后的2位元素")).subscribe(System.out::println);System.out.println("----------");//获取元素，知道符合条件后停止向下游发送数据,包括条件本身，也就是当it>105的元素也会被发布至下游Flux.range(100, 10).takeUntil(it -> it > 105).doOnComplete(() -> System.out.println("一直取数，直到大于105结束")).subscribe(System.out::println);System.out.println("----------");//获取元素，当元素符合该断言时，如果不符合直接终止,不包含条件本身Flux.range(100, 10).takeWhile(it -> it < 105).doOnComplete(() -> System.out.println("取出小于105示例")).subscribe(System.out::println);System.out.println("----------");//获取指定某个位置的一个元素Flux.range(100, 10).elementAt(0).doOnSuccess(new Consumer<Integer>() {@Overridepublic void accept(Integer i) {System.out.println("获取指定某个位置的一个元素:" + i);}}).subscribe();System.out.println("----------");//获取最后一个元素，last()如果为空则抛出异常，last(1)如果为空则发出默认值Flux.range(100, 10).takeWhile(it -> it > 105).last(1).subscribe(System.out::println);System.out.println("----------");//跳至第几秒开始执行Flux.range(100, 10).skip(Duration.ofSeconds(5)).subscribe(System.out::println);System.out.println("----------");//跳至第几个元素开始执行Flux.range(100, 10).skip(5).subscribe(System.out::println);System.out.println("----------");//从开始跳到最后第N个元素结束Flux.range(100, 10).skipLast(5).subscribe(System.out::println);System.out.println("----------");//跳至满足条件的地方开始执行,从第一个元素开始，知道满足条件，开始发送至下游Flux.range(100, 10).skipUntil(it -> it > 105).subscribe(System.out::println);System.out.println("----------");//每隔一段时间抽取样本数(取在这个时间的最后一个元素)，如果相隔实现大于序列的执行时间，则去最后一元素Flux.range(100, 100000000).sample(Duration.ofMillis(100)).subscribe(System.out::println);System.out.println("----------");//每隔一段时间抽取样本数(取在这个时间的第一个元素)，如果相隔实现大于序列的执行时间，则取第一个元素Flux.range(100, 10).sampleFirst(Duration.ofMillis(100)).subscribe(System.out::println);System.out.println("----------");//只获取一个元素，single()如果为空或者超多一个，抛出异常，single(1)如果为空返回默认值，如果多个抛出异常,singleOrEmpty()可以允许为空Flux.range(100, 10).single(1).subscribe(System.out::println);}/*** 当被订阅后如果发生异常，则stream会停止运行* 此时可以通过处理error来决定如何处理异常* 可以将异常跳过、将异常替换等*/@Testpublic void testErrorHandle() {System.out.println("----------");Flux.just(1, 2, 3, 0, 5, 4).map(it -> {it = 100 / it;return it;})//报错后返回，并停止运行.onErrorResume(e -> {return Mono.just(10000);}).doFinally(type -> {System.out.println(type);}).subscribe(System.out::println);System.out.println("----------");Flux.just(1, 2, 3).doOnNext(new Consumer<Integer>() {@Overridepublic void accept(Integer integer) {System.out.println(integer);if (integer == 2) {throw new RuntimeException("触发异常");}}}).doOnError(new Consumer<Throwable>() {@Overridepublic void accept(Throwable throwable) {System.out.println("doOnError：" + throwable.getMessage());}}).subscribe();System.out.println("----------");Flux.just(1, 2, 3, 0, 5, 4).map(it -> {it = 100 / it;return it;})//报错后继续运行，并执行相关操作.onErrorContinue((e, it) -> {System.out.println(e.getMessage());}).doFinally(type -> {System.out.println(type);}).subscribe(System.out::println);}@Testpublic void flatMapTest() {//输出50，100Flux.just(5, 10).flatMap(x -> Flux.just(x * 10)).toStream().forEach(System.out::println);}
}

Mono源码分析

以下面的代码为例，来分析一下Mono源码

@Test
public void test0() {//just用法Mono.just("hello world").subscribe(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println("accept:" + s);}});
}

Mono.just返回了个啥

原来是静态方法，返回了个MonoJust对象，入参作为构造参数传入

	public static <T> Mono<T> just(T data) {return onAssembly(new MonoJust<>(data));}

MonoJust原来是继承Mono的
在这里插入图片描述
有两个要点
1、有一个value字段来保存入参
2、一个subscribe方法，执行了什么动作，后面再分析

final class MonoJust<T> 
extends Mono<T>implements Fuseable.ScalarCallable<T>, Fuseable, SourceProducer<T>  {final T value;MonoJust(T value) {this.value = Objects.requireNonNull(value, "value");}@Overridepublic T call() throws Exception {return value;}@Overridepublic T block(Duration m) {return value;}@Overridepublic T block() {return value;}@Overridepublic void subscribe(CoreSubscriber<? super T> actual) {actual.onSubscribe(Operators.scalarSubscription(actual, value));}@Overridepublic Object scanUnsafe(Attr key) {if (key == Attr.BUFFERED) return 1;if (key == Attr.RUN_STYLE) return Attr.RunStyle.SYNC;return null;}
}

Mono.subscribe到底做了什么

subscribe方法入参是一个Consumer对象，这里可以理解为一个回调方法

	public final Disposable subscribe(Consumer<? super T> consumer) {Objects.requireNonNull(consumer, "consumer");return subscribe(consumer, null, null);}

继续往下，调用了三个参数的subscribe方法

	public final Disposable subscribe(@Nullable Consumer<? super T> consumer,@Nullable Consumer<? super Throwable> errorConsumer,@Nullable Runnable completeConsumer) {return subscribe(consumer, errorConsumer, completeConsumer, (Context) null);}

这里除了我们入参的第一个consumer，还有另外两个consumer。还有一个context，即上下文，这里也是空的。
errorConsumer：在出错的时候的回调方法
completeConsumer：完成时的回调方法，这里是一个Runnable

	public final Disposable subscribe(@Nullable Consumer<? super T> consumer,@Nullable Consumer<? super Throwable> errorConsumer,@Nullable Runnable completeConsumer,@Nullable Context initialContext) {return subscribeWith(new LambdaMonoSubscriber<>(consumer, errorConsumer,completeConsumer, null, initialContext));}

这里将几个consumer封装成了一个LambdaMonoSubscriber。
接着往下看subscribeWith方法

	public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {subscribe(subscriber);return subscriber;}

继续往下分析

@Override@SuppressWarnings("unchecked")public final void subscribe(Subscriber<? super T> actual) {CorePublisher publisher = Operators.onLastAssembly(this);CoreSubscriber subscriber = Operators.toCoreSubscriber(actual);//省略部分代码publisher.subscribe(subscriber);}catch (Throwable e) {Operators.reportThrowInSubscribe(subscriber, e);return;}}

省略了部分代码，publisher.subscribe(subscriber)，
publisher 即当前mono对象，MonoJust实现了这个方法
这里又回到MonoJust里了

@Override
public void subscribe(CoreSubscriber<? super T> actual) {actual.onSubscribe(Operators.scalarSubscription(actual, value));
}

这里的actual是什么，是上面的LambdaMonoSubscriber
这里又把actual和value封装成Operators.scalarSubscription
看一下LambdaMonoSubscriber定义
LambdaMonoSubscriber主要就是定义了一系列consumer，即回调勾子

final class LambdaMonoSubscriber<T> implements InnerConsumer<T>, Disposable {final Consumer<? super T>            consumer;final Consumer<? super Throwable>    errorConsumer;final Runnable                       completeConsumer;final Consumer<? super Subscription> subscriptionConsumer;final Context                        initialContext;volatile Subscription subscription;
}

看一下LambdaMonoSubscriber.onSubscribe方法

	@Overridepublic final void onSubscribe(Subscription s) {if (Operators.validate(subscription, s)) {this.subscription = s;if (subscriptionConsumer != null) {try {subscriptionConsumer.accept(s);}catch (Throwable t) {Exceptions.throwIfFatal(t);s.cancel();onError(t);}}else {s.request(Long.MAX_VALUE);}}}

我们的示例，会进入s.request(Long.MAX_VALUE);这个逻辑
这个s是什么：Operators.scalarSubscription
再来看看request方法

		@Overridepublic void request(long n) {if (validate(n)) {if (ONCE.compareAndSet(this, 0, 1)) {Subscriber<? super T> a = actual;a.onNext(value);if(once != 2) {a.onComplete();}}}}

即调用了LambdaMonoSubscriber的onNext和complete方法
LambdaMonoSubscriber.next

@Overridepublic final void onNext(T x) {Subscription s = S.getAndSet(this, Operators.cancelledSubscription());if (s == Operators.cancelledSubscription()) {Operators.onNextDropped(x, this.initialContext);return;}if (consumer != null) {try {consumer.accept(x);}catch (Throwable t) {Exceptions.throwIfFatal(t);s.cancel();doError(t);}}if (completeConsumer != null) {try {completeConsumer.run();}catch (Throwable t) {Operators.onErrorDropped(t, this.initialContext);}}}

这里主要是调用了consumer.accept(x);。这个consumer即我们最开始入参的那个回调方法
onComplete同理，即运行completeConsumer这个runnable

	@Overridepublic final void onComplete() {Subscription s = S.getAndSet(this, Operators.cancelledSubscription());if (s == Operators.cancelledSubscription()) {return;}if (completeConsumer != null) {try {completeConsumer.run();}catch (Throwable t) {Operators.onErrorDropped(t, this.initialContext);}}}

如果出错的情况下，会执行

	@Overridepublic final void onError(Throwable t) {Subscription s = S.getAndSet(this, Operators.cancelledSubscription());if (s == Operators.cancelledSubscription()) {Operators.onErrorDropped(t, this.initialContext);return;}doError(t);}void doError(Throwable t) {if (errorConsumer != null) {errorConsumer.accept(t);}else {Operators.onErrorDropped(Exceptions.errorCallbackNotImplemented(t), this.initialContext);}}

到这里，就分析完了

总结一下

  • Mono.Just构造了一个MonoJust对象，用于接收入参value。
  • Mono.subscribe方法，会接收一个Consumer，可以理解为回调方法
  • Mono.subscribe方法，最终会调用LambdaMonoSubscriber里面的onNext方法。onNext执行的，即我们传入的回调consumer
  • 在正常执行完时，会执行LambdaMonoSubscriber中的onComplete。这个runnable也是通过入参传过来的。
  • 在执行异常时，会执行LambdaMonoSubscriber中的onError。这个回调方法，也是通过入参传过来的。

体会一下，下面的过程，最好调试一下

    @Testpublic void test0() {//just用法Mono.just("hello world").doOnNext(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println("doOnNext1:"+s);}}).doOnNext(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println("doOnNext2:"+s);}}).subscribe(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println("subscribe:" + s);}}, new Consumer<Throwable>() {@Overridepublic void accept(Throwable throwable) {System.out.println("subscribe exception:" + throwable.getMessage());}}, new Runnable() {@Overridepublic void run() {System.out.println("subscribe complete");}});}

doOnNext1:hello world
doOnNext2:hello world
subscribe:hello world
subscribe complete

执行流程如下
在这里插入图片描述

参考文章

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/77653.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

腾讯云centos7.6安装部署备忘

腾讯云centos7.6安装部署备忘

1.Mysql 1.1 安装mysql wget http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm rpm -ivh mysql-community-release-el7-5.noarch.rpm yum install mysql-community-server 1.1.1 安装后重启 service mysqld restart 1.1.2 初次安装mysql&#xff0c;root账…
阅读更多...
【Python】【Fintech】用Python和蒙特卡洛法预测投资组合未来收益

【Python】【Fintech】用Python和蒙特卡洛法预测投资组合未来收益

【背景】 想利用蒙特卡洛方法和yahoo，stooq等财经网站上的数据快速预测特定portfolio的收益。 【分析】 整个程序的功能包括 读取json中的portfolio组合创建蒙特卡洛模拟预测收益的算法创建从财经网站获得特定投资组合数据，并根据2的算法获得该Index或Portfolio收益预测结…
阅读更多...
ARTS打卡第四周之删除链表倒数第几个节点、gdb start命令、扩散模型、如何学习分享

ARTS打卡第四周之删除链表倒数第几个节点、gdb start命令、扩散模型、如何学习分享

Algorithm 题目&#xff1a;删除链表倒数第 n 个结点 分析&#xff1a;可以把通过两个结点进行标记&#xff0c;有一个节点需要遍历得快点&#xff0c;简称为快结点&#xff0c;有个结点遍历得慢&#xff0c;简称为慢结点。快结点先停在正数第 n 个结点处&#xff0c;然后快慢…
阅读更多...
蓝桥杯打卡Day7

蓝桥杯打卡Day7

文章目录 阶乘的末尾0整除问题 一、阶乘的末尾0IO链接 本题思路&#xff1a;由于本题需要求阶乘的末尾0&#xff0c;由于我们知道2*510可以得到一个0&#xff0c;那么我们就可以找出2的数和5的数&#xff0c;但是由于是阶乘&#xff0c;所以5的数量肯定是小于2的数量&#xf…
阅读更多...
车载Android应用开发与分析 - 初试 SystemUI Plugin

车载Android应用开发与分析 - 初试 SystemUI Plugin

在前面的视频、文章中我们介绍完了整个车载Android应用开发所需要的基础知识&#xff1a; 【视频文稿】车载Android应用开发与分析 - 走进车载操作系统 - 掘金【视频文稿】车载Android应用开发与分析 - AOSP的下载与编译 - 掘金【视频文稿】车载Android应用开发与分析 - 开发系…
阅读更多...
Elasticsearch：为具有许多 and/or 高频术语的 top-k 查询带来加速

Elasticsearch：为具有许多 and/or 高频术语的 top-k 查询带来加速

作者&#xff1a;Adrien Grand Disjunctive queries&#xff08;term_1 OR term_2 OR ... OR term_n&#xff09;非常常用&#xff0c;因此在提高查询评估效率方面它们受到了广泛关注。 Apache Lucene 对于评估 disjunctive queries 有两个主要优化&#xff1a;一方面用于详尽评…
阅读更多...
[Android jni] Bitmap与Mat对象的相互转换

[Android jni] Bitmap与Mat对象的相互转换

1.JNI实现Bitmap到Mat的转换 void bitmap2mat(JNIEnv *env, jobject bitmap,Mat &mat){//锁定画布void *pixels;AndroidBitmap_lockPixels(env,bitmap,&pixels);//获取Bitmap的信息AndroidBitmapInfo bitmapInfo;AndroidBitmap_getInfo(env,bitmap,&bitmapInfo);//…
阅读更多...
opencv（python）视频按帧切片/cv2.VideoCapture()用法

opencv（python）视频按帧切片/cv2.VideoCapture()用法

一、介绍 cv2.VideoCapture是OpenCV中一个用于捕捉视频的类。它可以访问计算机的摄像头&#xff0c;或从视频文件中读取图像。通过cv2.VideoCapture&#xff0c;用户可以轻松地捕捉、保存、编辑和传输视频流数据。 使用cv2.VideoCapture可以实现以下功能&#xff1a; 1. 打开…
阅读更多...
计算机网络第四节 数据链路层

计算机网络第四节 数据链路层

一&#xff0c;引入数据链路层的目的 1.目的意义 数据链路层是体系结构中的第二层&#xff1b; 从发送端来讲&#xff0c;物理层可以将数据链路层交付下来的数据&#xff0c;装换成光&#xff0c;电信号发送到传输介质上了 从接收端来讲&#xff0c;物理层能将传输介质的光&…
阅读更多...
【Vue】一文让你进入Vue的大门

【Vue】一文让你进入Vue的大门

Vue简介 官网 ● 英文官网 ● 中文官网 介绍与描述 Vue历史 Vue 是一套用来动态构建用户界面的渐进式JS框架 构建用户界面&#xff1a;把数据通过某种办法变成用户界面 渐进式&#xff1a;Vue可以自底向上逐层的应用&#xff0c;简单应用只需要一个轻量小巧的核心库&#xff0c…
阅读更多...
python 语法入门

python 语法入门

文章目录 前言python 语法入门1. 语句分隔符2. 注释3. pep8规范4. 变量5. 扩展5.1. 运行此行代码的过程 前言 如果您觉得有用的话&#xff0c;记得给博主点个赞&#xff0c;评论&#xff0c;收藏一键三连啊&#xff0c;写作不易啊^ _ ^。   而且听说点赞的人每天的运气都不会…
阅读更多...
Promise，async，await 面试题

Promise，async，await 面试题

目录 5&#xff0c;面试题1234567 推荐先看Promise 相关知识点 5&#xff0c;面试题 1 结果 1&#xff0c;5&#xff0c;2&#xff0c;3&#xff0c;4 const promise new Promise((resolve, reject) > {console.log(1);setTimeout(() > {console.log(2);resolve();c…
阅读更多...
【LeetCode刷题篇零】一些基础算法知识和前置技能（下）

【LeetCode刷题篇零】一些基础算法知识和前置技能（下）

数组常用技巧 使用数组代替Map 使用另一个数组来统计每个数字出现的次数&#xff0c;数组的下标作为key, 数组的值作为value&#xff0c; 将数字作为数组的下标索引&#xff0c;数组里的值存储该数字出现的次数&#xff0c;原理有点类似桶排序中使用的计数数组。 比如这里如…
阅读更多...
小程序赖加载刷新数据页面数据堆叠问题debug

小程序赖加载刷新数据页面数据堆叠问题debug

目录 项目所需 原生写赖加载存在的bug 解决问题思路及代码实现 思路&#xff1a; 代码实现&#xff1a; 列表.wxml 列表.js Wenjain_shanchu.js Wenjain_shanchu.json Wenjain_shanchu.wxml shouye.js ⭐️ 好书推荐 【内容简介】 项目所需 某高校大一新生入学&am…
阅读更多...
​LeetCode解法汇总2605. 从两个数字数组里生成最小数字

​LeetCode解法汇总2605. 从两个数字数组里生成最小数字

目录链接&#xff1a; 力扣编程题-解法汇总_分享记录-CSDN博客 GitHub同步刷题项目&#xff1a; GitHub - September26/java-algorithms: 算法题汇总&#xff0c;包含牛客&#xff0c;leetCode&#xff0c;lintCode等网站题目的解法和代码&#xff0c;以及完整的mode类&#…
阅读更多...
EasyPHP-Devserver-17安装和配置mantisBT

EasyPHP-Devserver-17安装和配置mantisBT

文章目录 1、准备工作2、安装easyphp2.1 http://127.0.0.1 无法访问 3、安装mantisBT和phpMyAdmin3.1 配置浏览器的访问url和端口号&#xff08;配置局域网内可访问&#xff09;3.2 安装mantis 4、Administrator 注册新用户时设置登录密码5、附件上传6、邮件配置 文章参考自&am…
阅读更多...
【广州华锐互动】煤矿提升机作业VR互动实训平台

【广州华锐互动】煤矿提升机作业VR互动实训平台

在煤矿行业中&#xff0c;安全性是无可忽视的首要任务。传统的煤矿工人培训方法&#xff0c;如理论课堂讲解、实地操作演示&#xff0c;尽管具有一定的效果&#xff0c;但往往无法真实地模拟出煤矿的复杂环境&#xff0c;工作人员在没有真正接触煤矿的情况下&#xff0c;很难理…
阅读更多...
【LLM】Windows本地CPU部署民间版中文羊驼模型（Chinese-LLaMA-Alpaca）踩坑记录

【LLM】Windows本地CPU部署民间版中文羊驼模型（Chinese-LLaMA-Alpaca）踩坑记录

目录 前言 准备工作 Git Python3.9 Cmake 下载模型 合并模型 部署模型 前言 想必有小伙伴也想跟我一样体验下部署大语言模型, 但碍于经济实力, 不过民间上出现了大量的量化模型, 我们平民也能体验体验啦~, 该模型可以在笔记本电脑上部署, 确保你电脑至少有16G运行…
阅读更多...
【Face Swapping综述】Quick Overview of Face Swap Deep Fakes

【Face Swapping综述】Quick Overview of Face Swap Deep Fakes

【Face Swapping综述】Quick Overview of Face Swap Deep Fakes 0、前言Abstract1. Introduction2. Face Swapping Process2.1. Preprocessing2.2. Identity Extraction2.3. Attributes Extractor2.4. Generator2.5. Postprocessing2.6. Evaluation Methods3. Challenges4. Con…
阅读更多...
【GO语言基础】变量常量

【GO语言基础】变量常量

系列文章目录 【Go语言学习】ide安装与配置 【GO语言基础】前言 【GO语言基础】变量常量 【GO语言基础】数据类型 文章目录 系列文章目录常量和枚举变量声明全局变量声明大小写敏感 总结 常量和枚举 使用const关键字声明常量&#xff0c;并为每个常量提供显式的值。Go语言没有…
阅读更多...
最新文章

Copyright @ 2022~2023