Java8-如何使用CompletableFuture跟踪异步并行流中调用的异常数量
Java8引入了CompletableFuture类，它是一种用于处理异步操作的工具。通过CompletableFuture，我们可以轻松地跟踪异步并行流中调用的异常数量。
要使用CompletableFuture跟踪异步并行流中调用的异常数量，可以按照以下步骤进行操作：
- 创建一个Stream对象，可以是集合或数组等。
- 将Stream对象转换为并行流，使用parallel()方法。
- 使用map()方法将每个元素映射为CompletableFuture对象。在CompletableFuture对象中，我们可以执行异步操作。
- 使用CompletableFuture的exceptionally()方法来处理异常。在异常处理中，我们可以记录异常的数量。
- 使用CompletableFuture的allOf()方法等待所有异步操作完成。
- 使用filter()方法过滤出异常的CompletableFuture对象。
- 使用count()方法获取异常的数量。
下面是一个示例代码：
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;
public class CompletableFutureExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long exceptionCount = numbers.stream()
.parallel()
.map(number -> CompletableFuture.supplyAsync(() -> divideByZero(number))
.exceptionally(ex -> {
System.out.println("Exception occurred: " + ex.getMessage());
return null;
}))
.collect(Collectors.toList())
.stream()
.filter(CompletableFuture::isCompletedExceptionally)
.count();
System.out.println("Number of exceptions: " + exceptionCount);
}
private static int divideByZero(int number) {
return number / 0;
}
}在上面的示例中，我们创建了一个包含数字的列表。然后，我们将列表转换为并行流，并使用map()方法将每个数字映射为一个CompletableFuture对象。在CompletableFuture对象中，我们执行了一个会抛出异常的操作（除以0）。在异常处理中，我们打印了异常信息，并返回了null。
最后，我们使用filter()方法过滤出异常的CompletableFuture对象，并使用count()方法获取异常的数量。
请注意，这只是一个示例代码，用于演示如何使用CompletableFuture跟踪异步并行流中调用的异常数量。在实际应用中，您可能需要根据具体的业务需求进行适当的修改和调整。
推荐的腾讯云相关产品：腾讯云函数（SCF），腾讯云容器服务（TKE）
- 腾讯云函数（SCF）：https://cloud.tencent.com/product/scf
- 腾讯云容器服务（TKE）：https://cloud.tencent.com/product/tke
相关·内容
我有一个并行流，里面有一些数据库查询，如下所示：
private void processParallel() {
List\<Result\> = objects.parallelStream().peek(object -\> {
doSomething(object)
}
}
private void doSomething(object) {
CompletableFuture<String> param =
CompletableFuture.supplyAsync(() -> objectService.getParam(obj
浏览 5提问于2022-11-07得票数 0
2回答
有：
String getData(String key){
// Slow operation
}
CompletableFuture<String> getDataAsync(String key){
return CompletableFuture.supplyAsync(() -> getData(key));
}
以下几点有什么区别？
a)
keyStream.map(key -> getData(key));
b)
keyStream.map(key -> getDataAsync(key).join());
在这种情况下，使用异步有
浏览 3提问于2017-07-04得票数 0
原题：
OkHttp，有没有一种不依赖连接池的方法？
嘿，OkHttp用户和/或贡献者！
有没有一种没有任何连接池的使用OkHttpClient的方法？换句话说，是否有可能从调用myClient.execute()方法的同一个线程触发一个或几个HTTP请求？
我试着在网上找到一个清晰的答案，但我只找到了这些：
默认情况下使用连接池，因此我的理解是，HTTP请求总是从一个由OkHttp客户端实例化并保持活动的线程触发
可以在客户端级别配置自定义ExecutorService。理论上，我可以定义一个单独的线程执行程序，但无论如何，它会附带一个专用的额外线程(而不是调用堆栈中的父线程
浏览 17提问于2022-04-29得票数 0
2回答
从并行流捕获异常
、、、、
我有一堆来自csv文件的列作为字符串数组。现在我想解析它们。因为这种解析需要日期解析和其他不是很快的解析技术，所以我考虑了并行性(我对它进行了计时，这需要一些时间)。我的简单方法是：
Stream.of(columns).parallel().forEach(column ->
result[column.index] = parseColumn(valueCache[column.index], column.type));
列包含ColumnDescriptor元素，它只有两个属性，要解析的列索引和定义如何解析它的类型。没别的了。result是一个对象数组，它接受结果数组。
浏览 0提问于2017-03-27得票数 11
1回答
离开几年后，我又回到了Java，看到在新的java.net.http.HttpClient和AWS Java SDK 2.0中引入了非阻塞异步支持，我感到很兴奋。我在几年前的会议演讲中听说过响应式编程的概念，但没有太多机会将这些想法应用到实践中。 我有一个问题似乎非常适合使用这种编程风格:基本上，我想通过HTTP下载一堆文件(比方说10,000个)，并将它们写回S3。 我已经使用failsafe实现了非阻塞异步http GETs的重试，并且通过S3异步客户端(参见下面的草图)使用上传的重试是很简单的。 然而，我不确定如何恰当地限制程序的内存使用:如果文件下载的速度快于写回S3的速度，则没有机
浏览 15提问于2019-06-13得票数 3
回答已采纳
我们需要开发一种服务，应该能够处理高容量，即大约5TPS。我们必须做3-4个并行的下游rest调用(下面提到的是POC和2个rest调用) -->聚合所有响应-->做一些处理-->将响应发送回消费者。服务端点是同步的。 我正在尝试使用可完成的未来来做异步rest调用和连接方法来聚合响应，如下所示：{ ResponseWrapper response = null； CompletableFuture<Student> s = CompletableFuture.supplyAsync(() -> {
return s
浏览 19提问于2020-06-14得票数 0
我正在学习并尝试将CompletableFuture应用到我的问题陈述中。我有一个我正在迭代的项目列表。
Prop是一个只有两个属性prop1和prop2的类，分别是getter和setter。
List<Prop> result = new ArrayList<>();
for ( Item item : items ) {
item.load();
Prop temp = new Prop();
// once the item is loaded, get its properties
temp.setProp
浏览 25提问于2017-07-04得票数 0
回答已采纳
1回答
有一个卡夫卡集群，我从其中消费两个主题，并加入它。由于联接的结果，我对数据库做了一些操作。对DB的所有操作都是异步的，因此它们返回给我一个未来(scala.concurrent.Future，但无论如何它与java.util.concurrent.CompletableFuture相同)。因此，我得到了这样的代码：
val firstSource: KTable[String, Obj]
val secondSource: KTable[String, Obj2]
def enrich(data: ObjAndObj2): Future[EnrichedObj]
def saveResult
浏览 3提问于2017-02-15得票数 5
2回答
它们之间的区别是什么： List<String> parra = list.parallelStream()
.map(heavyPrcessingFunction)
.collect(Collectors.toList()); 这是(除了第二个有点复杂)： List<CompletableFuture<Void>> com = list.stream()
.map(x-> CompletableFuture.runAsync(() -> heavyPrcessingFunction.apply(x)))
.co
浏览 34提问于2019-09-07得票数 2
回答已采纳
public void executeAsync(Task task){
CompletableFuture.runAsync(
() -> {
task.execute(CompletableFuture.completedFuture(null), executor)
.exceptionally(
ex -> {
浏览 73提问于2020-01-18得票数 0
1回答
在spring boot应用程序中使用CompletableFuture时，我注意到在使用CompletableFuture异步运行的函数中发生了异常，但没有任何日志。函数执行停止，因此CompletableFuture已完成。为什么日志里什么都没有？当我在.runAsync中使用.whenComplete时，我能够记录错误。
void function() {
CompletableFuture
.runAsync(() -> runAsyncfunction())
.whenComplete((result, err) -> {//log the er
浏览 4提问于2021-11-04得票数 1
下面是我的代码：
final int startIndex = LoaderConstants.ServeiTerritorial.DEFAULT_START_INDEX;
final long pageSize = LoaderConstants.ServeiTerritorial.DEFAULT_PAGE_SIZE;
final String tableName = LoaderConstants.ServeiTerritorial.TIPUS_VIA_TABLE_NAME;
final String ownerType = LoaderConstants.ServeiTerritori
浏览 4提问于2021-07-21得票数 2
1回答
我希望提高后端REST在某个操作上的性能，该操作顺序地轮询多个不同的外部API，收集它们的响应，并将它们都压缩到一个响应列表中。
在刚刚了解到CompletableFuture之后，我决定尝试一下，并将该解决方案与只需将stream更改为parallelStream的解决方案进行比较。
下面是用于基准测试的代码：
package com.foo;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
imp
浏览 2提问于2019-12-03得票数 9
回答已采纳
我有多个可完成的未来，如：
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> xxx);
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> xxx);
List<CompletableFuture<Void>> futures = Lists.newArrayList(future1, future2);
当我在下面运行时，这两个未来的任务是否并行运行？异常会抛出一个未
浏览 0提问于2020-02-24得票数 2
回答已采纳
我正在使用 (与Netty一起)向RESTful API发出异步Http请求。由于我希望保留非阻塞行为，所以我将返回CompletableFuture<T>的实例，这是Http请求的结果。因此，在Json API端点返回Json数组的地方，我将返回一个CompletableFuture<T[]>。
然而，根据Erik对的分类，我认为Stream<T>更适合于发出异步Http请求并返回Json数组的方法的结果。在这种情况下，我们可以将Stream<T>看作是Observable<T>等效的，这是一个返回多个值的异步计算的结果。
因此，考
浏览 4提问于2016-05-23得票数 6
是否可以使用Java CompletableFutures在Kafka stream应用程序中执行并行工作？ 我想从1Kafka主题中读取，创建两个窗口计数，1分钟，另一个小时，但它们是并行的。 我写了一些示例代码。我能够让它工作，但是看一下Kafka流文档，因为KafkaStreams为每个分区分配一个任务，并且它不能超过一个线程，我不确定这个代码是否会有预期的效果。 CompletableFuture completableFutureOfMinute = CompletableFuture.runAsync(() -> {
inputStream.groupByK
浏览 38提问于2020-07-25得票数 0
回答已采纳
2回答
我正在使用一个可完成的未来来链接一系列异步操作，我想知道如何将其转换为使用RxJava，特别是使用Rxjava与CompletableFuture的好处是什么？
CompletableFuture cf = CompletableFuture.runAsync(() -> System.out.println("hello");
浏览 4提问于2017-05-07得票数 1
要并行或异步运行某些程序，我可以使用ExecutorService：<T> Future<T> submit(Runnable task, T result);或CompletableFuture Api:static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor); (假设我在这两种情况下都使用相同的执行器)
除了返回类型Future和CompletableFuture之外，还有什么显着的区别吗？或者什么时候使用什么？
如果我
浏览 3提问于2016-09-13得票数 49
回答已采纳
我必须运行多个外部调用操作，然后以列表的形式获得结果。我决定使用CompletableFuture api，我编写的代码非常令人作呕：
例子：
public class Main {
public static void main(String[] args) {
String prefix = "collection_";
List<CompletableFuture<User>> usersResult = IntStream.range(1, 10)
.boxed()
浏览 5提问于2017-10-30得票数 7
回答已采纳
3回答
如何使用5个CompletableFutures异步执行20个可运行任务(或1个任务20次)？
这就是我得到的：
Runnable task = () -> {
long startTime = System.currentTimeMillis();
Random random = new Random();
while (System.currentTimeMillis() - startTime < 3000) {
DoubleStream.generate(() -> random.nextDou
浏览 0提问于2018-04-15得票数 2
在CompletableFuture.supplyAsync()的生产环境中发现了一个问题，我们有一个批处理方法，如下所示：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
public class CompletableFutureProblem {
public voi
浏览 5提问于2020-11-21得票数 3
回答已采纳
3回答
我试图按计划在Spring中每5分钟运行一次异步方法，使用每次运行的100 threads.At结束来处理1000个任务，我需要知道有多少任务失败了&成功了。我尝试使用可完成的未来使用下面的示例代码，但我面临两个主要问题。
如果出现一些异常，则按计划重新启动而不完成运行。
如何在运行后获得成功/失败任务编号我想在最后打印成功任务:1、2、4、5失败任务:9、10、7、8
//ScheduledTask
public void processTask(){
List<CompletableFuture<Integer>> futures=new A
浏览 2提问于2022-03-15得票数 2
回答已采纳
我有一个场景，需要使用阻塞API向服务器发送100万条消息。API不接受批处理请求，所以我必须一个一个地发送1M消息。
我不使用一个线程，而是考虑使用多个线程来发送它们。
调用方必须等待所有100万条消息才能继续发送。
我的执行情况如下：
public class MySender {
private final MyPublisher myPublisher;
private final ExecutorService threadPool;
private final Map<String, List<CompletableFuture<Void&
浏览 3提问于2021-09-23得票数 0
当我尝试在Axon中使用CompletableFuture时，我遇到了一些问题。例如：
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
log.info("Start processing target: {}", target.toString());
return new Event();
}, threadPool);
future.thenAcceptAsync(event -> {
浏览 2提问于2018-10-22得票数 1
回答已采纳
2回答
我有以下现有的实现
CompletableFuture<Employee>[] employeeDetails =
empIds.stream().map(empId ->
employeeService.employeeDetails(Integer.valueOf(empId)))
.filter(Objects::nonNull)
.toArray(CompletableFuture[]::new);
在这段代码中，我需要在HashMap中检查empId是否已经存在，
浏览 0提问于2019-01-03得票数 4
我正在阅读java8 in action，第11章(关于CompletableFutures)，这让我开始思考我公司的代码库。
Java8in action book说，如果你有像我写在下面这样的代码，你一次只会使用4个CompletableFuture(如果你有一台4核的计算机)。这意味着如果您想异步执行例如10个操作，您将首先运行前4个CompletableFuture，然后运行第二个4个，然后运行剩下的2个，因为默认的ForkJoinPool.commonPool()只提供与Runtime.getRuntime().availableProcessors()相等的线程数量。
在我公司的代
浏览 38提问于2018-06-11得票数 4
回答已采纳
我第一次使用可完成的未来。我没有收到任何错误，但想了解我是否正确地使用它。
CompletableFuture<HashMap<String, String>> completableFuture = new CompletableFuture<>();
for (int iterator = 0; iterator < 10; iterator = iterator + 1)) {
int finalIterator = iter
浏览 16提问于2022-12-02得票数 0
例如，Java的handleAsync不会处理不来自完成阶段的异常：
package my.package;
import java.util.concurrent.CompletableFuture;
public class Test {
private CompletableFuture<String> throwWithoutCompletionStage() {
throw new RuntimeException("error");
}
private CompletableFuture<String> getNa
浏览 4提问于2022-10-04得票数 0
回答已采纳
我正在尝试找出实现以下目标的最佳方法。
我有一个web服务，它将由web应用程序中的页面调用。服务本身最多需要在一两秒内返回结果，以保持页面可用。
该服务将需要调用至少12个单独的服务来累积所需的数据，然后将其聚合以交付到页面。
我正在考虑使用具有并行活动的WF4来管理多个服务调用。
我的问题是，这在实践中是否可行，或者呼叫是否会以某种方式排队，因为同时运行的呼叫太多了？
如果可以的话，我真的不想把它变成一个批处理过程。
浏览 0提问于2010-06-21得票数 0
回答已采纳
2回答
我的代码中有几个可完成的未来。在一个可完成的未来中，我想要另一个可完成的未来(在可完成的未来中的可完成的未来)。
public CompletableFuture<List<Employee>> buildEmployee (List<EmployeeResponse> employeeInfo) {
return supplyAsync(() -> {
Map<String, List<EmployeeReward>> rewards = rewards(employeeInfo);
浏览 4提问于2019-09-18得票数 1
我刚刚开始研究Java的，对它是真正的异步(即并发运行在一个线程上)还是跨多个线程(并行)有点困惑。
例如，假设我想调用1000个不同的服务。进一步假设每个服务调用都可以异步进行。当使用CompletableFuture时，JVM是制造1000个单独的线程(假设JVM允许这么多线程)，还是在一个线程中执行所有这些请求？还是两者兼而有之？使用一些线程异步执行这些请求？
我想做的是这样的事情(在Python中)：
有方法异步地在同一个线程上执行多个请求/操作吗？
浏览 3提问于2017-07-31得票数 10
回答已采纳
1回答
我正在测试CompletableFuture是如何工作的。我对如何并行执行任务感兴趣：
try {
CompletableFuture one = CompletableFuture.runAsync(() -> {
throw new RuntimeException("error");
});
CompletableFuture two = CompletableFuture.runAsync(() -> System.out.println("2"));
浏览 0提问于2019-03-23得票数 2
回答已采纳
我想连锁一个CompletableFuture，这样它就会在处理过程中发出扇子。我的意思是，对于一个列表，我有一个开放的CompletableFuture，我想对列表中的每一项应用一个计算。
第一步是调用m_myApi.getResponse(request，executor)，它发出异步调用。
异步调用的结果有一个getCandidates方法。我想并行分析所有这些候选人。
目前，我的代码依次解析它们。
public CompletableFuture<List<DOMAIN_OBJECT>> parseAllCandidates(@Nonnull final REQ
浏览 0提问于2018-10-25得票数 5
回答已采纳
1回答
我已经创建了一个实现异步重试模式的方法。实际上，我希望当我调用此方法时，请求应该在单独的线程中处理，并且应该延迟重试
private <R> CompletableFuture<R> withRetryRequest(Supplier<CompletableFuture<R>> supplier, int maxRetries) {
CompletableFuture<R> f = supplier.get();
for (int i = 0; i < maxRetries; i++) {
浏览 0提问于2020-05-06得票数 0
1回答
我在F#中看到了一些将异步与并行相结合的例子。下面是一个MSDN示例：，这难道不是线程的低效使用吗？为什么要在许多可能长时间运行的IO类型操作中使用新线程。这难道不就是创建只会坐在那里等待的线程吗？
浏览 1提问于2014-09-25得票数 2
回答已采纳
2回答
如何以函数式风格编写以下代码？我想链式执行返回CompletableFuture的方法(即playRound返回CompletableFuture<Void>)
CompletableFuture<Void> current = CompletableFuture.completedFuture(null);
for (int i = 1; i <= rounds; i++) {
final int t = i;
current = current.thenCompose(it -> playRound(t));
}
return curr
浏览 0提问于2019-08-11得票数 2
我有一个问题，循环中的CompletableFuture任务不是并行运行的，而是同步运行的：
List<List<File>> filesLists = divideArrayIntoChunks(Arrays.asList(filesArray), 10);
// number of tasks
int numberOfTasks = filesLists.size();
List<CompletableFuture<TreeMap<String, HashMap<String, Intege
浏览 0提问于2020-11-22得票数 1
我正在为如何和何时完成可完成的未来而挣扎。我创建了这个测试用例：
import org.junit.Test;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.stream.Stream;
imp
浏览 0提问于2018-05-16得票数 3
回答已采纳
我注意到在Java8中使用流的CompleteableFutures有一些不寻常的行为。
String [] arr = new String[]{"abc", "def", "cde", "ghj"};
ExecutorService executorService = Executors.newFixedThreadPool(10);
List<String> lst =
Arrays.stream(arr)
浏览 0提问于2019-07-03得票数 1
1回答
我试图在java 8中学习并发性和lambda，但是我的代码并没有在map中输入lambda块。
List<Book> bookList = new ArrayList<Book>();
isbnList
.stream()
.map(isbn -> (CompletableFuture.supplyAsync( () -> {
try {
List<String> pageContents = getUrlContents(webLink + isbn);
浏览 1提问于2016-11-02得票数 4
回答已采纳
关于CompletableFuture方法，我有一个问题：
public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)
问题是，JavaDoc说的就是：
返回一个新的CompletionStage，当此阶段正常完成时，将该阶段的结果作为提供的函数的参数执行。有关异常完成的规则，请参阅CompletionStage文档。
那线程呢？这将在哪个线程中执行？如果将来是由线程池完成的呢？
浏览 3提问于2017-09-05得票数 49
回答已采纳
我正试图在CompletableFuture上给CompletableFuture打电话。
从医生的角度看：
如果尚未完成，则使用一个CompletableFuture完成此CancellationException。尚未完成的依赖CompletableFutures也将在特殊情况下完成，由此CancellationException引起的CompletionException也将完成。
它应该异常地完成它们--这正是我所期望的--但是相反，它抛出并立即执行CancellationException。
下面是一个示例代码
CompletableFuture<?> f = C
浏览 6提问于2021-09-02得票数 0
回答已采纳
给定一些任意的上下文(例如，Junit测试，不一定是特定的“主”线程)。
这样的代码必须至少引入两个线程吗？
public static void main (String[] args)
{
CompletableFuture<Void> s = new CompletableFuture<>();
CompletableFuture<Void> f = new CompletableFuture<>();
CompletableFuture<Void> someContext = Complet
浏览 3提问于2021-06-24得票数 7
回答已采纳
我第一次尝试创建一个异步调用。我偶然发现了CompletableFuture CompletableFuture因此，我尝试了以下几点：
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class test {
public static void main(String[] args) throws InterruptedException, ExecutionException {
浏览 4提问于2020-09-08得票数 1
2回答
假设我有这个Java代码，它异步地执行一些任务：
public String main() {
try {
// Code before that could throw Exceptions
CompletableFuture.runAsync(() -> {...});
// Code after that could throw Exceptions
} catch (SomeException e) {
// ...
} catch (CompletionException e) {
浏览 0提问于2018-06-06得票数 0
回答已采纳
1回答
期货上市最有效的方式
、、、、
我通过一个对象列表调用异步客户端方法。该方法返回未来。
在调用后返回的期货列表中，什么是最好的迭代方式(以便处理那些最先出现的期货)？
注意:异步客户端只返回未来，而不是CompletableFuture。
以下是守则：
List<Future<Object>> listOfFuture = objectsToProcess.parallelStream()
.map((object) -> {
/* calling an async client returning a Future<Object> */ })
.co
浏览 1提问于2017-04-05得票数 8
回答已采纳
1回答
请看下面的类，建议使用哪一个，以及它们有什么不同？
// Approach 1
public class Test extends Controller {
private final DatabaseExecutionContext executionContext;
@Inject
public Test(DatabaseExecutionContext executionContext) {
this.executionContext = executionContext;
}
public CompletableFuture&
浏览 2提问于2019-12-27得票数 3
我有以下代码：
return CompletableFuture.supplyAsync(() -> {
return foo; // some custom object
})
.thenAccept(foo -> {
// ??? need to spawn N async parallel jobs that works on 'foo'
});
第一个任务异步创建foo对象，然后我需要在它上运行N个并行进程。
那么，是否有更好的方法来做到这一点：
...
CompletableFuture[] parallel = new Completa
浏览 4提问于2016-06-15得票数 3
回答已采纳
对于下面的程序，我试图弄清楚为什么使用两个不同的流并行任务，使用相同的流并在可完成的未来调用join/get使它们花费更长的时间，就好像它们是按顺序处理的一样)。
public class HelloConcurrency {
private static Integer sleepTask(int number) {
System.out.println(String.format("Task with sleep time %d", number));
try {
TimeUnit.SECONDS.sleep
浏览 6提问于2019-11-04得票数 7
回答已采纳
如何将阻塞方法调用“转换”为？示例：
T waitForResult() throws InterruptedException {
obj.await(); // blocking call
// ...
return something;
}
我需要把它变成这样：
CompletableFuture.of(this::waitForResult); // .of(Callable<T>) doesn't exist
有些事情需要考虑：
waitForResult()可能引发异常。必须正确处理这些问题，这样completableFuture.g
浏览 2提问于2019-06-07得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
