响应式编程Reactor API大全（下）

Reactor 是一个基于响应式编程的库，主要用于构建异步和事件驱动的应用程序。Reactor 提供了丰富的 API，包括创建、转换、过滤、组合等操作符，用于处理异步数据流。以下是一些 Reactor 的主要 API 示例：

pom依赖

   <dependencyManagement><dependencies><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-bom</artifactId><version>2023.0.0</version><type>pom</type><scope>import</scope></dependency></dependencies></dependencyManagement><dependencies><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-core</artifactId></dependency><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.7.2</version><scope>test</scope></dependency></dependencies>

61. 使用 Reactor 的 then 方法进行后续操作

then 方法用于在当前数据流完成后执行后续操作。

import reactor.core.publisher.Flux;public class ReactorThenExample {public static void main(String[] args) {Flux<Integer> source = Flux.just(1, 2, 3);// 在当前数据流完成后执行后续操作source.then(Mono.fromRunnable(() -> System.out.println("Done"))).subscribe();}
}

62. 使用 Reactor 的 publishOn 方法进行线程切换

publishOn 方法用于切换数据流的发布线程，从而改变元素处理的线程。

import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;public class ReactorPublishOnExample {public static void main(String[] args) {Flux<Integer> source = Flux.range(1, 3);// 将数据流的发布线程切换到另一个线程池source.publishOn(Schedulers.elastic()).map(value -> value * 2).subscribe(System.out::println);}
}

63. 使用 Reactor 的 subscribeOn 方法进行订阅线程切换

subscribeOn 方法用于切换数据流的订阅线程，影响整个数据流的执行线程。

import reactor.core.publisher.Flux;
import reactor.core.scheduler.Schedulers;public class ReactorSubscribeOnExample {public static void main(String[] args) throws InterruptedException {Flux<Integer> source = Flux.range(1, 3).log();// 将数据流的订阅线程切换到另一个线程池 另一个线程：parallel-1source.subscribeOn(Schedulers.parallel()).map(value -> value * 2).subscribe(System.out::println);Thread.sleep(23333);}
}

64. 使用 Reactor 的 delayElements 方法进行元素延迟

delayElements 方法用于延迟数据流中元素的发送。

import reactor.core.publisher.Flux;
import java.time.Duration;public class ReactorDelayElementsExample {public static void main(String[] args) throws InterruptedException {Flux<Integer> source = Flux.range(1, 3);// 延迟每个元素的发送source.delayElements(Duration.ofSeconds(1)).subscribe(System.out::println);Thread.sleep(23333);}
}

65. 使用 Reactor 的 concatWith 方法进行数据流连接

concatWith 方法用于将两个数据流连接在一起，保持顺序。

import reactor.core.publisher.Flux;public class ReactorConcatWithExample {public static void main(String[] args) {Flux<Integer> source1 = Flux.just(1, 2, 3);Flux<Integer> source2 = Flux.just(4, 5, 6);// 将两个数据流连接在一起，保持顺序source1.concatWith(source2).subscribe(System.out::println);}
}

66. 使用 Reactor 的 merge 方法进行多数据流合并

merge 方法用于将多个数据流合并成一个数据流，并发执行。

import reactor.core.publisher.Flux;public class ReactorMergeExample {public static void main(String[] args) {Flux<Integer> source1 = Flux.just(1, 2, 3);Flux<Integer> source2 = Flux.just(4, 5, 6);// 将两个数据流合并成一个数据流Flux<Integer> mergedFlux = Flux.merge(source1, source2);mergedFlux.subscribe(System.out::println);}
}

67. concatWith和merge的比较

  1. 执行顺序：
    • concatWith： 这个方法会按照合并的顺序执行 Flux。它会等待第一个 Flux 完成（包括完成信号或错误信号），然后再开始下一个 Flux。
    • merge： 这个方法会并发执行所有的 Flux，它不会等待前一个 Flux 完成。因此，元素的顺序可能是交错的。
  2. 参数类型：
    • concatWith： 它接受一个单独的 Flux 作为参数，将这个 Flux 追加到当前 Flux 的末尾。
    • merge： 它接受可变参数，可以传入多个 Flux，并同时合并它们。
public class FluxConcatWithMergeExample {public static void main(String[] args) throws InterruptedException {Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(50));Flux<Integer> flux3 = Flux.just(7, 8, 9).delayElements(Duration.ofMillis(75));// 使用 concatWith 方法，按顺序执行flux1.concatWith(flux2).concatWith(flux3).subscribe(v ->{System.out.println("concatWith = " + v);});// 使用 merge 方法，并发执行Flux.merge(flux1, flux2, flux3).subscribe(v ->{System.out.println("merge = " + v);});Thread.sleep(22333);}
}

68. 使用 Reactor 的 mergeSequential 方法进行多数据流合并

mergeSequential 方法用于按顺序合并多个数据流，保持各个数据流的元素顺序。

import reactor.core.publisher.Flux;public class ReactorMergeSequentialExample {public static void main(String[] args) {Flux<Integer> source1 = Flux.just(1, 2, 3);Flux<Integer> source2 = Flux.just(4, 5, 6);// 按顺序合并两个数据流Flux<Integer> mergedFlux = Flux.mergeSequential(source1, source2);mergedFlux.subscribe(System.out::println);}
}

69. 使用 Reactor 的 combineLatest 方法进行多数据流合并

combineLatest 方法用于合并多个数据流的最新元素。

import reactor.core.publisher.Flux;public class ReactorCombineLatestExample {public static void main(String[] args) {Flux<Integer> source1 = Flux.just(1, 2, 3);Flux<Integer> source2 = Flux.just(4, 5, 6);// 合并两个数据流的最新元素Flux<Integer> combinedFlux = Flux.combineLatest(source1, source2, (a, b) -> a + b);combinedFlux.subscribe(System.out::println);}
}

71. 使用 Reactor 的 doOnNext 方法进行每个元素的附加操作

doOnNext 方法用于在每个元素发出时执行附加操作，例如日志记录、统计等。

import reactor.core.publisher.Flux;public class ReactorDoOnNextExample {public static void main(String[] args) {Flux<Integer> source = Flux.range(1, 3);// 在每个元素发出时执行附加操作source.doOnNext(value -> System.out.println("Processing: " + value)).subscribe(System.out::println);}
}

79. 使用 Reactor 的 fromCallable 方法创建带有返回值的 Mono

fromCallable 方法用于创建一个 Mono，其值由提供的 Callable 对象返回。

import reactor.core.publisher.Mono;import java.util.concurrent.Callable;public class ReactorFromCallableExample {public static void main(String[] args) {// 创建带有返回值的 MonoMono<String> resultMono = Mono.fromCallable(() -> {// 执行一些计算return "Result";});resultMono.subscribe(System.out::println);}
}

80. 使用 Reactor 的 using 方法进行资源管理

using 方法用于在数据流的生命周期内管理资源，例如打开和关闭文件、网络连接等。

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;public class ReactorUsingExample {public static void main(String[] args) {// 使用 using 方法管理资源Flux<String> resultFlux = Flux.using(() -> getResource(), // 打开资源resource -> getData(resource), // 使用资源获取数据流resource -> releaseResource(resource) // 关闭资源);resultFlux.subscribe(System.out::println);}private static Mono<String> getResource() {System.out.println("Opening resource");return Mono.just("Resource");}private static Flux<String> getData(Mono resource) {System.out.println("Getting data from resource: " + resource);return Flux.just("Data1", "Data2", "Data3");}private static Mono<Void> releaseResource(Mono resource) {System.out.println("Releasing resource: " + resource);return Mono.empty();}
}

82. 使用 Reactor 的 scan 方法进行累积操作

scan 方法用于对数据流中的元素进行累积操作，并生成一个新的数据流。

import reactor.core.publisher.Flux;public class ReactorScanExample {public static void main(String[] args) {Flux<Integer> source = Flux.just(1, 2, 3, 4, 5);// 对数据流中的元素进行累积操作source.scan(0, (acc, value) -> acc + value).subscribe(System.out::println);}
}

83. 使用 Reactor 的 takeWhile 方法进行条件性的元素获取

takeWhile 方法用于根据指定的条件获取数据流中的元素，直到条件不满足。

import reactor.core.publisher.Flux;public class ReactorTakeWhileExample {public static void main(String[] args) {Flux<Integer> source = Flux.just(1, 2, 3, 4, 5);// 根据条件获取元素，直到条件不满足source.takeWhile(value -> value < 4).subscribe(System.out::println);}
}

84. 使用 Reactor 的 thenMany 方法进行串联操作

thenMany 方法用于在当前数据流完成后执行另一个数据流，将它们串联起来。

import reactor.core.publisher.Flux;public class ReactorThenManyExample {public static void main(String[] args) {Flux<Integer> source1 = Flux.just(1, 2, 3);Flux<Integer> source2 = Flux.just(4, 5, 6);// 在当前数据流完成后执行另一个数据流source1.thenMany(source2).subscribe(System.out::println);}
}

85. 使用 Reactor 的 ignoreElements 方法忽略所有元素

ignoreElements 方法用于忽略数据流中的所有元素，只关注完成信号或错误信号。

import reactor.core.publisher.Flux;public class ReactorIgnoreElementsExample {public static void main(String[] args) {Flux<Integer> source = Flux.just(1, 2, 3);// 忽略所有元素，只关注完成信号source.ignoreElements().doOnTerminate(() -> System.out.println("Completed")).subscribe();}
}

在 Reactor 中，Sink 是一个用于手动推送元素（signals）到 Subscriber 的接口。它允许你在创建 Flux 或 Mono 的过程中手动控制元素的生成。Reactor 提供了两种 Sink：FluxSink 用于创建 Flux，MonoSink 用于创建 Mono。

98. 使用 FluxSink 发送元素和完成信号

import reactor.core.publisher.Flux;public class FluxSinkExample {public static void main(String[] args) {Flux.create(fluxSink -> {for (int i = 0; i < 5; i++) {fluxSink.next(i); // 发送元素}fluxSink.complete(); // 发送完成信号}).subscribe(System.out::println);}
}

99. 使用 FluxSink 发送元素和错误信号

import reactor.core.publisher.Flux;public class FluxSinkErrorExample {public static void main(String[] args) {Flux.create(fluxSink -> {for (int i = 0; i < 5; i++) {fluxSink.next(i); // 发送元素}fluxSink.error(new RuntimeException("Simulated error")); // 发送错误信号}).subscribe(System.out::println,error -> System.err.println("Error: " + error.getMessage()));}
}

100. 使用 MonoSink 发送元素和完成信号

import reactor.core.publisher.Mono;public class MonoSinkExample {public static void main(String[] args) {Mono.create(monoSink -> {monoSink.success("Hello, Mono!"); // 发送元素}).subscribe(System.out::println);}
}

101. 使用 MonoSink 发送错误信号

import reactor.core.publisher.Mono;public class MonoSinkErrorExample {public static void main(String[] args) {Mono.create(monoSink -> {monoSink.error(new RuntimeException("Simulated error")); // 发送错误信号}).subscribe(System.out::println,error -> System.err.println("Error: " + error.getMessage()));}
}

102. 使用 FluxSink 进行背压控制

在 Reactor 中，FluxSink 也提供了一些方法用于实现背压控制，以避免在高速生产者和低速消费者之间的元素溢出。

import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;public class FluxSinkBackpressureExample {public static void main(String[] args) {Flux.create(fluxSink -> {for (int i = 0; i < 1000; i++) {fluxSink.next(i);}}, FluxSink.OverflowStrategy.BUFFER) // 指定背压策略.onBackpressureBuffer(10, buffer -> System.err.println("Buffer overflow! Discarding: " + buffer)).subscribe(value -> {// 模拟慢速消费者try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(value);});}
}

在上述例子中，通过指定 FluxSink.OverflowStrategy.BUFFER 背压策略，当消费者无法跟上生产者的速度时，缓冲区将被用来存储元素。使用 onBackpressureBuffer 方法可以在溢出时执行自定义的操作。

103. 使用 FluxSink 进行手动请求

FluxSink 也提供了 request 方法，允许消费者手动请求元素。

import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxSink;public class FluxSinkManualRequestExample {public static void main(String[] args) {Flux.create(fluxSink -> {for (int i = 0; i < 100; i++) {fluxSink.next(i);if (i % 10 == 0 && fluxSink.requestedFromDownstream() == 0) {// 当请求的元素达到 0 时，等待下游再次请求while (fluxSink.requestedFromDownstream() == 0) {// 等待下游请求try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}}fluxSink.complete();}).subscribe(System.out::println);}
}

在这个例子中，当消费者请求的元素达到 0 时，生产者会等待下游再次请求。这种手动控制请求的方式可以更灵活地处理背压。

107. 使用 Reactor 的 Hooks 进行全局错误处理

Hooks 是 Reactor 提供的一组钩子，可以用于全局错误处理，捕获整个流的错误。

import reactor.core.publisher.Flux;
import reactor.core.publisher.Hooks;public class ReactorHooksErrorHandlingExample {public static void main(String[] args) {// 使用 Hooks 进行全局错误处理Hooks.onOperatorError((error, reference) -> {System.err.println("Global Error Handling: " + error.getMessage());return error;});Flux<Integer> source = Flux.just(1, 2, 0, 4, 5);// 流中的错误将被全局处理source.map(x -> 10 / x).subscribe(data -> System.out.println("Received: " + data),error -> System.err.println("Subscriber Error: " + error.getMessage()));}
}

在这个例子中，我们使用 Hooks.onOperatorError 来设置全局错误处理，当流中发生错误时，会调用全局错误处理的回调方法。这可以用于捕获整个流的错误，而不是每个 subscribe 中单独处理。

109. 使用 Reactor 的 ConnectableFlux 进行热序列

ConnectableFlux 是 Reactor 提供的一种特殊类型的 Flux，它允许在订阅之前预热（开始生成元素），并在多个订阅者之间共享相同的序列。

import reactor.core.publisher.ConnectableFlux;
import reactor.core.publisher.Flux;import java.time.Duration;public class ReactorConnectableFluxExample {public static void main(String[] args) {ConnectableFlux<Integer> connectableFlux = Flux.range(1, 3).delayElements(Duration.ofSeconds(1)).publish(); // 将普通的 Flux 转换为 ConnectableFluxconnectableFlux.connect(); // 开始生成元素// 第一个订阅者connectableFlux.subscribe(data -> System.out.println("Subscriber 1: " + data));try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}// 第二个订阅者，共享相同的序列connectableFlux.subscribe(data -> System.out.println("Subscriber 2: " + data));// 结果：// Subscriber 1: 1// Subscriber 1: 2// Subscriber 2: 2// Subscriber 1: 3// Subscriber 2: 3}
}

在这个例子中，我们使用 publish 方法将普通的 Flux 转换为 ConnectableFlux，通过 connect 方法开始生成元素。第一个订阅者在元素生成过程中订阅，然后等待了 2 秒后，第二个订阅者也开始订阅，两者共享相同的序列。这种方式可以用于创建热序列，使得订阅者能够共享相同的元素序列。

110. 使用 Reactor 的 Flux.defer 实现延迟订阅

Flux.defer 允许你在每次订阅时创建一个新的 Flux，从而实现延迟订阅。这对于需要在每次订阅时执行一些逻辑的场景非常有用。

import reactor.core.publisher.Flux;public class ReactorFluxDeferExample {public static void main(String[] args) {Flux<Integer> deferredFlux = Flux.defer(() -> {// 在每次订阅时创建新的 FluxSystem.out.println("Creating new Flux");return Flux.just(1, 2, 3);});// 第一个订阅deferredFlux.subscribe(data -> System.out.println("Subscriber 1: " + data));// 第二个订阅deferredFlux.subscribe(data -> System.out.println("Subscriber 2: " + data));// 结果：// Creating new Flux// Subscriber 1: 1// Subscriber 1: 2// Subscriber 1: 3// Creating new Flux// Subscriber 2: 1// Subscriber 2: 2// Subscriber 2: 3}
}

在这个例子中，Flux.defer 中的 lambda 表达式将在每次订阅时执行，因此每个订阅都会创建一个新的 Flux。这对于那些需要在每次订阅时重新生成数据的情况非常有用。

119. 使用 Reactor 的 Flux.handle 处理元素和错误

Flux.handle 方法用于处理元素和错误，通过提供一个 BiConsumer 处理每个元素，并通过提供一个 BiConsumer 处理错误。

import reactor.core.publisher.Flux;public class ReactorFluxHandleExample {public static void main(String[] args) {Flux<Integer> source = Flux.just(1, 2, 0, 4, 5);// 处理元素和错误Flux<Integer> handledFlux = source.handle((value, sink) -> {if (value != 0) {sink.next(value); // 处理元素} else {sink.error(new RuntimeException("Cannot divide by zero")); // 处理错误}});handledFlux.subscribe(System.out::println,error -> System.err.println("Error: " + error.getMessage()));}
}

在这个例子中，我们使用 Flux.handle 处理每个元素，如果元素不为零，则将其发送到下游；如果元素为零，则通过 sink.error 处理错误。这可以用于处理元素和错误的场景。

120. 使用 Reactor 的 Mono.handle 处理元素和错误

Mono.handle 方法与 Flux.handle 类似，用于处理单个元素和错误。

import reactor.core.publisher.Mono;public class ReactorMonoHandleExample {public static void main(String[] args) {Mono<Integer> source = Mono.just(10);// 处理元素和错误Mono<Integer> handledMono = source.handle((value, sink) -> {if (value > 0) {sink.next(value); // 处理元素} else {sink.error(new RuntimeException("Invalid value")); // 处理错误}});handledMono.subscribe(System.out::println,error -> System.err.println("Error: " + error.getMessage()));}
}

在这个例子中，我们使用 Mono.handle 处理单个元素，如果元素为正数，则发送到下游；如果元素不为正数，则通过 sink.error 处理错误。这可以用于处理单个元素和错误的场景。

太太太多了，到此为止吧~~~~

学习打卡day08：响应式编程Reactor API大全（下）

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

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

相关文章

Git Large File Storage介绍

Git Large File Storage介绍

Git Large File Storage&#xff08;Git LFS&#xff09;是一个 Git 扩展&#xff0c;用于改善大文件的处理。著名的huggingface就是使用它存储大模型文件。在使用传统的 Git 时&#xff0c;所有历史记录中的文件都存储在 Git 仓库中&#xff0c;这可能导致仓库变得异常庞大&am…
阅读更多...
抛弃安卓，追赶iOS，鸿蒙能否成为中国第二大系统？

抛弃安卓，追赶iOS，鸿蒙能否成为中国第二大系统？

据半导体行业观察机构Techinsights发布报告预测&#xff0c;从2024年起&#xff0c;鸿蒙Harmony OS将取代苹果iOS&#xff0c;成为中国市场上第二大智能手机操作系统。 鸿蒙系统&#xff0c;支棱起来了&#xff01;去年&#xff0c;华为前脚“复活”麒麟芯片&#xff0c;后脚宣…
阅读更多...
C#-sort()利用委托自定义排序

C#-sort()利用委托自定义排序

文章速览 前言&#xff1a;核心代码&#xff1a;完整示例&#xff1a;对链表实现自定义排序1、链表类2、解决方案&#xff1a; 坚持记录实属不易&#xff0c;希望友善多金的码友能够随手点一个赞。 共同创建氛围更加良好的开发者社区&#xff01; 谢谢~ 前言&#xff1a; 使用…
阅读更多...
学习笔记18——个人理解为什么快速重传是3次ACK

学习笔记18——个人理解为什么快速重传是3次ACK

为什么快速重传是选择3次ACK&#xff1f; 个人理解&#xff1a;首先网络中的丢包&#xff0c;乱序以及网路故障都会让服务器端发回duplicated ACK&#xff0c;表示有一个包一直未收到。快速重传是通过3次ACK来区分乱序&#xff0c;丢包和网路拥塞的情况&#xff0c;是基于实践经…
阅读更多...
解决jenkins需要jdk11，项目需要jdk8的问题

解决jenkins需要jdk11，项目需要jdk8的问题

思路&#xff1a;jdk8 采用解压缩模式&#xff0c;jdk11采用安装模式&#xff0c;然后在jenkins中指定jdk路径 下载解压缩jdk8 https://www.oracle.com/java/technologies/downloads/#java8 解压缩&#xff1a;jdk-8u391-linux-i586.tar.gz /lib/ld-linux.so.2: bad ELF inte…
阅读更多...
2023年全国职业院校技能大赛（高职组）“云计算应用”赛项赛卷⑥

2023年全国职业院校技能大赛（高职组）“云计算应用”赛项赛卷⑥

2023年全国职业院校技能大赛&#xff08;高职组&#xff09; “云计算应用”赛项赛卷6 目录 需要竞赛软件包环境以及备赛资源可私信博主&#xff01;&#xff01;&#xff01; 2023年全国职业院校技能大赛&#xff08;高职组&#xff09; “云计算应用”赛项赛卷6 模块一…
阅读更多...
时空数据各大顶会最新论文和代码分享，结合多模态、扩散学习等热门主题

时空数据各大顶会最新论文和代码分享，结合多模态、扩散学习等热门主题

本次继续分享时空数据相关的论文。上一期戳这里↓&#xff1a;时空预测方向最新研究成果汇总&#xff0c;附13篇必看顶会论文https://blog.csdn.net/weixin_42645636/article/details/135369217 在刚刚过去的2023年间&#xff0c;我们不仅在时空数据领域的传统任务上取得了许多…
阅读更多...
Java线程学习笔记

Java线程学习笔记

1、判断线程存活 1. 当线程run()或者call()方法执行结束&#xff0c;线程进入终止状态 2. 当线程内发生异常&#xff0c;并且异常没有被捕获&#xff0c;线程进入终止状态 3. 线程调用stop()方法后&#xff0c;线程进入终止状态(不推荐使用) 当主线程结束时&#xff0c;其他线程…
阅读更多...
下一代人工智能的设计思路

下一代人工智能的设计思路

大模型扭转了此前人工智能研究的思路&#xff0c;放弃了可解释性&#xff0c;而开始拥抱复杂网络和大规模参数。 这些让现代神经网络的能力超越前代&#xff0c;但也带来了不少问题。 巨大的成本&#xff1a;训练模型需要的数据和算力都是海量&#xff0c;动辄数百万千万&…
阅读更多...
Redis 内存淘汰策略有哪些？过期数据如何删除？

Redis 内存淘汰策略有哪些？过期数据如何删除？

Redis 在面试中出现的概率非常大&#xff0c;毕竟后端项目如果用到分布式缓存的话&#xff0c;一般用的都是 Redis。目前&#xff0c;还没有出现一个能够取代 Redis 的分布式缓存解决方案。 这篇文章中&#xff0c;我会分享几道 Redis 内存管理相关的问题&#xff0c;都很常见…
阅读更多...
Redis的过期策略

Redis的过期策略

Redis 支持的过期策略主要有以下几种&#xff1a; 定时过期(Timed Expiration) 这种策略会在设置键的过期时间时&#xff0c;创建一个定时器&#xff0c;当达到指定的过期时间点时&#xff0c;立即执行删除操作。这种方式可以精确控制键的生命周期&#xff0c;但是如果有大量的…
阅读更多...
uniapp引入第三方字体库如（宋体、喜鹊燕书体、字小魂歌以晓手迹行楷体等) 最优解决方案

uniapp引入第三方字体库如（宋体、喜鹊燕书体、字小魂歌以晓手迹行楷体等) 最优解决方案

最近在开发一个写对联的小程序&#xff0c;其中要求对联文字以不同字体呈现&#xff0c;比如&#xff08;宋体、喜鹊燕书体、字小魂歌以晓手迹行楷体等&#xff09;&#xff0c;如图&#xff1a; 一般UI设计给的都是这种.tff格式的字体文件&#xff0c;如图&#xff1a; 那么…
阅读更多...
猫咪主食冻干真的对猫好吗？最热门的三款主食冻干对比测评

猫咪主食冻干真的对猫好吗？最热门的三款主食冻干对比测评

随着对猫咪主食健康和营养问题的关注度提高&#xff0c;越来越多的铲屎官开始重视科学养猫。 主食冻干因其模拟猫咪原始捕猎猎物模型配比、低温加工的特点&#xff0c;被认为是最符合猫咪饮食天性的选择。 相比传统的膨化猫粮&#xff0c;主食冻干中的淀粉和碳水化合物添加较…
阅读更多...
如何删除mysql-bin

如何删除mysql-bin

“删除mysql-bin”,用于记录一下后面还会用到. 删除mysql-bin的方法&#xff1a; 1、通过“mysql> reset master;reset slave;”命令删除“mysql-bin”文件&#xff1b;2、删除“my.cnf”中的“log-binmysql-bin”一行即可。 默认情况下mysql会一直保留mysql-bin文件&…
阅读更多...
QT基础篇（2）QT5模板库，工具类及控件

QT基础篇（2）QT5模板库，工具类及控件

1.字符串类 QT中的字符串类包括以下几种&#xff1a; QString类&#xff1a;是Qt中最常用的字符串类&#xff0c;用来存储Unicode字符。它支持各种字符串操作&#xff0c;例如连接、替换、截取等。 QByteArray类&#xff1a;用来存储字节序列&#xff0c;适用于处理非Unicode…
阅读更多...
计算机网络 物理层

计算机网络 物理层

文章目录 物理层物理层的基本概念数据通信的基础知识数据通信系统的模型有关信道的几个基本概念信道的极限容量 物理层下面的传输媒体导引型传输媒体非引导型传输媒体 信道复用技术波分复用码的复用 宽带接入技术ADSL 技术光纤同轴混合网 (HFC 网&#xff09;FTTx 技术 物理层 …
阅读更多...
爬虫01-爬虫原理以及爬虫前期准备工作

爬虫01-爬虫原理以及爬虫前期准备工作

文章目录 1 爬虫基本原理什么是爬虫爬虫功能详解爬虫基本流程两个概念&#xff1a;request和response 2 一些问题爬虫能抓取什么样的数据&#xff1f;抓取的数据怎么提取部分内容&#xff1f;数据解析方式。为什么我爬虫抓取的数据和浏览器看到的不一样怎样解决JavaScript渲染的…
阅读更多...
阿里云弹性计算技术公开课-ECS 安全季 全新上线！

阿里云弹性计算技术公开课-ECS 安全季 全新上线！

云布道师 如何保障云上业务的应用安全和数据安全&#xff0c;是每一个上云的企业和用户关注的重点。云上安全建设是一个体系化工程&#xff0c;需要用户主动进行多方面的考虑和实施&#xff0c;包括制定完善的安全策略和规范&#xff0c;如身份认证、访问控制、漏洞管理、安全…
阅读更多...
超实用的公众号内容制作流程，小白也能轻松学会

超实用的公众号内容制作流程，小白也能轻松学会

公众号是以内容为王的平台&#xff0c;保持优质原创内容发布可以给公众号带来源源不断的流量&#xff0c;稳定输出内容&#xff0c;会获得平台的流量扶持。 很多小伙伴运营公众号都没有什么阅读量&#xff0c;一方面是公众号内容同质化越来越严重&#xff0c;另外一方面是公众…
阅读更多...
编程笔记 html5cssjs 030 HTML音频

编程笔记 html5cssjs 030 HTML音频

编程笔记 html5&css&js 030 HTML音频 一、<audio>元素二、属性三、事件三、使用 CSS 设置样式练习小结 有时候网页上也需要嵌入音频。比如播放歌曲或老师讲课的音频等。 一、<audio>元素 <audio> HTML 元素用于在文档中嵌入音频内容。<audio>…
阅读更多...
最新文章

Copyright @ 2022~2023