本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Android AIDL是实现进程间通信（IPC）的关键技术，允许Android应用间共享服务。通过定义接口、支持特定的数据类型和管理数据流向，开发者可以构建强大的多进程交互功能。本文将详细指导如何通过AIDL文件定义接口、生成代理类和实现服务端逻辑，以及如何处理跨进程通信中的异常。此外，还将探讨二层树形数据结构的实现方式，例如递归和Adapter模式，以及如何将这两种技术结合到实际的Android应用开发中。 android aidl

1. Android AIDL进程间通信（IPC）基础

Android 进程间通信（IPC）是应用程序组件之间交互的一种机制。而AIDL（Android Interface Definition Language）作为Android平台提供的一种接口描述语言，允许在不同的进程之间进行方法调用。AIDL的设计初衷是为了让开发人员能够更简单地实现跨进程通信。

要使用AIDL，首先需要理解其基础概念。AIDL通过定义接口文件来实现跨进程的方法调用。AIDL文件被编译成Java类，这些类由Android系统加载和管理。利用这些机制，客户端可以通过绑定服务的方式与服务端通信。

在实际开发过程中，开发者需要通过创建AIDL文件定义服务端的接口和方法，然后实现这些接口。客户端则通过绑定服务来调用服务端方法，进而实现跨进程的数据交换。接下来的章节我们将深入介绍AIDL接口与方法的定义和实现、AIDL文件的创建编译、服务端和客户端的具体实现方式以及如何进行优化和最佳实践。

2. AIDL接口与方法的定义和实现

2.1 定义AIDL接口及方法

2.1.1 AIDL接口的声明和方法签名

Android接口定义语言（AIDL）是一种允许你在不同进程间进行通信的接口描述语言。AIDL接口定义了客户端和服务端之间的通信契约。在AIDL文件中，我们首先需要声明接口名称和方法签名，以便服务端和客户端遵循相同的通信规则。

以下是一个简单的AIDL接口声明示例：

// IBookManager.aidl
package com.example.ipc;
interface IBookManager {
    void addBook(in Book book);
    List<Book> getBooks();
}

在这个例子中， IBookManager 是一个AIDL接口， addBook 方法接收一个 Book 对象作为输入参数， getBooks 方法返回一个 Book 对象列表。 in 关键字表示参数是输入参数，AIDL中的参数默认是双向的，即既可以作为输入也可以作为输出，除非明确指定为 in 或 out 。

2.1.2 接口方法参数和返回值的规则

在定义AIDL接口方法时，需要遵循一系列特定的规则：

  • 所有的AIDL方法都不能有 void 返回值，因为跨进程调用需要返回某种形式的结果。
  • 只能使用原始数据类型、声明在AIDL中的自定义对象、 List 和 Map （其中元素类型也必须是可序列化的）作为参数和返回值。
  • 所有非原始类型的参数和返回值都必须标记为 in 、 out 或 inout 。 in 表示输入参数， out 表示输出参数， inout 表示输入输出参数。
  • 参数和返回值必须实现 Parcelable 接口，以便在进程间传输。

2.2 支持的数据类型与映射机制

2.2.1 基本数据类型在AIDL中的使用

基本数据类型（如int、long、boolean等）在AIDL中可以直接使用，无需任何特殊处理。这是因为基本数据类型在Java中自带序列化和反序列化的功能。

2.2.2 集合类型List和Map在AIDL中的应用

集合类型在AIDL中通过 List 和 Map 进行封装。需要注意的是，这些集合类型只能包含可序列化的数据。例如，List只能包含 Book 类型的数据，而Map的键（key）和值（value）也必须是可序列化的。

// ILibrary.aidl
package com.example.ipc;
import com.example.ipc.Book;
interface ILibrary {
    List<Book> getAvailableBooks();
    void addBooks(in List<Book> books);
    Map<String, Book> getBookMap();
}

在这个例子中， getAvailableBooks 方法返回一个 Book 对象的列表， addBooks 方法接收一个 Book 对象列表作为输入参数，而 getBookMap 方法返回一个键值对映射，其中键是 String 类型，值是 Book 类型。

2.2.3 自定义类型和泛型的处理

自定义类型需要实现 Parcelable 接口，以确保它们可以在进程间传输。当使用泛型时，泛型类型参数必须限定为 Parcelable 或其他实现了 Parcelable 接口的类型。这是因为在AIDL中，系统需要能够序列化和反序列化数据。

// Book.java
package com.example.ipc;
import android.os.Parcel;
import android.os.Parcelable;
public class Book implements Parcelable {
    private String title;
    private String author;
    // Implement Parcelable methods
}

在上面的代码中， Book 类实现了 Parcelable 接口。这样， Book 对象就可以在AIDL文件中被用作参数或返回值类型。

以上，我们已经讨论了AIDL接口及方法的定义和实现的基础知识。在下一节中，我们将深入了解如何创建AIDL文件并编译它们以生成Java接口，并探讨如何在服务端实现这些接口。

3. AIDL文件的创建、编译与服务端实现

AIDL（Android Interface Definition Language）是一种用于进程间通信（IPC）的接口定义语言，它允许在不同进程的应用程序之间进行接口调用。AIDL工作在Android的Binder IPC机制之上，可以让不同应用程序之间进行数据交换和方法调用。本章节将详细介绍AIDL文件的创建、编译过程以及服务端的实现与绑定。

3.1 AIDL文件的创建与编译过程

3.1.1 如何创建AIDL文件和声明接口

创建AIDL文件是使用AIDL进行跨进程通信的第一步。开发者需要遵循AIDL的语法规则来定义一个接口。通常，AIDL文件扩展名为 .aidl ，包含了接口声明以及方法签名。

  1. 在Android Studio中，右键点击项目中的 src 目录下的 main 文件夹下的 aidl 目录，选择 New > AIDL 。
  2. 输入包名后，选择或创建一个AIDL文件，例如创建一个名为 IMyService.aidl 的文件。
  3. 在AIDL文件中声明接口及其方法，例如：
package com.example.myservice;

// Declare any non-default types here with import statements

interface IMyService {
    /** Called from the client to ping the service */
    void ping();
}

3.1.2 AIDL文件的编译和生成Java接口

在定义了 .aidl 文件之后，Android构建系统会自动处理这些文件，编译成标准的Java接口，这些接口文件会存放在 build/generated/source/aidl/debug 目录下。编译过程如下：

  1. 在Android Studio中，当项目构建时，AIDL文件会被编译成Java接口。
  2. 该接口继承自 android.os.IInterface 。
  3. 构建过程还会生成一个Stub类，用于服务端实现接口方法和客户端代理调用。

3.2 服务端接口的实现与绑定

3.2.1 实现服务端接口的步骤和要求

服务端接口的实现是通过编写一个继承自 Service 的类，并实现AIDL文件生成的接口。以下是实现AIDL接口服务端的步骤：

  1. 创建一个继承自 Service 的类，例如 MyService 。
  2. 实现AIDL接口，例如 IMyService.Stub 类。
  3. 在 onBind() 方法中返回 IMyService.Stub 的实例。
public class MyService extends Service {
    private final IMyService.Stub mBinder = new IMyService.Stub() {
        @Override
        public void ping() {
            // 实现ping()方法的具体逻辑
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

3.2.2 服务的绑定和注册流程

服务端需要在AndroidManifest.xml中注册服务，并提供绑定服务的方法。以下是注册和绑定服务端的流程：

  1. 在 AndroidManifest.xml 中声明服务：
<service android:name=".MyService">
    <intent-filter>
        <action android:name="com.example.myservice.IMyService" />
    </intent-filter>
</service>
  1. 客户端通过 bindService() 方法绑定服务：
Intent intent = new Intent(this, MyService.class);
bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
  1. 在客户端中定义 ServiceConnection 以接收服务绑定结果：
private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName className, IBinder service) {
        IMyService myService = IMyService.Stub.asInterface(service);
        // 使用myService进行跨进程调用
    }

    @Override
    public void onServiceDisconnected(ComponentName arg0) {
        // 处理服务断开连接的逻辑
    }
};

本章节通过具体的代码示例和逻辑分析，阐述了AIDL文件的创建和编译过程，以及服务端接口的实现和绑定流程。通过这种方式，开发者可以在Android系统中实现高效且稳定的跨进程通信机制。在下一章节中，我们将深入探讨客户端如何进行跨进程方法调用以及异常处理的相关内容。

4. 客户端跨进程方法调用与异常处理

4.1 客户端跨进程方法调用机制

4.1.1 客户端如何绑定服务和调用方法

在Android系统中，客户端进行跨进程通信时，首先要绑定远程服务。这一过程类似于在本地绑定服务，但涉及到IPC机制。以下是客户端绑定远程服务和调用方法的基本步骤：

  1. 创建一个 Intent ，指定目标服务的名称。
  2. 使用 bindService() 方法绑定远程服务。这通常需要一个 ServiceConnection 对象，以便在服务成功绑定或者绑定失败时接收回调。
  3. 在 ServiceConnection 的 onServiceConnected() 方法中，客户端会收到一个 IBinder 对象，它是跨进程通信的桥梁。
  4. 利用这个 IBinder 对象，客户端可以将其转换为对应的AIDL代理类，然后就可以调用服务中定义的AIDL方法了。
  5. 当服务不再需要时，客户端应调用 unbindService() 方法来断开与服务的连接。

下面是一个简单的示例代码，展示客户端绑定服务和跨进程调用方法的过程：

// 创建绑定服务的Intent
Intent intent = new Intent(this, MyAidlService.class);
// 绑定服务
bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);

// ServiceConnection实现
private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName className, IBinder service) {
        // 将IBinder转换为AIDL代理类
        IMyAidlInterface myAidlInterface = IMyAidlInterface.Stub.asInterface(service);
        try {
            // 调用跨进程方法
            String result = myAidlInterface.doRemoteWork("input data");
            Log.d(TAG, "Result from remote service: " + result);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName arg0) {
        myAidlInterface = null;
    }
};

4.1.2 跨进程通信的过程和细节

跨进程通信的过程可以分解为以下几个关键步骤：

  1. 服务端注册AIDL接口 ：服务端首先定义AIDL接口并实现该接口的方法。然后通过某种方式将接口暴露给客户端，这通常是通过 Service 组件实现。
  2. 客户端获取服务代理 ：当客户端绑定到服务端后，服务端会返回一个 IBinder 对象，客户端通过它来访问远程服务。
  3. 转换代理对象 ：客户端将收到的 IBinder 对象转换成对应的AIDL代理对象。这允许客户端调用代理对象的方法，就像调用本地方法一样。
  4. IPC机制激活 ：调用代理对象的方法时，Android系统将介入，通过IPC机制将调用从客户端进程转发到服务端进程。
  5. 执行远程方法 ：服务端接收到调用请求后，执行相应的远程方法。处理完毕后，将结果返回给客户端。
  6. 处理异步操作 ：跨进程方法调用通常是异步的。这意味着客户端发起调用后，会继续执行其他操作，直到结果返回。

在实际的跨进程通信中，细节问题可能包括网络延迟、序列化和反序列化数据、异常处理等。开发者需要关注这些细节，确保应用的性能和稳定性。

4.2 跨进程通信异常处理

4.2.1 常见的跨进程通信异常及处理

在进行跨进程通信时，可能会遇到各种异常情况，如网络错误、服务不可用、接口版本不匹配等。在Android中，这些异常通常以 RemoteException 的形式表现。因此，客户端需要正确处理这些异常，以避免应用崩溃或其他不良影响。以下是一些常见的异常及其处理方式：

  • RemoteException ：这是最常见的跨进程通信异常，发生在客户端尝试调用远程方法时。由于IPC机制异常，如Binder线程池耗尽，导致调用失败。处理方式通常是捕获这个异常，并给用户合理的反馈。

  • DeadObjectException ：当服务进程崩溃或被杀死时，客户端尝试调用远程方法，会抛出此异常。开发者可以检查服务状态，并在必要时重新绑定服务。

  • TransactionTooLargeException ：当传递给远程方法的数据太大时，会抛出此异常。开发者应该检查传递的数据，确保它们不会超出IPC机制的大小限制。

下面的代码展示了如何在客户端处理 RemoteException ：

try {
    String result = myAidlInterface.doRemoteWork("input data");
} catch (RemoteException e) {
    // 处理跨进程通信异常
    Log.w(TAG, "RemoteException occurred");
    e.printStackTrace();
    // 根据需要执行错误恢复或反馈给用户
}

4.2.2 客户端与服务端的异常同步机制

在客户端与服务端进行交互时，异常处理需要双方协作，以确保错误信息能够准确同步。这通常涉及到两个方面：

  1. 服务端异常反馈 ：服务端应当记录异常，并且在合适的情况下，将其返回给客户端。例如，在远程方法执行失败时，服务端可以返回一个错误代码或者抛出一个自定义异常。

  2. 客户端异常捕获和处理 ：客户端在调用远程方法时，需要有适当的异常捕获机制，并且在捕获到异常时能够进行正确的处理，比如提示用户、重试或者记录日志。

开发者可以创建自定义异常类，通过AIDL接口传递，服务端在发生错误时可以返回这个自定义异常。客户端在接收到异常后，根据异常的类型和内容来进行相应处理。

表格：跨进程通信异常类型及其处理方法

| 异常类型 | 发生条件 | 处理方法 | |--------------------------|----------------------------------------------------------|--------------------------------------------------------| | RemoteException | 远程方法调用过程中的任何异常都可能导致此异常 | 捕获异常，记录日志，给用户合理反馈 | | DeadObjectException | 远程服务不存在或已经停止 | 检查服务状态，必要时重新绑定服务 | | TransactionTooLargeException | 远程方法调用时传递的数据包太大 | 检查数据，确保不超出大小限制，或通过其他方式进行数据传输 | | ServiceNotFoundException | 客户端尝试绑定一个不存在的服务 | 显示错误提示，给用户正确的操作建议 |

在设计跨进程通信机制时，开发者应当考虑到以上异常情况，通过合理的错误处理和日志记录，保证应用的稳定性和用户体验。

mermaid格式流程图：跨进程通信异常处理流程图

graph LR
    A[开始调用远程方法]
    A --> B{是否捕获异常}
    B -->|是| C[记录异常信息]
    B -->|否| D[继续正常处理]
    C --> E[反馈给用户]
    D --> F[方法调用成功]

在以上流程图中，清晰地表示了当客户端尝试调用远程方法时，如何通过判断是否捕获异常来进行不同的处理。这种处理机制保证了在发生错误时能够及时地响应并采取相应措施。

5. 树形数据的展示与AIDL的结合应用

树形数据结构是一种广泛应用于软件工程中的数据结构，它能够以层次化的方式组织和表示具有层级关系的信息。在Android系统中，AIDL（Android Interface Definition Language）用于在不同进程间进行通信。当树形数据结构需要在进程间传递时，就需要考虑如何将这种复杂的数据结构通过AIDL进行序列化和反序列化。这一章节将深入探讨树形数据的展示方法，以及如何与AIDL结合应用。

5.1 树形数据的展示方法

在讨论如何将树形数据与AIDL结合之前，我们首先要了解如何在Android应用中展示树形数据。

5.1.1 使用递归方法构建树形结构

树形结构的一个关键特点就是递归。每一个节点除了包含数据外，还可能包含指向其他节点的指针或引向。递归方法是构建树形结构的一种自然选择，因为它可以简洁地反映出树的递归定义。

class TreeNode {
    private int data;
    private List<TreeNode> children;

    public TreeNode(int data) {
        this.data = data;
        this.children = new ArrayList<>();
    }

    public void addChild(TreeNode child) {
        children.add(child);
    }

    public int getData() {
        return data;
    }

    public List<TreeNode> getChildren() {
        return children;
    }
    public TreeNode getChildAt(int index) {
        return children.get(index);
    }
    public int getChildCount() {
        return children.size();
    }
}

public class TreeHelper {
    public TreeNode buildTree(List<Integer> flatList, int parentId) {
        TreeNode node = new TreeNode(flatList.get(0));
        List<TreeNode> nodesToBeAdded = new ArrayList<>();
        nodesToBeAdded.add(node);
        int currentIndex = 1;
        while (currentIndex < flatList.size()) {
            TreeNode currentNode = nodesToBeAdded.get(0);
            TreeNode childNode = new TreeNode(flatList.get(currentIndex));
            currentNode.addChild(childNode);
            nodesToBeAdded.add(childNode);
            if (currentIndex % 2 == 1 || currentIndex == flatList.size() - 1) {
                nodesToBeAdded.remove(0);
            }
            currentIndex++;
        }
        return node;
    }
}

5.1.2 利用Adapter模式展示树形数据

在Android的UI组件中，ListView或RecyclerView常用于展示列表数据。树形数据结构并不直接适用于这些组件，因此我们需要将其扁平化，即转换为一个列表，然后通过Adapter模式填充到UI组件中。

public class TreeAdapter extends RecyclerView.Adapter<TreeAdapter.ViewHolder> {
    private TreeNode root;
    private List<TreeNode> flatData;

    public TreeAdapter(TreeNode root) {
        this.root = root;
        this.flatData = convertTreeToList(root);
    }

    private List<TreeNode> convertTreeToList(TreeNode root) {
        List<TreeNode> list = new ArrayList<>();
        list.add(root);
        for (int i = 0; i < root.getChildCount(); i++) {
            list.addAll(convertTreeToList(root.getChildAt(i)));
        }
        return list;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        // Create a new view, which defines the UI of the list item
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        // Bind data to the view
    }

    @Override
    public int getItemCount() {
        return flatData.size();
    }

    public class ViewHolder extends RecyclerView.ViewHolder {
        // Your views here
    }
}

5.2 AIDL与树形结构数据的结合应用

当树形结构需要在不同的进程间进行传递时，AIDL提供了一种方式来实现跨进程的数据传输。

5.2.1 AIDL处理复杂数据结构的能力

AIDL支持基本数据类型、String、List、Map和声明在AIDL文件中的自定义类型。对于树形结构数据，可以通过递归的方式实现序列化和反序列化。

// TreeData.aidl
package com.example.ipc;
import java.util.List;

interface TreeData {
    List<TreeNode> getTree();
}

// TreeNode.aidl
package com.example.ipc;
import java.util.List;

interface TreeNode {
    int getData();
    List<TreeNode> getChildren();
}

// TreeData.aidl (扩展版本)
package com.example.ipc;
import java.util.List;

interface TreeData {
    List<INode> getTree();
}

// INode.aidl
package com.example.ipc;
import java.util.List;

interface INode {
    int getData();
    List<INode> getChildren();
}

5.2.2 实际案例分析：树形数据在AIDL中的应用

假设有一个树形结构的联系人列表需要跨进程传递给另一个应用进行处理。我们可以定义AIDL接口来序列化和反序列化树形数据。

public class IPCContactTree {
    private ITreeData treeDataStub;
    private INode remoteRoot;

    // Server端的实现
    public void setupAidlService() {
        remoteRoot = createRootNode(1, "Root");
        treeDataStub = TreeDataAidlService.bindService();
        treeDataStub.setTree(remoteRoot);
    }

    private INode createRootNode(int id, String name) {
        INode rootNode = new Node.Stub() {
            @Override
            public int getData() {
                return id;
            }

            @Override
            public List<INode> getChildren() {
                // 生成子节点列表并返回
            }
        };
        // 设置根节点的数据和子节点
        return rootNode;
    }
}

// Client端的实现
public class IPCContactTreeClient {
    private ITreeData treeDataService;

    public void fetchTreeData() {
        treeDataService = TreeDataAidlService.bindService();
        List<INode> treeList = treeDataService.getTree();
        TreeNodeAdapter adapter = new TreeNodeAdapter(treeList);
        recyclerView.setAdapter(adapter);
    }
}

在上述案例中，我们定义了 ITreeData 和 INode 两个AIDL接口，分别用于获取和表示树形数据。服务端实现这些接口，而客户端通过绑定服务来获取树形数据，并通过自定义的 TreeNodeAdapter 将其展示在UI组件中。在AIDL文件中，我们使用了接口的方式替代了直接类引用的方式，以适应AIDL的跨进程通信机制。

树形数据的展示与AIDL的结合应用是一个复杂的主题，涉及到数据结构的理解、UI展示的技巧以及AIDL跨进程通信的实现。通过本章节的介绍，你不仅能够掌握树形数据结构的展示方法，还能够将其与AIDL结合，实现进程间复杂的树形数据传递。

6. AIDL高级技巧与最佳实践

6.1 AIDL的优化策略

在Android开发中，AIDL是一种常用的跨进程通信IPC方式，但如果处理不当，可能会导致性能问题。因此，在开发中需要注意以下几个优化策略：

6.1.1 提高跨进程通信效率的方法

  • 减少频繁的跨进程通信 ：频繁的IPC调用会带来显著的性能开销，尤其是在UI线程中进行IPC通信会直接影响到用户界面的响应。因此，应尽量减少或避免在UI线程中进行跨进程通信。

  • 批量传递数据 ：对于需要传递大量数据的场景，使用List、Map等集合类型可以一次性传递多个数据项，这样可以减少通信次数，提高效率。

  • 使用binder pool ：如果服务端需要同时支持多个AIDL接口，可以实现一个binder pool来复用binder线程，这样可以提高服务端的效率。

6.1.2 如何减少AIDL接口的性能开销

  • 避免在AIDL接口中传递大的数据对象 ：大的数据对象会增加序列化和反序列化的开销，尽可能传递基本数据类型或者较小的对象。

  • 实现oneway方法 ：在方法声明前加上oneway关键字可以让服务端的方法变为单向调用，调用方不再等待服务端的响应，这样可以减少等待时间和提升性能。

  • 合理使用线程池 ：对于服务端需要进行耗时操作的方法，可以通过线程池异步执行，避免阻塞服务端主线程，提升服务端的响应能力。

6.2 AIDL应用的最佳实践

AIDL在实际应用中需要结合具体的场景来设计和实现，下面是一些AIDL应用的最佳实践：

6.2.1 设计高效AIDL接口的经验分享

  • 合理定义接口方法 ：AIDL接口中的方法需要精心设计，以减少不必要的跨进程通信。例如，可以设计一些批量处理的方法，从而减少通信次数。

  • 接口版本兼容 ：在设计AIDL接口时，要考虑未来可能的变更，提前设计好接口的升级策略。例如，为每个方法的变更预留足够的参数空间，或者设计能够兼容新旧版本的代理方法。

6.2.2 解决实际开发中遇到的疑难问题

  • 解决死锁问题 ：在进行跨进程通信时，尤其是在多线程环境下，可能会遇到死锁问题。合理地管理线程和锁，确保在进行跨进程通信时能够及时释放资源，是避免死锁的关键。

  • 维护服务的稳定性 ：服务端在处理跨进程请求时，要保证服务的稳定性和容错性。可以通过重试机制、超时设置等方式，保证服务的可靠性。

在实际开发中，AIDL提供了一种强大的机制来实现复杂的数据结构和高级的IPC策略，但同时也需要开发者具备深入的了解和丰富的实践经验。通过优化策略和最佳实践的应用，可以有效地提升AIDL在项目中的性能和稳定性。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：Android AIDL是实现进程间通信（IPC）的关键技术，允许Android应用间共享服务。通过定义接口、支持特定的数据类型和管理数据流向，开发者可以构建强大的多进程交互功能。本文将详细指导如何通过AIDL文件定义接口、生成代理类和实现服务端逻辑，以及如何处理跨进程通信中的异常。此外，还将探讨二层树形数据结构的实现方式，例如递归和Adapter模式，以及如何将这两种技术结合到实际的Android应用开发中。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

Logo
永洪数据分析社区

永洪科技，致力于打造全球领先的数据技术厂商，具备从数据应用方案咨询、BI、AIGC智能分析、数字孪生、数据资产、数据治理、数据实施的端到端大数据价值服务能力。

更多推荐

cover

【PostgreSQL数据分析实战：从数据清洗到可视化全流程】4.4 异构数据源整合（CSV/JSON/Excel数据导入）

avatar 永洪数据分析社区
cover

大数据面试问答-数据湖

avatar 永洪数据分析社区
cover

Vue3携手Echarts，打造炫酷数据可视化大屏

avatar 永洪数据分析社区