Android 自定义SO库使用及方法调用详解

周不宅

于 2025-06-11 16:12:02 发布

阅读量1.2k

点赞数 24

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/weixin_35972981/article/details/148615200

本文还有配套的精品资源，点击获取

简介：在Android应用开发中，利用NDK创建自定义SO库能够实现Java与C/C++语言间的高效交互。本教程通过TestDemo示例，详细介绍从环境配置到构建、加载和调用自定义SO库的完整过程。内容包括设置NDK环境、创建jni目录与源文件、编写Android.mk配置、生成.so文件，以及Java层中加载和调用本地库的方法。通过实践操作，开发者能深入理解并掌握在Android中使用自定义库的技术要点，确保跨语言交互的顺畅和应用性能的优化。 android 自定义so库使用与方法调用demo

1. NDK环境配置

在进行跨平台开发或是需要使用本地语言进行优化时，Android NDK（Native Development Kit）就显得尤为重要。配置NDK环境是开发过程中不可避免的一步。本章将带您深入了解如何设置NDK环境，以确保后续开发过程的顺畅。

首先，NDK环境的配置主要包含以下几个步骤：

下载并安装适用于您操作系统的NDK版本。
将NDK的工具链路径添加到系统的环境变量中，使得可以在命令行中调用NDK工具。
验证安装是否成功，通过在命令行输入 ndk-build 或 ndk-gdb 等指令来检查。

接下来，我们还需要确认和设置相关的环境变量，以便在进行项目构建时，能够正确地找到NDK的执行文件和库文件。通常，环境变量的配置可以通过修改用户目录下的 .bash_profile （Linux或MacOS）或 .bashrc （Windows）等配置文件来实现。

此外，还需要考虑到平台的兼容性问题，不同版本的NDK可能在某些API的调用和库的链接上有差异。因此，在配置环境时，应确保选择与您的项目兼容的NDK版本。

通过本章的介绍，相信您已对NDK环境配置有了初步的了解，为下一章节的jni目录创建打下了坚实的基础。

2. jni目录创建与源文件编写

在深入探讨JNI开发之前，首先要理解JNI（Java Native Interface）是如何工作的。它允许Java代码和其他语言编写的代码进行交互，这在性能敏感和需要调用已有本地库的场景中尤为重要。本章节将介绍jni目录的创建过程、源文件的编写规则，以及如何规范地实现JNI接口。

2.1 jni目录的创建与项目结构

2.1.1 jni目录的作用与重要性

JNI目录是项目中存放本地代码（通常是C或C++代码）的专用目录。它的存在是为了帮助Android构建系统识别哪些文件需要被编译成本地库，并最终打包到APK中。它的重要性不仅在于组织项目结构，还在于确保Java层和本地层代码之间的高效交互。

2.1.2 项目中jni目录的构建过程

构建项目中的jni目录涉及到多个步骤，首先是创建目录结构，然后是编写源文件和配置文件。具体步骤如下：

在项目根目录下创建一个名为 jni 的文件夹。
在 jni 文件夹内根据模块功能创建子目录，以方便管理。
编写C/C++源文件，通常以 .c 或 .cpp 作为扩展名。
在 jni 目录中创建一个 Android.mk 文件，用于指定如何编译本地库。

2.2 源文件的编写规则

2.2.1 C/C++源文件的基本构成

一个标准的C/C++源文件通常由以下部分组成：

头文件包含区域，使用 #include 指令引入所需的头文件。
宏定义，可选部分，通过 #define 指令定义常量或宏。
函数声明和数据类型声明区域。
函数定义和实现部分。
可选的全局变量声明。

源文件编写的基本原则是保证代码的可读性和可维护性。示例代码块如下：

#include <jni.h>
#include <stdio.h>

// 函数声明
JNIEXPORT void JNICALL Java_com_example_myapp_MainActivity_nativePrintHelloWorld(JNIEnv *env, jobject obj);

// 本地方法实现
JNIEXPORT void JNICALL Java_com_example_myapp_MainActivity_nativePrintHelloWorld(JNIEnv *env, jobject obj) {
    printf("Hello World from C/C++!\n");
}

2.2.2 JNI接口的规范与实现

JNI接口定义了Java与本地代码交互的规范。在编写JNI接口时，需要遵循一些特定的命名规则，例如方法名通常以 Java_ 、 _native 为前缀，后面跟着完整的Java类名和方法名。在实现接口时，需使用 javah 工具生成对应的本地方法头文件，以确保类型匹配。

JNI方法实现时需使用 JNIEnv 指针，它是JNI环境中最重要的接口之一，提供了丰富的本地方法接口。JNI方法的返回类型和参数类型都必须严格匹配Java中声明的类型。

示例JNI方法实现：

#include "com_example_myapp_MainActivity.h"

JNIEXPORT void JNICALL Java_com_example_myapp_MainActivity_nativePrintHelloWorld(JNIEnv *env, jobject obj) {
    (*env)->FindClass(env, "java/lang/String");
    // 实现逻辑
}

2.2.3 JNI方法的加载与调用

在Java层加载和调用JNI方法，首先需要确保本地库已经被加载到内存中。这可以通过 System.loadLibrary("library_name") 实现。加载完成后，就可以通过 native 关键字声明的Java方法来调用对应的本地方法了。

public class MainActivity extends AppCompatActivity {
    // 加载本地库
    static {
        System.loadLibrary("native-lib");
    }

    // 声明本地方法
    public native void nativePrintHelloWorld();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 调用本地方法
        nativePrintHelloWorld();
    }
}

通过上述章节的详细介绍，我们已经了解了jni目录创建和源文件编写的基本知识。这为后续的Android.mk文件配置、SO库构建、Java层加载SO库以及跨语言交互和性能优化等章节奠定了基础。在继续之前，请确保已经熟悉了章节中介绍的核心概念，以保证开发过程的流畅性。

3. Android.mk文件配置

3.1 Android.mk文件的作用

3.1.1 模块化构建的基本原理

在Android NDK开发中， Android.mk 文件扮演着不可或缺的角色。它是用于定义模块化构建过程的Makefile脚本，通过它可以让开发者以声明式的方式指定源文件、编译选项、目标库等信息。构建系统读取 Android.mk 文件后，会使用NDK自带的编译工具链，将C或C++源代码编译成动态库（.so文件）或静态库（.a文件）。

模块化构建的基本原理是将应用程序分解成若干个可独立编译、链接的小模块。每个模块都有自己的源文件、头文件、依赖关系和编译选项。这种做法可以极大提升开发效率和编译速度，特别是在大型项目中，模块化使得代码结构更为清晰，便于管理和维护。此外，模块化构建还允许开发者只重新编译更改过的模块，从而缩短编译时间。

3.1.2 Android.mk与Application.mk的关系

Android.mk 是模块级别的构建文件，用于定义一个或多个模块。与之相对应的是 Application.mk 文件，它是应用级别的构建文件，用于为整个应用定义一些全局的构建参数，如构建类型、目标架构、是否包含调试信息等。

在编译过程中，构建系统会同时读取 Android.mk 和 Application.mk 文件，以获取完整构建信息。 Application.mk 中的设置将作为默认值，可以被 Android.mk 文件中对应模块的设置所覆盖。这种设计允许项目中不同模块可以有不同的编译选项，而不需要为每个模块重复设置全局编译参数。

3.2 Android.mk文件的编写技巧

3.2.1 源文件的引入与编译

编写 Android.mk 文件时，核心任务之一是正确引入和编译源文件。文件中的 LOCAL_SRC_FILES 变量用于指定需要编译的源文件，而 LOCAL_MODULE 变量则定义了该模块的名称。以下是一个简单的 Android.mk 示例，展示了如何引入和编译两个C源文件：

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# 模块名称
LOCAL_MODULE    := my_module

# 源文件列表
LOCAL_SRC_FILES := hello.c
LOCAL_SRC_FILES += world.c

# 编译标志，例如是否需要包含调试信息
LOCAL_CFLAGS    := -Wall

# 编译模块
include $(BUILD_SHARED_LIBRARY)

在上述代码中， LOCAL_SRC_FILES 列出所有源文件， LOCAL_CFLAGS 用于添加编译标志， BUILD_SHARED_LIBRARY 指明构建的是一个共享库（动态链接库）。这样的设置使得构建系统知道如何处理这些文件，以及如何将它们打包成最终的动态库或静态库文件。

3.2.2 动态库和静态库的区分配置

Android NDK支持构建动态库和静态库。动态库在运行时被加载，可以节省内存空间，但需要在运行时链接，可能会稍微影响性能。静态库则在应用安装时就已包含在内，不需要运行时链接，但会增加应用的体积。

在 Android.mk 文件中，通过 BUILD_SHARED_LIBRARY 宏来构建动态库，通过 BUILD_STATIC_LIBRARY 宏来构建静态库。代码示例如下：

include $(CLEAR_VARS)

# 模块名称
LOCAL_MODULE    := static_hello
# 构建静态库
LOCAL_SRC_FILES := hello.c
LOCAL_STATIC_LIBRARIES := static_hello

include $(BUILD_STATIC_LIBRARY)

在这个例子中， BUILD_STATIC_LIBRARY 宏表示我们要构建一个静态库。这里我们构建了一个名为 static_hello 的静态库模块。需要注意的是，静态库的引入和编译过程与动态库有所不同，通常用于项目内部组件的复用，而动态库则更适合提供跨项目或跨应用的共享功能。

请注意，以上内容仅涵盖第三章"Android.mk文件配置"的部分内容。第三章的完整内容应继续在剩余部分展开，遵循所描述的结构和详细程度。按照要求，文章内容应通过各级章节逐步深入分析，确保专业性及逻辑性，同时提供足够的细节，使得即便是经验丰富的IT从业者也能从中获益。

4. SO库构建流程

4.1 构建前的准备工作

4.1.1 确保NDK环境配置无误

在开始构建SO库之前，首先需要确保NDK环境配置正确无误。这一步骤是构建过程中的基础，其目的是为后续的编译和链接环节提供正确的工具链和环境变量。

为了验证NDK环境是否配置正确，需要进行以下几个步骤： 1. 确认NDK路径是否被添加到系统的环境变量PATH中。通过执行 echo $PATH 或在命令行运行 ndk-build -v ，如果能正确显示NDK版本信息，则表示环境变量配置成功。 2. 在项目根目录下，通过 ndk-build 命令尝试进行一次简单的构建，确保没有报错信息。如果构建过程中遇到问题，要根据错误提示进行相应的环境调整。 3. 检查 ndk-build 命令是否可用，以及其版本是否满足项目的需求。

4.1.2 检查源文件与配置文件的正确性

源文件和配置文件是构建过程中所依赖的关键要素。必须确保源文件（如C/C++文件）和配置文件（如Android.mk和Application.mk）的正确性和完整性。

在进行构建之前，应当进行以下检查： 1. 源文件应当遵循JNI接口规范，正确声明了native方法。 2. Android.mk文件中，确保所有源文件被正确引入，且模块名正确。 3. 检查源文件中是否包含语法错误或编译器不识别的语法结构。 4. 检查配置文件的语法是否正确，没有遗漏必要的配置项。

4.2 构建过程详解

4.2.1 使用ndk-build命令进行构建

ndk-build 是一个由Android NDK提供的构建系统，用于编译原生代码并将其打包成动态链接库（.so文件）。

构建流程通常包括以下步骤： 1. 在项目根目录打开命令行工具。 2. 执行 ndk-build 命令开始构建过程。 3. 构建系统会根据Android.mk和Application.mk的配置，查找并编译源文件。 4. 如果一切顺利，生成的so文件将会被放置在 obj/local/ 目录下对应架构的子目录中。

如果遇到编译错误或警告，需要根据提示调整源代码或配置文件，并重新执行 ndk-build 命令。

4.2.2 构建过程中可能出现的问题及解决方案

在构建过程中可能会遇到的问题包括但不限于：编译错误、链接错误、库依赖问题等。为了有效地解决这些问题，需要深入了解错误信息，并采取合适的解决策略。

编译错误 ：如果编译器报告语法错误，通常意味着代码中有语法不正确的地方。需要检查错误信息，定位问题所在，并修改代码。
链接错误 ：链接错误通常是由于未定义的引用或缺失库造成的。需要确认所有需要的库都已经正确引入，并且符号定义和引用是匹配的。
库依赖问题 ：如果系统找不到某些依赖库，可能需要检查NDK的路径设置或者将缺失的库文件手动添加到项目路径中。

下面是一个典型的ndk-build命令执行过程的示例代码块及其逻辑分析：

ndk-build

执行 ndk-build 命令会触发NDK的构建系统。构建系统首先读取 Android.mk 文件，该文件定义了源文件和构建规则。然后，系统会根据这些规则查找并编译源文件，并最终生成相应的.so文件。

在实际的构建过程中，可能还需要处理各种环境依赖和路径配置问题。例如，指定NDK的路径、确保系统安装了必需的工具链和依赖库。

以下是通过mermaid流程图表示的构建流程：

graph TD;
    A[开始构建] --> B[检查环境变量]
    B --> C[检查ndk-build命令]
    C --> D{检查源文件和配置文件}
    D -- 无问题 --> E[执行ndk-build命令]
    D -- 有问题 --> F[修复源文件和配置文件]
    E --> G[编译源文件]
    G --> H{构建是否成功}
    H -- 是 --> I[输出.so文件]
    H -- 否 --> J[查看错误信息]
    J --> K[根据错误信息修复问题]
    K --> E
    I --> L[构建完成]

这个流程图概括了构建过程中的主要步骤和可能的决策路径。每个步骤都与前面的章节紧密相关，确保了构建过程的连贯性和完整性。

5. Java层加载SO库方法

5.1 为何需要在Java层加载SO库

5.1.1 Java与C/C++代码交互的必要性

在Android应用开发中，Java是最常用的编程语言，它提供了丰富的API和强大的开发工具支持，使得应用开发效率和维护性大大提升。然而，Java在系统底层的处理能力和对特定硬件操作的精细度方面存在限制。例如，涉及到音频、视频编解码处理，图形渲染加速，或者需要高性能计算时，Java的表现可能无法满足需求。

这时，就需要使用C/C++语言来实现这些功能，因为它们能够提供对硬件的直接控制，运行效率高，尤其适合性能要求苛刻的场景。为了实现Java层与C/C++层的交互，Android引入了JNI（Java Native Interface），允许Java代码调用本地（Native）方法，这些本地方法是用C或C++编写的。

5.1.2 SO库在Android系统中的角色

SO库是共享对象（Shared Object）库的缩写，在Android系统中，SO库本质上就是一个编译后的二进制文件，其中包含了编译后的C/C++代码。这些代码在运行时可以被Java层的代码通过JNI调用。SO库的一个关键优势是能够提高应用程序的运行效率，因为它们以本地代码的形式直接运行在设备的硬件上。

SO库在Android系统中扮演着一个重要的角色，允许开发者在保持Java代码的可移植性和开发效率的同时，也能够利用本地代码的优势来实现更复杂、高效的算法和功能。通过加载SO库，Java应用能够利用底层的资源和硬件加速功能，从而达到提升整体性能的目的。

5.2 加载SO库的具体方法

5.2.1 System.loadLibrary()的使用

加载SO库是通过Java的 System.loadLibrary() 方法来实现的。这个方法是JNI提供的一个接口，允许Java代码加载指定的本地库。

public class NativeLibLoader {
    static {
        System.loadLibrary("native-lib");
    }

    // 其他Java代码...
}

在上面的代码中， System.loadLibrary("native-lib") 将会加载名为"native-lib"的本地库。当这个静态代码块被执行时，它会查找名为"libnative-lib.so"的共享库文件，并加载到当前进程中。需要注意的是， loadLibrary() 方法中指定的参数是不包含"lib"前缀和".so"后缀的，只需要提供不带前后缀的库名。

5.2.2 System.load()与动态库的加载

除了 System.loadLibrary() 之外，还有 System.load() 方法可用于加载本地库，它允许开发者通过指定库文件的绝对路径来加载库。

public class NativeLibLoader {
    static {
        System.load("/path/to/libnative-lib.so");
    }

    // 其他Java代码...
}

在这个例子中， System.load() 方法通过绝对路径直接加载本地库。这种方式提供了更多的灵活性，使得开发者可以控制库文件的具体位置，适用于库文件可能需要动态更换的情况。但使用这种方式时需要注意路径的正确性，错误的路径会导致库加载失败。

此外，使用 System.load() 加载库时，库文件的命名必须符合标准的命名约定，即以"lib"开头，以".so"结尾。例如，如果要加载的动态库名为"native-lib"，那么实际的文件名应该为"libnative-lib.so"。

在实现Java层加载SO库时，需要注意确保SO库文件的名称与加载时指定的名称完全一致，并且库文件与Java类库在同一个应用进程中。正确地加载和使用本地库，可以有效地提升Android应用的性能和功能。

6. 使用javah工具生成头文件

6.1 javah工具的作用与意义

6.1.1 javah在JNI开发中的地位

JNI (Java Native Interface) 开发允许 Java 代码调用本地的应用程序接口（API），具体是指在非 Java 语言（通常是 C 或 C++）中实现的 API。在 JNI 开发中，Java 类中的 native 方法需要与本地代码进行交互，但为了使 Java 能够识别本地方法的签名，需要生成相应的本地头文件（.h）。 javah 是 Java 开发工具包（JDK）中的一个工具，用于根据 Java 类中的 native 方法声明生成对应的 C/C++ 头文件。

使用 javah 生成的头文件，开发者可以清楚地知道本地代码中需要实现哪些方法，并确保方法签名与 Java 端声明完全一致。这一步骤在 JNI 开发中是不可或缺的，因为任何签名的不匹配都会导致在动态链接时出现错误。

6.1.2 从Java接口生成本地头文件的原理

javah 工具的原理是读取 Java 编译后的 .class 文件，识别其中声明的 native 方法，并根据这些方法的名称、返回类型以及参数类型生成对应的 C/C++ 函数签名。这些签名在 C/C++ 端的实现是必须的，因为 JNI 函数的名称和签名必须与 Java 中声明的保持一致。

生成的头文件中包含了被 extern "C" 包围的函数声明，这允许 C++ 代码能够调用 C 函数而不发生名称修饰（name mangling），这一点对于实现 JNI 接口是至关重要的。

6.2 生成头文件的步骤与注意事项

6.2.1 通过命令行使用javah工具

使用 javah 工具生成头文件的步骤相对简单，通常在命令行中执行。下面是基本的命令行用法：

javah -classpath <your-classpath> -d <output-directory> <fully-qualified-class-name>

其中： - <your-classpath> 是包含 .class 文件的目录路径。 - <output-directory> 是生成头文件的输出目录。 - <fully-qualified-class-name> 是要生成头文件的 Java 类的全限定名。

例如，假设有一个类 com.example.MyNativeClass ，其中包含 native 方法，且位于 build/classes 目录下，可以使用以下命令：

javah -classpath build/classes -d include com.example.MyNativeClass

6.2.2 处理javah生成的头文件中的问题

虽然使用 javah 生成头文件的过程比较直接，但在实际开发过程中可能会遇到一些问题。例如：

如果 Java 类中有多个 native 方法的签名相同， javah 生成的头文件可能会出现冲突。
有时 javah 生成的头文件中，返回类型或参数类型可能会有所不同，这可能是由于 Java 类型与 C/C++ 类型之间的不匹配。

为了解决这些问题，可以采取以下措施： - 在 Java 类中为每个 native 方法使用唯一的方法名。 - 在生成的头文件中，仔细检查返回类型和参数类型，确保它们与本地代码实现匹配。 - 如果存在类型不匹配，使用 JNI 提供的类型转换函数来适配类型。

通过以上措施，可以有效地避免或解决生成头文件过程中可能遇到的问题。

代码块与逻辑分析

下面是一个 Java 类定义和使用 javah 生成头文件的实例：

Java 类定义 MyNativeClass.java ：

public class MyNativeClass {
    static {
        System.loadLibrary("myNativeLibrary");
    }

    // native method declaration
    private native void nativeMethod(int arg);
    // native method implementation in native code
    public native void anotherNativeMethod(String arg);
}

执行 javah 命令：

javah -classpath build/classes -d include com.example.MyNativeClass

这会生成一个名为 com_example_MyNativeClass.h 的头文件，在这个文件中， javah 会为每个 native 方法生成 C 函数的声明：

/* Header for class com_example_MyNativeClass */

#ifndef _Included_com_example_MyNativeClass
#define _Included_com_example_MyNativeClass

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class:     com_example_MyNativeClass
 * Method:    nativeMethod
 * Signature: (I)V
 */
JNIEXPORT void JNICALL Java_com_example_MyNativeClass_nativeMethod
  (JNIEnv *, jobject, jint);

/*
 * Class:     com_example_MyNativeClass
 * Method:    anotherNativeMethod
 * Signature: (Ljava/lang/String;)V
 */
JNIEXPORT void JNICALL Java_com_example_MyNativeClass_anotherNativeMethod
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif

#endif

通过上述过程，我们可以看到如何使用 javah 工具将 Java 中的 native 方法声明转换为 C/C++ 函数声明，为本地代码的编写奠定了基础。

7. 跨语言交互及性能优化

跨语言交互是Java与C/C++代码协作的核心所在，它允许开发者在保持Java应用层的便利性的同时，利用C/C++进行性能敏感的开发。在性能优化方面，开发者需要考虑诸多因素，从数据类型的高效转换到交互过程中的性能损耗最小化。

7.1 跨语言交互的基本原理

Java和C/C++的跨语言交互涉及到的数据类型转换以及调用效率问题，是两个重要的考量点。

7.1.1 Java与C/C++数据类型转换

在进行Java和C/C++跨语言交互时，数据类型的转换是必须要考虑的问题。Java的 byte 、 short 、 char 、 int 、 long 、 float 和 double 等基本数据类型与C/C++中的对应基本类型在内存大小上不完全相同。因此，当这些数据在两个语言间传递时，需要进行相应的类型转换。JNI为此提供了一系列的宏定义，如 jint 对应Java中的 int ， jlong 对应Java中的 long 等，来确保类型在不同语言间传递时保持一致。

7.1.2 跨语言调用的效率问题

跨语言调用的效率问题是性能优化的重点。由于Java和C/C++运行在不同的虚拟机或环境中，调用开销相对较大。调用过程涉及到参数的传递、数据的转换等操作，这些都会对性能产生影响。因此，为了提高效率，需要尽量减少跨语言调用的次数和复杂度。

7.2 优化策略与实践

针对性能问题，优化数据传输效率以及减少交互过程中的性能损耗是两个关键点。

7.2.1 优化数据传输效率的方法

使用直接字节缓冲区： 在Java中可以使用 ByteBuffer 或 DirectByteBuffer 来直接操作内存，这比使用基本数据类型的数组进行拷贝要高效得多。
减少数据拷贝次数： 设计交互协议时，尽可能地减少数据的拷贝次数，例如使用对象的持久化方法，避免在每次交互时都拷贝数据。
使用引用传递： 在可能的情况下，使用引用传递代替值传递可以减少数据拷贝，尤其是在传递大型数据结构时。

7.2.2 减少交互过程中的性能损耗

缓存对象： 如果频繁调用同一C/C++函数，可以将频繁使用的数据缓存起来，减少重复的内存分配和数据传输。
减少同步调用： 跨语言调用往往是同步的，可以考虑将某些计算密集型的任务进行异步处理，或者在C/C++端进行批处理，减少调用次数。
使用JNI局部引用： 在JNI层面对Java对象进行操作时，尽量使用局部引用替代全局引用，因为局部引用在函数返回后就会被自动释放，减少了内存泄漏的风险。

// 示例代码：使用ByteBuffer进行高效的字节数据交互
public void shareDataViaByteBuffer() {
    ByteBuffer buffer = ByteBuffer.allocateDirect(1024); // 创建直接缓冲区
    // ...操作buffer中的数据...
    buffer.flip(); // 切换为读模式
    // 使用C/C++中的native方法来处理这个buffer
    processByteBuffer(buffer);
}

以上展示了通过JNI进行高效跨语言交互的一些实践方法。跨语言调用的过程复杂且充满挑战，它要求开发者对内存管理、数据传输有深入的理解。只有在全面优化的基础上，才能实现Java和C/C++之间性能的最佳平衡。在实际应用中，开发者需要不断测试和调整交互策略，找到最优的解决方案。

本文还有配套的精品资源，点击获取