RxJava/RxAndroid的基本使用方法(一)

文章目录

  • 一、什么是RxJava
  • 二、使用前的准备
    • 1、导入相关依赖
    • 2、字段含意
    • 3、Upstream/Downstream——上/下游
    • 4、BackPressure
    • 5、BackPressure策略
    • 6、“热” and “冷” Observables
    • 7、 基类
    • 8、事件调度器
    • 9、操作符是什么?
  • 三、RxJava的简单用法
    • 1、Observable——Observer
    • 2、Flowable——Subscriber
    • 3、Completable——CompletableObserver
    • 4、Maybe——MaybeObserver
    • 5、Single——SingleObserver
      • **Single的操作符**
      • 5.1、just: 创建一个发射单一数据项的 `Single`
      • 5.2、error:创建一个发射错误通知的 `Single`
      • 5.3 map: 对 `Single` 中的数据进行转换
      • 5.4 flatMap: 将一个 `Single` 转换为另一个 `Single`
      • 5.5 zip:将多个 `Single` 组合成一个新的 `Single`,并在它们都成功时触发。
      • 5.6 Single的转化模式
        • 5.6.1 将 Single 转换为 Observable——single.toObservable
        • 5.6.2 将 Observable 转换为 Single
        • 5.6.3 将 Single转换为 Completable——single.ignoreElement
        • 5.6.4 将 Single转换为 Maybe——single.toMaybe
  • 四、事件调度器释放事件
  • 五、Scheduler——调度者

一、什么是RxJava

ReactiveX 是一个使用可观察序列编写异步和基于事件的程序的库。它扩展了观察者模式以支持数据和/或事件序列,并添加了运算符,允许以声明方式将序列组合在一起,同时抽象出对低级线程、同步、线程安全、并发数据结构和非线程等问题的关注和阻塞 I/O。

官网链接:ReactiveX

什么是响应式编程?

响应式编程是一种编程范式,旨在处理异步数据流和事件驱动的编程。它着重于数据流和变化的处理,使得在异步和事件驱动环境中更容易构建可维护可伸缩高响应的应用程序。

  1. 数据流: 响应式编程关注数据流,将数据视为一系列事件或变化。
  2. 响应性: 响应式编程强调应用程序对事件和数据的即时响应能力。它允许应用程序根据数据流中的事件来触发操作,而不是等待数据的拉取或轮询。
  3. 观察者模式: 响应式编程经常使用观察者模式,其中存在一个可观察对象(Observable)和一个或多个观察者(Observer)。可观察对象发出事件,观察者订阅并对这些事件作出反应。
  4. 流式操作: 响应式编程提供了一组丰富的操作符,用于处理、过滤、转换和合并数据流。这些操作符允许开发人员以声明性方式构建数据流处理管道。
  5. 背压处理: 响应式编程处理异步数据流时,考虑了背压问题,即生产者产生数据的速度大于消费者处理数据的速度。它提供了一些机制来处理背压,如缓冲、丢弃、错误处理等。
  6. 异步性: 在响应式编程中,大部分操作都是异步执行的,这有助于避免应用程序的阻塞,提高性能和响应能力。

RxJava的观察者模式

RxJava有四个基本概念:Observer(观察者),Observable(被观察者),subscribe(订阅),事件

ObserverObservable通过subscribe()实现订阅关系,从而Observable可以在需要的时候发出事件通知Observer。

  • Observer: 观察者,它决定事件发生时有怎么样的行为;
  • Observable: 被观察者,它决定什么时候出发事件以及触发什么样的事件;
  • subscribe:订阅,将Observer和Observable关联起来

二、使用前的准备

1、导入相关依赖

最新依赖地址:Github-RxJava/RxAndroid

implementation "io.reactivex.rxjava3:rxjava:3.1.8"

2、字段含意

Reactive:根据上下文一般翻译为反应式、响应式。

Iterable :可迭代对象,支持以迭代器的形式遍历。

Observable: 可观察对象,在Rx中定义为更强大的Iterable,在观察者模式中是被观察的对象,一旦数据产生或发生变化,会通过某种方式通知观察者或订阅者。

Observer :观察者对象,监听Observable发射的数据并做出响应,Subscriber是它的一个特殊实现。

emit: 含义是Observable在数据产生或变化时发送通知给Observer,调用Observer对应的方法,翻译为发射

items: 在Rx里是指Observable发射的数据项

3、Upstream/Downstream——上/下游

在响应式编程中,"上游"和"下游"通常用于描述数据流的生产者和消费者之间的关系。

  1. 上游(Upstream):上游是数据流的生产者,它生成和发出数据项。上游通常是源(例如,传感器、数据库查询、文件读取等),它们生成数据并将其传递给下游。
  2. 下游(Downstream):下游是数据流的消费者,它接收和处理来自上游的数据项。下游可以执行各种操作,如过滤、映射、转换、订阅等。它们通常是应用程序中的组件,用于处理和响应来自上游的数据。

在响应式编程中,数据通过流动的方式从上游传递到下游,这是一种异步的、非阻塞的方式。

上游和下游之间的通信通常是通过观察者模式或发布-订阅模式进行的,以实现数据的异步传递和处理。这种方式使得可以构建高效的、响应式的应用程序,能够处理异步数据流。

4、BackPressure

BackPressure直译为:背压,也叫做反压。

背压(Backpressure)是指在异步编程中,当生产者(Producer)生成数据的速度快于消费者(Consumer)处理数据的速度时,数据压力会在系统中积累,可能导致一些问题,如内存溢出或性能下降。

在RxJava中也就是被观察者(Observable)发送事件的速度快于观察者(Observer)的速度

背压问题通常出现在处理数据流的情况下,其中数据生产速度不受消费速度的限制。

5、BackPressure策略

image-20231106174727841

  1. MISSING:缺省设置,不做任何操作,而不进行任何缓冲或丢弃。
  2. ERROR: 当订阅者无法处理来自发布者的数据时,会引发 MissingBackpressureException 异常,表示出现了背压问题。
  3. BUFFER:当订阅者无法处理来自发布者的数据时,数据会被缓冲在内存中,直到订阅者可以处理它们。
  4. DROP: 把存不下的事件丢弃。
  5. LATEST:只保留最新的数据项,丢弃之前的数据。

6、“热” and “冷” Observables

Observable 何时开始发出其items?这取决于Observable。一个“热”Observable 可能会在创建后立即开始发射items,因此任何后续订阅该 Observable 的观察者都可能会开始观察中间某个位置的序列。另一方面,“冷”Observable 会等到观察者订阅它之后才开始发射items,因此这个观察者可以确保会收到整个数据序列。

7、 基类

RxJava 3 中的基类相比RxJava 2 没啥改变,主要有以下几个基类:

  • io.reactivex.Observable:发送0个/N个的数据,不支持BackPressure,有onNextonComplete

  • io.reactivex.Flowable:发送0个/N个的数据,支持Reactive-Streams和支持BackPressure,有onNextonComplete

  • io.reactivex.Single:只能发送单个数据或者一个错误,有onSuccess

  • io.reactivex.Completable:没有发送任何数据,但只处理 onComplete 和 onError 事件。有onComplete

  • io.reactivex.Maybe:能够发射0或者1个数据,要么成功,要么失败。有onSuccessonComplete

8、事件调度器

RxJava事件发出去并不是置之不顾,要有合理的管理者来管理它们,在合适的时机要进行释放事件,这样才不会导致内存泄漏,这里的管理者我们称为事件调度器CompositeDisposable

9、操作符是什么?

RxJava 提供了各种操作符,用于对观察序列进行转换、过滤、组合和处理。这些操作符可帮助你更灵活地处理异步数据流。

常见的操作符有:create、just、error、map、flatMap。在后面介绍Single的时候会简单的介绍。更多关于操作符的使用在下一篇博客这里简单了解概念就行了。

三、RxJava的简单用法

**RxJava以观察者模式为骨架,**有两种常见的观察者模式:

  • Observable(被观察者)/Observer(观察者)
  • Flowable(被观察者)/Subscriber(观察者)

image-20231106181029150

使用流程:

  1. 创建被观察者
  2. 创建观察者
  3. 订阅被观察者
  4. 取消订阅(这一步可以省略)

1、Observable——Observer

一般用法:

//创建被观察者/事件源
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {emitter.onNext("a");emitter.onNext("b");emitter.onNext("c");emitter.onComplete();}
});//创建观察者
Observer observer = new Observer<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {Log.e("TAG", "onSubscribe == 订阅");}@Overridepublic void onNext(@NonNull String s) {Log.e("TAG", "onNext == " + s);}@Overridepublic void onError(@NonNull Throwable e) {Log.e("TAG", "onError == " + e.toString());}@Overridepublic void onComplete() {Log.e("TAG", "onComplete");}
};//订阅(观察者监视被观察着)
observable.subscribe(observer);//取消订阅
observable.distinct();

image-20231106181404793

这种观察者模型不支持背压:当被观察者快速发送大量数据时,下游不会做其他处理,即使数据大量堆积,调用链也不会报MissingBackpressureException

消耗内存过大只会OOM。所以,当我们使用Observable——Observer的时候,我们需要考虑的是,数据量是不是很大(官方给出以1000个事件为分界线作为参考)。

并且观察者具有多个重载方法:

    //观察者不对被观察者发送的事件做出响应(但是被观察者还可以继续发送事件)public final Disposable subscribe()//观察者对被观察者发送的任何事件都做出响应public final void subscribe(Observer<? super T> observer)//表示观察者只对被观察者发送的Next事件做出响应public final Disposable subscribe(Consumer<? super T> onNext)//表示观察者只对被观察者发送的Next & Error事件做出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)//表示观察者只对被观察者发送的Next & Error & Complete事件做出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,Action onComplete)//表示观察者只对被观察者发送的Next & Error & Complete & onSubscribe事件做出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,Action onComplete, Consumer<? super Disposable> onSubscribe)

2、Flowable——Subscriber

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {@Overridepublic void subscribe(@NonNull FlowableEmitter<Integer> emitter) throws Throwable {emitter.onNext(1);emitter.onNext(2);emitter.onNext(3);emitter.onNext(4);emitter.onComplete();}
}, BackpressureStrategy.BUFFER);Subscriber<Integer> subscriber = new Subscriber<Integer>() {Subscription sub;@Overridepublic void onSubscribe(Subscription s) {Log.w("TAG", "onsubscribe start");sub = s;s.request(1);Log.w("TAG", "onsubscribe end");}@Overridepublic void onNext(Integer integer) {Log.e("TAG", "onNext == " + integer);sub.request(1);}@Overridepublic void onError(Throwable t) {t.printStackTrace();}@Overridepublic void onComplete() {Log.e("TAG", "onComplete");}
};flowable.subscribe(subscriber);

image-20231106184629182

Flowable是支持背压的,也就是说,一般而言,上游的被观察者会响应下游观察者的数据请求,下游调用request(n)来告诉上游发送多少个数据。这样避免了大量数据堆积在调用链上,使内存一直处于较低水平。

Flowable使用create()创建时,必须指定BackPressure策略。

注意

尽可能确保在request()之前已经完成了所有的初始化工作,否则就有空指针的风险。

3、Completable——CompletableObserver

它只有onComplete和onError两个事件

//被观察者
Completable completable = Completable.create(new CompletableOnSubscribe() {@Overridepublic void subscribe(@NonNull CompletableEmitter emitter) throws Throwable {emitter.onComplete();}
});//订阅观察者
completable.subscribe(new CompletableObserver() {@Overridepublic void onSubscribe(@NonNull Disposable d) {}@Overridepublic void onComplete() {Log.e("TAG","onComplete");}@Overridepublic void onError(@NonNull Throwable e) {}
});

image-20231106210536185

要转换成其他类型的被观察者,也是可以使用toFlowable()toObservable()等方法去转换。

4、Maybe——MaybeObserver

如果你的需求是可能发送一个数据或者不会发送任何数据,这时候你就需要Maybe,它类似于SingleCompletable的混合体。

        //被观察者Maybe<String> maybe = Maybe.create(new MaybeOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull MaybeEmitter<String> emitter) throws Throwable {emitter.onSuccess("have Data"); //发送一个数据的情况
//                emitter.onComplete();   //不发送数据的情况}});//订阅观察者maybe.subscribe(new MaybeObserver<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {}@Overridepublic void onSuccess(@NonNull String s) {Log.e("TAG",s);}@Overridepublic void onError(@NonNull Throwable e) {}@Overridepublic void onComplete() {Log.e("TAG","无数据");}});

image-20231106211427552

5、Single——SingleObserver

Single类似于Observable,不同的是,它总是只发射一个值,而不是发射一系列的值(并不存在MissingBackpressureException问题),所以当你使用一个单一连续事件流,这样可以使用Single。

Single观察者只包含两个事件,一个是正常处理成功的onSuccess,另一个是处理失败的onError。

Single.create

Single<String> stringSingle = Single.create(new SingleOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull SingleEmitter<String> emitter) throws Throwable {emitter.onSuccess("success1");emitter.onSuccess("success2");}
});stringSingle.subscribe(new SingleObserver<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {Log.e("TAG", "onSubscribe: "+d);}@Overridepublic void onSuccess(@NonNull String s) {Log.e("TAG", "onSuccess: "+s);}@Overridepublic void onError(@NonNull Throwable e) {e.printStackTrace();}
});

image-20231106184706201

可以看见数据只会发送一次,Single只会调用这两个方法中的一个,而且只会调用一次,调用了任何一个方法之后,订阅关系终止

Single 类型的操作符用于处理这些单一的数据项或错误。

Single的操作符

更多关于操作符的使用在下一篇博客这里简单了解概念就行了。

操作符返回值说明
composeSingle创建一个自定义的操作符
concat and concatWithObservable连接多个 Single 和 Observable 发射的数据
createSingle调用观察者的 create 方法创建一个 Single
errorSingle返回一个立即给订阅者发射错误通知的 Single
flatMapSingle返回一个 Single,它发射对原 Single 的数据执行 flatMap 操作后的结果
flatMapObservableObservable返回一个 Observable,它发射对原 Single 的数据执行 flatMap 操作后的结果
fromSingle将 Future 转换成 Single
justSingle返回一个发射一个指定值的 Single
mapSingle返回一个 Single,它发射对原 Single 的数据执行 map 操作后的结果
mergeSingle将一个 Single(它发射的数据是另一个 Single,假设为 B)转换成另一个 Single(它发射来自另一个 Single(B) 的数据)
merge and mergeWithObservable合并发射来自多个 Single 的数据
observeOnSingle指示 Single 在指定的调度程序上调用订阅者的方法
onErrorReturnSingle将一个发射错误通知的 Single 转换成一个发射指定数据项的 Single
subscribeOnSingle指示 Single 在指定的调度程序上执行操作
timeoutSingle它给原有的 Single 添加超时控制,如果超时了就发射一个错误通知
toSingleSingle将一个发射单个值的 Observable 转换为一个 Single
zip and zipWithSingle将多个 Single 转换为一个,后者发射的数据是对前者应用一个函数后的结果

用法示例:

5.1、just: 创建一个发射单一数据项的 Single

Single.just

Single<Integer> single = Single.just(42);

5.2、error:创建一个发射错误通知的 Single

Single.error

Single<String> single = Single.error(new RuntimeException("Something went wrong"));

5.3 map: 对 Single 中的数据进行转换

Single.map

        Single<Integer> source = Single.just(5);Single<String> mapped = source.map(new Function<Integer, String>() {@Overridepublic String apply(Integer integer) throws Throwable {return "integer : "+integer;}});

这意味着原始整数数据 5 经过映射操作转变为了字符串数据,带有特定的前缀。

这种操作在响应式编程中非常有用,因为它允许你对数据进行转换和处理,而不改变数据流的类型。你可以将原始数据映射为需要的格式,以满足应用程序的需求。

5.4 flatMap: 将一个 Single 转换为另一个 Single

Single.map

        Single<Integer> source = Single.just(5);Single<String> mapped = source.flatMap(new Function<Integer, SingleSource<? extends String>>() {@Overridepublic SingleSource<? extends String> apply(Integer integer) throws Throwable {return Single.just("Return : "+integer);}});

5.5 zip:将多个 Single 组合成一个新的 Single,并在它们都成功时触发。

Single.zip

Single<Integer> source = Single.just(5);
Single<String> mapped = source.flatMap(new Function<Integer, SingleSource<? extends String>>() {@Overridepublic SingleSource<? extends String> apply(Integer integer) throws Throwable {return Single.just("Return : " + integer);}
});Single single = Single.zip(source, mapped, new BiFunction<Integer, String, Object>() {@Overridepublic Object apply(Integer integer, String s) throws Throwable {return "Return : " + integer + s;}
});

5.6 Single的转化模式

5.6.1 将 Single 转换为 Observable——single.toObservable

Single<Integer> source = Single.just(5);// 将 Single 转换为 Observable
Observable<Integer> observable = source.toObservable();// 现在你可以将 Single 的结果集成到 Observable 中
observable.subscribe(value -> Log.e("TAG","Received value: " + value),error -> Log.e("TAG","Error: " + error),() -> Log.e("TAG","Completed")
);
5.6.2 将 Observable 转换为 Single
Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5);// 将 Observable 转换为 Single,只发射第一个数据项或错误
Single<Integer> single = observable.first(0);// 现在你可以将 Observable 的结果集成到 Single 中
single.subscribe(value -> System.out.println("Received value: " + value),error -> System.err.println("Error: " + error)
);
5.6.3 将 Single转换为 Completable——single.ignoreElement
Single<Integer> single = Single.just(42);// 将 Single 转换为 Completable,忽略结果,只关注完成或错误
Completable completable = single.ignoreElement();// 现在你可以使用 Completable 来执行某些操作
completable.subscribe(() -> System.out.println("Completed"),error -> System.err.println("Error: " + error)
);
5.6.4 将 Single转换为 Maybe——single.toMaybe
Single<Integer> single = Single.just(42);// 将 Single 转换为 Maybe,考虑成功结果、错误或没有结果
Maybe<Integer> maybe = single.toMaybe();// 现在你可以使用 Maybe 来处理这三种情况
maybe.subscribe(value -> System.out.println("Received value: " + value),error -> System.err.println("Error: " + error),() -> System.out.println("No result")
);

四、事件调度器释放事件

  1. Disposable:

    • Disposable 是 RxJava 的通用接口,用于表示订阅关系。
    • 它与所有的 RxJava 数据类型都相关,包括 ObservableFlowableSingleCompletableMaybe
    • 当你订阅一个数据流时,RxJava 会返回一个 Disposable 对象,你可以使用它来取消订阅或检查订阅状态。
       // 创建一个简单的 Observable,发射一些数据Observable stringObservable = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {emitter.onNext("Xiyou");emitter.onNext("3G");emitter.onNext("Android");emitter.onComplete();}});// 订阅 Observable 并获取 Disposable 对象Disposable disposable = stringObservable.subscribe(value -> Log.e("TAG", value.toString()),error -> Log.e("TAG", "ERROR" + error),() -> Log.e("TAG", "Completed"));disposable.dispose();   //在需要的时候取消订阅
    
  2. CompositeDisposable:

    • CompositeDisposableDisposable 接口的实现。
    • 它特别用于管理多个订阅关系,以便一次性取消多个订阅。
    • CompositeDisposable 可以添加多个 Disposable 对象,并在需要时一次性取消它们。
    • 这在管理多个订阅关系时非常有用,例如在 Android 中管理多个异步任务的订阅。
            //创建一个简单的 Observable,发射一些数据Observable stringObservable = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {emitter.onNext("Xiyou");emitter.onNext("3G");emitter.onNext("Android");emitter.onComplete();}});// 创建一个 CompositeDisposable 来管理订阅关系CompositeDisposable compositeDisposable = new CompositeDisposable();// 订阅 Observable 并获取 Disposable 对象Disposable disposable = stringObservable.subscribe(value -> Log.e("TAG", value.toString()),error -> Log.e("TAG", "ERROR" + error),() -> Log.e("TAG", "Completed"));// 将 Disposable 对象添加到 CompositeDisposable 中compositeDisposable.add(disposable);// 在不再需要订阅关系时,可以取消它们// compositeDisposable.clear(); // 取消所有订阅// 或者单独取消某个订阅// disposable.dispose();// 在不再需要 CompositeDisposable 时,清理它compositeDisposable.dispose();
    

    CompositeDisposable提供的方法中,都是对事件的管理

    • dispose():释放所有事件
    • clear():释放所有事件,实现同dispose()
    • add():增加某个事件
    • addAll():增加所有事件
    • remove():移除某个事件并释放
    • delete():移除某个事件

五、Scheduler——调度者

在RxJava默认规则中,事件的发出和消费都是在同一个线程中发生的,那么上面的这些例子来说,就是一个同步的观察者模式。

在RxJava中Scheduler(调度器)相当于线程控制器,RxJava通过Scheduler来指定那一部分代码执行在哪一个线程。我们来看看简单的例子:

 Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {@Overridepublic void subscribe(ObservableEmitter<String> emitter) throws Exception {emitter.onNext("RxJava:e.onNext== 第一次");emitter.onComplete();Log.d("TAG", "subscribe()线程==" + Thread.currentThread().getId());}}).subscribeOn(Schedulers.io())//指定被观察者subscribe()(发射事件的线程)在IO线程().observeOn(AndroidSchedulers.mainThread());//指定观察者接收响应事件的线程在主线程observable.subscribe(new Observer<String>() {@Overridepublic void onSubscribe(@NonNull Disposable d) {}@Overridepublic void onNext(@NonNull String s) {// 接收到数据时的回调,s 是传递的数据Log.d("TAG", "Received data: " + s);Log.d("TAG", "onNext()线程==" + Thread.currentThread().getId());}@Overridepublic void onError(@NonNull Throwable e) {}@Overridepublic void onComplete() {}});
  • subscribeOn():用于指定Observable被观察者subscribe()时所发生的线程,即指定发生事件的线程
  • observeOn():指定Observer观察者接收&响应事件的线程,即观察者接收事件的线程

注意:多次指定发射事件的线程只有第一次指定有效,也就是说多次调用subscribeOn()只有第一次有效,其余的会被忽略;但是多次指定订阅者接收事件的线程是可以的,也就是说每observeOn()一次,接收事件的线程就会切换一次。

  • Schedulers.io():代表IO操作的线程,通常用于网络、读写文件等IO密集型的操作。行为模式和new Thread()差不多,只是IO的内部是一个无上限的线程池,可重用空闲的线程,更高效(不要把计算工作放在IO内,可以避免创建不必要的线程)
  • AndroidSchedulers.mainThread():Android的主线程;用于更新UI
  • Schedulers.newThread():总是启用新线程,并在新线程中执行操作;多用于耗时操作
  • Schedulers.computation(): 代表CPU计算密集型的操作,即不会被IO等操作限制性能的操作。

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

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

相关文章

看了“米小圈”,才知道竟然有如此宝藏的动画片

在这个竞争激烈的时代里&#xff0c;作为孩子家长&#xff0c;都希望自己的孩子将来能够出类拔萃&#xff0c;我也不例外。自从孩子上小学后&#xff0c;就将孩子的学习作为第一要务&#xff0c;不再一味地纵容他贪玩&#xff0c;不允许他浪费时间。 我家孩子很淘气&#xff0…

【网络协议】聊聊DNS协议如何域名解析和负载均衡

DNS 服务器 我们知道如果使用IP地址进行访问网站&#xff0c;很难进行记忆&#xff0c;所以DNS的作用是将域名转换成对应的IP地址。如果全世界都使用同一台DNS服务器&#xff0c;那么DNS服务器本身需要保证服务的高可用、高性能&#xff0c;以及分布式等。最好的方式就是分层。…

【MongoDB】MongoExport如何过滤数据导出

问题 使用MongoDB处理导出数据时&#xff0c;想增加数据过滤操作。 例如&#xff1a;导出所有isGirl为true的所有数据。 分析 在mongoexport说明文档中找到了query字段和queryFile字段&#xff0c;用来进行数据查询匹配导出。 query字段 后面直接跟 json格式数据。 queryF…

java高并发系列-第1天:必须知道的几个概念

同步&#xff08;Synchronous&#xff09;和异步&#xff08;Asynchronous&#xff09; 同步和异步通常来形容一次方法调用&#xff0c;同步方法调用一旦开始&#xff0c;调用者必须等到方法调用返回后&#xff0c;才能继续后续的行为。异步方法调用更像一个消息传递&#xff…

承载AI计算的数据中心网络和传统数据中心有何不同?

生成式AI正在风靡全球&#xff0c;不少企业开始研究如何在其业务流程中采用人工智能技术&#xff0c;更有一些企业客户开始考虑在数据中心和私有云中部署自己的AIGC和 GPU 扩展网络。从网络角度来看&#xff0c;用于承载这类业务的数据中心与传统的数据中心有很大不同&#xff…

JVM 内存和 GC 算法

文章目录 内存布局直接内存执行引擎解释器JIT 即时编译器JIT 分类AOT 静态提前编译器&#xff08;Ahead Of Time Compiler&#xff09; GC什么是垃圾为什么要GC垃圾回收行为Java GC 主要关注的区域对象的 finalization 机制GC 相关算法引用计数算法&#xff08;Reference Count…

Flink(一)【WordCount 快速入门】

前言 学完了 Hadoop、Spark&#xff0c;本想着先把 Kafka、Flume 这些工具先学完的&#xff0c;但想了想还是把核心的技术先学完最后再去把那些工具学学。 最近心有点累哈哈哈&#xff0c;偷偷立个 flag&#xff0c;反正也没人看&#xff0c;明年的今天来这里还愿哈&#xff0c…

深度学习之基于Yolov5人体姿态摔倒识别分析报警系统(GUI界面)

欢迎大家点赞、收藏、关注、评论啦 &#xff0c;由于篇幅有限&#xff0c;只展示了部分核心代码。 文章目录 一项目简介 二、功能三、系统四. 总结 一项目简介 系统设计概述&#xff1a; 传感器采集&#xff1a;通过在场景中布置摄像头或红外传感器等设备&#xff0c;采集人体…

GZ035 5G组网与运维赛题第8套

2023年全国职业院校技能大赛 GZ035 5G组网与运维赛项&#xff08;高职组&#xff09; 赛题第8套 一、竞赛须知 1.竞赛内容分布 竞赛模块1--5G公共网络规划部署与开通&#xff08;35分&#xff09; 子任务1&#xff1a;5G公共网络部署与调试&#xff08;15分&#xff09; 子…

数学到底在哪里支撑着编程?

如果编程语言是血肉&#xff0c;那么数学的思想和知识就是灵魂。它可以帮助你选择合适的数据结构和算法&#xff0c;提升系统效率&#xff0c;并且赋予机器智慧。在大数据和智能化的时代更是如此。举个例子&#xff0c;我们在小学就学过的余数&#xff0c;其实在编程的世界里也…

python基础(Python高级特性(切片、列表生成式)、字符串的正则表达式、函数、模块、Python常用内置函数、错误处理)培训讲义

文章目录 1. Python高级特性&#xff08;切片、列表生成式&#xff09;a) 切片的概念、列表/元组/字符串的切片切片的概念列表切片基本索引简单切片超出有效索引范围缺省 扩展切片step为正数step为负数 b) 列表生成式以及使用列表生成式需要注意的地方概念举例说明1. 生成一个列…

Python详细教程,如何使用Python进行数据可视化?

文章目录 前言一、导入必要的库二、加载数据三、创建基本图表四、添加更多细节五、使用Seaborn库创建更复杂的图表关于Python技术储备一、Python所有方向的学习路线二、Python基础学习视频三、精品Python学习书籍四、Python工具包项目源码合集①Python工具包②Python实战案例③…

3D医学三维技术影像PACS系统源码

一、系统概述 3D医学影像PACS系统&#xff0c;它集影像存储服务器、影像诊断工作站及RIS报告系统于一身,主要有图像处理模块、影像数据管理模块、RIS报告模块、光盘存档模块、DICOM通讯模块、胶片打印输出等模块组成&#xff0c; 具有完善的影像数据库管理功能&#xff0c;强大…

人工智能AI 全栈体系(十二)

第二章 计算机是如何学会下棋的 下棋一直被认为是人类的高智商游戏&#xff0c;从人工智能诞生的那一天开始&#xff0c;研究者就开始研究计算机如何下棋。著名人工智能学者、图灵奖获得者约翰麦卡锡在 50 年代就开始从事计算机下棋方面的研究工作&#xff0c;并提出了著名的 …

北京陪诊小程序|陪诊系统开发|陪诊小程序未来发展不可小觑

近几年随着互联网快速发展&#xff0c;各行业领域都比较注重线上服务系统&#xff0c;通过陪诊小程序开发可以满足更多用户使用需求&#xff0c;同时还能提高用户使用体验。现在陪诊类的软件应用得到全面推广&#xff0c;在医疗行业当中陪诊小程序更贴近用户生活&#xff0c;可…

“七人拼团模式:创新玩法助力平台快速裂变引流“

七人拼团模式是一种结合了社交电商和拼购玩法的快速裂变引流模式。这种模式通过抽取平台营业所得作为奖励补贴用户&#xff0c;以更人性化的奖励机制吸引用户&#xff0c;服务用户&#xff0c;以此加快用户向粉丝的转变&#xff0c;为平台拉取有效流量。本文将介绍七人拼团模式…

什么是防火墙?详解三种常见的防火墙及各自的优缺点

目录 防火墙的定义 防火墙的功能 防火墙的特性 防火墙的必要性 防火墙的优点 防火墙的局限性 防火墙的分类 分组过滤防火墙 优点&#xff1a; 缺点&#xff1a; 应用代理防火墙 优点 缺点 状态检测防火墙 优点 缺点 防火墙的定义 防火墙的本义原是指古代人们…

DCU集群搭建虚拟环境方法简介

1.conda安装方法&#xff1a; wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh #下载miniconda安装包chmod 750 Miniconda3-latest-Linux-x86_64.sh #添加执行权限bash ./Miniconda3-latest-Linux-x86_64.sh #安装下载的minnconda32.集群安装…

VBA根据Excel内容快速创建PPT

示例需求&#xff1a;根据Excel中选中的单元格内容&#xff08;3列&#xff09;如下图所示&#xff0c;在已打卡的PowerPoint文件中创建页面。 新增PPT Slide页面使用第二个模板页面&#xff0c;其中包含两个文本占位符&#xff0c;和一个图片占位符。将Excel选中区域中前两列写…

c++实现观察者模式

前言 我觉得这是最有意思的模式&#xff0c;其中一个动&#xff0c;另外的自动跟着动。发布-订阅&#xff0c;我觉得很巧妙。 代码 头文件 #pragma once #include<vector> #include<string> #include<iostream>// 抽象观察者 class Aobserver { public:v…