首页 > 其他分享 >NDK开发

NDK开发

时间：2024-10-16 22:17:17浏览次数：3  
标签：__ NDK void LOGD 开发 env JNI JNIEnv

NDK介绍

  1. app为什么会把代码放到so中

a) C语言历史悠久，有很多现成的代码可用

b) C代码执行效率比Java高

c) Java代码很容易被反编译，而且反编译以后的逻辑很清晰

  1. 为什么要学习NDK开发

在安卓的so开发中，其他基本与C/C++开发一致，而与Java交互需要用到jni

在本部分的NDK开发讲解中，主要就是介绍jni相关内容

so中会接触的：系统库函数、jni调用、加密算法、魔改算法、系统调用、自定义算法

  1. 什么是JNI

jni是Java Native Interface的缩写。从Java1.1开始，jni标准成为Java平台的一部分，允许Java代码和其他语言写的代码进行交互

  1. 什么是NDK

交叉编译工具链

NDK的配置

NDK、CMake、LLDB的作用 https://developer.android.com/ndk/guides

  1. ABI与指令集

https://developer.android.com/ndk/guides/abis

NDK与Java工程的区别

  1. Java代码中加载so和声明所需使用的so中的函数

  2. 编写CMakeLists.txt和C文件

  3. build.gradle中添加一些代码

defaultConfig {
......
externalNativeBuild {
	cmake {
	    cppFlags "-std=c++11"
	}
}
ndk {
	abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
}
}
externalNativeBuild {
cmake {
	path "src/main/cpp/CMakeLists.txt"
	version "3.10.2"
}
}

第一个NDK工程

  1. CMakeLists介绍

指明文件源代码编译成哪个so、指明依赖库

2.so的加载

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

3.native函数的声明

public native String stringFromJNI();
  1. JNI函数的静态注册规则
extern "C" JNIEXPORT jstring JNICALL
Java_com_example_myapplication_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

5.JNIEnv、jobject/jclass

so层对接java层需要的参数

  1. NewstringUTF

将c字符串转换为java字符串

关键代码定位点、系统函数

  1. 在NDK开发中，一定要注意哪些是Java的类型，哪些是C/C++的类型，在适当的时候需要转换

  2. extern “C” JNIEXPORT jstring JNICALL

使用c语言方式编译、JNIEXPORT是否出现在导出表、jstring返回值

  1. 指定只编译arm64的so
ndk(){
    adiFilters 'arm64-v8a'
}
  1. 指定编译后的so名字

CMakeLists.txt中修改

so中常用的Log输出

#include <android/log.h>

#define TAG "xxxxxx"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);




#include <jni.h>
#include <string>
#include <android/log.h>

#define TAG "xxxxxx"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);



extern "C" JNIEXPORT jstring JNICALL
Java_com_example_myapplication_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    LOGD("xxxxxx%d",100);
    return env->NewStringUTF(hello.c_str());
}

#define中的…和__VA_ARGS__

可变参数

NDK多线程

JavaVM每个进程中只有一份
JNIEnv每个线程中都有一份
为了更好的演示，所以先简单介绍一下多线程

//线程id，其实就是long
pthread_t thread;
//线程id 线程属性 函数 传给函数的参数
pthread_create(&thread, nullptr, myThread, nullptr);
//等待线程执行完毕
//默认的线程属性是joinable 随着主线程结束而结束
//线程属性是dettach，可以分离执行 
pthread_join(thread, nullptr);
//子线程中使用它来退出线程
pthread_exit(0);

传递int参数
传递多个参数 结构体 数组
接收返回值

JNI_OnLoad

  1. so中各种函数的执行时机

init、init_array、JNI_OnLoad

  1. JNI_OnLoad的定义
JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = nullptr;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
        LOGD("GetEnv failed");
        return -1;
    }
    return JNI_VERSION_1_6;
}
  1. 注意事项

一个so中可以不定义JNI_OnLoad

一旦定义了JNI_OnLoad，在so被加载的时候会自动执行

必须返回JNI版本 JNI_VERSION_1_6

JavaVM

  1. JavaVM是什么
    JavaVM结构体介绍
    C和C++中的区别
    JavaVM中的常用方法
    GetEnv
    AttachCurrentThread
  2. JavaVM的获取方式
    JNI_OnLoad的第一个参数
    JNI_OnUnload的第一个参数
    env->GetJavaVM
    对比各种方式获取的JavaVM指针是否一致
    %p打印地址

JNIEnv

  1. JNIEnv是什么
    JNIEnv结构体介绍
    C和C++中的区别
    JNIEnv中的常用方法后续详细介绍
  2. JNIEnv的获取方式
    函数静态/动态注册，传的第一个参数
    vm->GetEnv
    globalVM->AttachCurrentThread
    对比各种方式获取的JNIEnv指针是否一致
    %p打印地址
#include <jni.h>
#include <string>
#include <android/log.h>
#include <pthread.h>


#define TAG "xxxx"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "xiaojianbang", __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);


JavaVM* globalVM;


void myThread(){

//    JNIEnv *env = nullptr;
//    if (globalVM->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
//        LOGD("GetEnv failed");
//    }

    JNIEnv *env = nullptr;
    if (globalVM->AttachCurrentThread((JNIEnv **) &env, nullptr) != JNI_OK) {
        LOGD("GetEnv failed");
    }
    LOGD("myThread JNIEnv %p", env);


    LOGD("this is from myThread");
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_javaandso_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */) {
    std::string hello = "Hello from C++";

    LOGD("stringFromJNI JNIEnv %p", env);

    //__android_log_print(ANDROID_LOG_DEBUG, "xiaojianbang", "xxxxxx jni native %d %d", 100, 200);
    LOGD("xxxxxx jni native %d %d", 100, 200);

    pthread_t thread;
    // int pthread_create(pthread_t* __pthread_ptr, pthread_attr_t const* __attr, void* (*__start_routine)(void*), void*);
    pthread_create(&thread, nullptr, reinterpret_cast<void *(*)(void *)>(myThread), nullptr);
    pthread_join(thread, nullptr);

    return env->NewStringUTF(hello.c_str());
}

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    LOGD("this is form JNI_OnLoad");

    JNIEnv *env = nullptr;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
        LOGD("GetEnv failed");
        return -1;
    }

    LOGD("JavaVM %p", vm);
    env->GetJavaVM(&globalVM);
    LOGD("JavaVM %p", globalVM);

    LOGD("JNI_OnLoad JNIEnv %p", env);


    return JNI_VERSION_1_6;
}

so相关的几个概念

  1. 导出表、导入表是什么
  2. 出现在导出表、导入表里面的函数，一般可以通过frida相关API直接得到函数地址，也可以自己计算函数地址
  3. 没有出现在导出表、导入表、符号表里面的函数，都需要自己计算函数地址
  4. 要完成so层的hook，都需要得到一个地址
  5. Java层中的native函数，被调用后会找到so中对应的函数。简单的说，就是Java调用C需要先完成函数注册，函数注册分为静态注册、动态注册

so函数注册

  1. JNI函数的静态注册
    必须遵循一定的命名规则，一般是Java_包名_类名_方法名
    系统会通过dlopen加载对应的so，通过dlsym来获取指定名字的函数地址，然后调用
    静态注册的jni函数，必然在导出表里
  2. JNI函数的动态注册
    通过env->RegisterNatives注册函数，通常在JNI_OnLoad中注册
    JNINativeMethod
    函数签名
    可以给同一个Java函数注册多个native函数，以最后一次为准
jclass MainActivityClazz = env->FindClass("com/xxxx/ndk/NDKMain");
JNINativeMethod methods[] = {
    //public native String encode(int i, String str, byte[] byt);
    {"encode", "(ILjava/lang/String;[B)Ljava/lang/String;", (void *)encodeFromC},
};
env->RegisterNatives(MainActivityClazz, methods, sizeof(methods)/sizeof(JNINativeMethod));

#include <jni.h>
#include <string>
#include <android/log.h>
#include <pthread.h>
#include <dlfcn.h>


#define TAG "xiaojianbang"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "xiaojianbang", __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);


JavaVM* globalVM;
void test();
extern "C" void fromSoB();

void myThread(){

//    JNIEnv *env = nullptr;
//    if (globalVM->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
//        LOGD("GetEnv failed");
//    }

    JNIEnv *env = nullptr;
    if (globalVM->AttachCurrentThread((JNIEnv **) &env, nullptr) != JNI_OK) {
        LOGD("GetEnv failed");
    }
    LOGD("myThread JNIEnv %p", env);


    LOGD("this is from myThread");
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_javaandso_MainActivity_stringFromJNI(
        JNIEnv* env,
        jobject /* this */, jstring path) {
    std::string hello = "Hello from C++";

    LOGD("stringFromJNI JNIEnv %p", env);

    //__android_log_print(ANDROID_LOG_DEBUG, "xiaojianbang", "xxxxxx jni native %d %d", 100, 200);
    LOGD("xxxxxx jni native %d %d", 100, 200);

    pthread_t thread;
    // int pthread_create(pthread_t* __pthread_ptr, pthread_attr_t const* __attr, void* (*__start_routine)(void*), void*);
    pthread_create(&thread, nullptr, reinterpret_cast<void *(*)(void *)>(myThread), nullptr);
    pthread_join(thread, nullptr);


    const char* cPath = env->GetStringUTFChars(path, nullptr);

    LOGD("cPath: %s", cPath);

    void *soinfo = dlopen(cPath, RTLD_NOW);
    void (*ref)();
    //ref = reinterpret_cast<void (*)()> (dlsym(soinfo, "_Z7fromSoBv"));
    ref = reinterpret_cast<void (*)()> (dlsym(soinfo, "fromSoB"));
    if (ref == nullptr) {
        LOGD("ref is null");
    }
    ref();

    fromSoB();
    dlclose(soinfo);

    return env->NewStringUTF(hello.c_str());
}

jstring xxxx(JNIEnv* env, jobject obj, jstring a, jint b, jbyteArray c) {
    return env->NewStringUTF("xxxx from jni");
}

jstring xxxx1(JNIEnv* env, jobject obj, jstring a, jint b, jbyteArray c) {

    test();

    return env->NewStringUTF("xxxx1 from jni");
}

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    LOGD("this is form JNI_OnLoad");

    JNIEnv *env = nullptr;
    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
        LOGD("GetEnv failed");
        return -1;
    }

    LOGD("JavaVM %p", vm);
    env->GetJavaVM(&globalVM);
    LOGD("JavaVM %p", globalVM);
    LOGD("JNI_OnLoad JNIEnv %p", env);

    jclass MainActivityClazz = env->FindClass("com/example/javaandso/MainActivity");
    JNINativeMethod methods[] = {
            {"stringFromJNI2", "(Ljava/lang/String;I[B)Ljava/lang/String;", (void *)xxxx},
            {"stringFromJNI2", "(Ljava/lang/String;I[B)Ljava/lang/String;", (void *)xxxx1},
    };
//    jint RegisterNatives(jclass clazz, const JNINativeMethod* methods,
//                         jint nMethods)
    env->RegisterNatives(MainActivityClazz, methods, sizeof(methods)/sizeof(JNINativeMethod));

    return JNI_VERSION_1_6;
}

so之间的互相调用

  1. 多个cpp文件编译成一个so

CMake.txt文件中 添加cpp文件

add_library( # Sets the name of the library.
            xiaojianbang
            
            # Sets the library as a shared library.
            SHARED
            
            # Provides a relative path to your source file(s).
            xiaojianbang.cpp
            xxx.cpp
        )
  1. 编译多个so
    编写多个cpp文件
    修改CMakeLists.txt
    Java静态代码块加载多个so
dd_library( # Sets the name of the library.
             xxxxA

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             xxxx.cpp
             main.cpp
        )

add_library( # Sets the name of the library.
        xxxxB

        # Sets the library as a shared library.
        SHARED

        # Provides a relative path to your source file(s).
        demo.cpp
        )


# Searches for a specified prebuilt library and stores the path as a
# variable. Because CMake includes system libraries in the search path by
# default, you only need to specify the name of the public NDK library
# you want to add. CMake verifies that the library exists before
# completing its build.

find_library( # Sets the name of the path variable.
              log-lib

              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )

# Specifies libraries CMake should link to your target library. You
# can link multiple libraries, such as libraries you define in this
# build script, prebuilt third-party libraries, or system libraries.

target_link_libraries( # Specifies the target library.
                       xxxxA
                       # Links the target library to the log library
                       # included in the NDK.
                       ${log-lib} )


target_link_libraries( # Specifies the target library.
                    xxxxB

                    # Links the target library to the log library
                    # included in the NDK.
                    ${log-lib} )
  1. so之间的相互调用
    2.1 使用dlopen、dlsym、dlclose获取函数地址，然后调用。需要导入dlfcn.h
    void soinfo = dlopen(nativePath, RTLD_NOW);
    void (def)(char str) = nullptr;
    def = reinterpret_cast<void (    )(char *)>(dlsym(soinfo, “_Z7fromSoBPc”));
    def(“”);
    2.2 extern 函数声明

通过jni创建Java对象

1. NewObject创建对象
jclass clazz = env->FindClass("com/xxxx/ndk/NDKDemo");
jmethodID methodID = env->GetMethodID(clazz, "<init>", "()V");
jobject ReflectDemoObj = env->NewObject(clazz, methodID);
LOGD("ReflectDemoObj %p", ReflectDemoObj);

2. AllocObject创建对象
jclass clazz = env->FindClass("com/xxxx/ndk/NDKDemo");
jmethodID methodID2 = env->GetMethodID(clazz, "<init>", "(Ljava/lang/String;I)V");
jobject ReflectDemoObj2 = env->AllocObject(clazz);
jstring jstr = env->NewStringUTF("from jni str");
env->CallNonvirtualVoidMethod(ReflectDemoObj2, clazz, methodID2, jstr, 100);

通过jni访问Java属性

  1. 获取静态字段
jfieldID privateStaticStringField = 
	env->GetStaticFieldID(clazz, "privateStaticStringField", "Ljava/lang/String;");
jstring privateStaticString = 
	static_cast<jstring>(env->GetStaticObjectField(clazz, privateStaticStringField));
const char* privatecstr = 
	env->GetStringUTFChars(privateStaticString, nullptr);
LOGD("privateStaticString: %s", privatecstr);
env->ReleaseStringUTFChars(privateStaticString, privatecstr);
  1. 获取对象字段
jfieldID publicStringField = 
	env->GetFieldID(clazz, "publicStringField", "Ljava/lang/String;");
jstring publicString = 
	static_cast<jstring>(env->GetObjectField(ReflectDemoObj, publicStringField));
const char* publiccstr = 
	env->GetStringUTFChars(publicString, nullptr);
LOGD("publicStringField: %s", publiccstr);
env->ReleaseStringUTFChars(publicString, publiccstr);
  1. 设置字段
env->SetObjectField(ndkobj, privateStringFieldID, env->NewStringUTF("xxxx"));

通过jni访问Java数组

  1. 获取数组字段ID
jfieldID byteArrayID = env->GetFieldID(clazz, "byteArray", "[B");
jbyteArray byteArray = 
	static_cast<jbyteArray>(env->GetObjectField(ReflectDemoObj, byteArrayID));
int _byteArrayLength = env->GetArrayLength(byteArray);
jbyte* CBytes = env->GetByteArrayElements(byteArray,nullptr);
for(int i=0;i< _byteArrayLength;i++)
{
    LOGD(CBytes[i]);
}
  1. 修改数组字段
char javaByte[10];
for(int i = 0; i < 10; i++){
	javaByte[i] = static_cast<char>(100 - i);
}
const jbyte *java_array = reinterpret_cast<const jbyte *>(javaByte);
env->SetByteArrayRegion(byteArray, 0, _byteArrayLength, java_array);
  1. 获取数组字段
byteArray = static_cast<jbyteArray>(env->GetObjectField(ReflectDemoObj, byteArrayID));
_byteArrayLength = env->GetArrayLength(byteArray);
char* str = reinterpret_cast<char *>(env->GetByteArrayElements(byteArray, nullptr));
for(int i = 0; i< _byteArrayLength; i++){
	LOGD("str[%d]=%d", i, str[i]);
}
env->ReleaseByteArrayElements(jbyteArray, reinterpret_cast<jbyte *>(cbyteArray), 0);

通过jni访问Java方法

  1. 调用静态函数
jclass ReflectDemoClazz = env->FindClass("com/xiaojianbang/ndk/NDKDemo");
jmethodID publicStaticFuncID = env->GetStaticMethodID(ReflectDemoClazz, "publicStaticFunc", "()V");
env->CallStaticVoidMethod(ReflectDemoClazz, publicStaticFuncID);
  1. 调用对象函数
jmethodID privateFuncID = env->GetMethodID(ReflectDemoClazz, "privateFunc", "(Ljava/lang/String;I)Ljava/lang/String;");
jmethodID ReflectDemoInit = env->GetMethodID(ReflectDemoClazz, "<init>", "(Ljava/lang/String;)V");
jstring str1 = env->NewStringUTF("this is from NDK");
jobject ReflectDemoObj = env->NewObject(ReflectDemoClazz, ReflectDemoInit, str1);
jstring str2 = env->NewStringUTF("this is from JNI");
jstring retval = static_cast<jstring>(env->CallObjectMethod(ReflectDemoObj, privateFuncID, str2, 1000));
  1. CallObjectMethodA的使用
jvalue args[2];
args[0].l = str2;
args[1].i = 1000;
jstring retval = static_cast<jstring>(env->CallObjectMethodA(ReflectDemoObj, privateFuncID, args));
const char* cpp_retval = env->GetStringUTFChars(retval, nullptr);
LOGD("cpp_retval: %s", cpp_retval);
env->ReleaseStringUTFChars(retval, cpp_retval);

通过jni访问Java父类方法

//super.onCreate(savedInstanceState);
jclass AppCompatActivityClazz = env->FindClass("androidx/appcompat/app/AppCompatActivity");
jmethodID onCreateID = env->GetMethodID(AppCompatActivityClazz, "onCreate", "(Landroid/os/Bundle;)V");
env->CallNonvirtualVoidMethod(thiz, AppCompatActivityClazz, onCreateID, saved_instance_state);

内存管理

  1. 局部引用
    大多数的jni函数，调用以后返回的结果都是局部引用
    因此，env->NewLocalRef 基本不用
    一个函数内的局部引用数量是有限制的，在早期的安卓系统中，体现的更为明显
    当函数体内需要大量使用局部引用时，比如大循环中，最好及时删除不用的局部引用
    可以使用 env->DeleteLocalRef 来删除局部引用
  2. 局部引用相关的其他函数
    env->EnsureLocalCapacity(num) 判断是否有足够的局部引用可以使用，足够则返回0
    需大量使用局部引用时，手动删除太过麻烦，可使用以下两个函数来批量管理局部引用
    env->PushLocalFrame(num)
    env->PopLocalFrame(nullptr)
  3. 全局引用
    在jni开发中，需要跨函数使用变量时，直接定义全局变量是没用的
    需要使用以下两个方法，来创建和删除全局引用
    env->NewGlobalRef
    env->DeleteGlobalRef
  4. 弱全局引用
    与全局引用基本相同，区别是弱全局引用有可能会被回收
    env->NewWeakGlobalRef
    env->DeleteWeakGlobalRef

子线程中获取Java类

  1. 在子线程中，findClass可以直接获取系统类
  2. 在主线程中获取类，使用全局引用来传递到子线程中
  3. 在主线程中获取正确的ClassLoader，在子线程中去加载类
    3.1 在Java中，可以先获取类字节码，然后使用getClassLoader()来获取
    Demo.class.getClassLoader()
    new Demo().getClass().getClassLoader()
    Class.forName(…).getClassLoader()
    3.2 在jni的主线程中获取ClassLoader
    3.3 在jni的子线程中loadClass

init与initarray

  1. so在执行JNI_Onload之前，还会执行两个构造函数init、initarray
  2. so加固、so中字符串加密等等，一般会把相关代码放到这里
  3. init的使用
    extern “C” void _init(){ //函数名必须为_init
    …
    }
  4. initarray的使用
attribute ((constructor)) void initArrayTest1(){ ... }
attribute ((constructor(200))) void initArrayTest2(){ ... }
attribute ((constructor(101))) void initArrayTest3(){ ... }
attribute ((constructor, visibility("hidden"))) void initArrayTest4(){ ... }

constructor后面的值，较小的先执行，最好从100以后开始用
如果constructor后面没有跟值，那么按定义的顺序，从上往下执行

visibility(“hidden”)隐藏函数名

标签：__,NDK,void,LOGD,开发,env,JNI,JNIEnv
From： https://blog.csdn.net/weixin_42403632/article/details/142966724

相关文章

  • Next.js 零基础开发入门教程2 构建基础脚手架 2024最新更新中｜曲速引擎 Warp Drive
    开发目标我们将构建一个简化版本的财务仪表板，其内容包括：公共主页、登录页面、受身份验证保护的仪表板页面、用户可以添加、编辑和删除发票这篇文章先创建一个简单的nextjs脚手架页面安装pnpm包管理器接上一篇，开发环境都准备好之后，我们来做创建项目的准备，首先先判断上一篇的环......
  • 2023年 10月自考《软件开发工具》03173试题
    目录一.单选题二.填空题三.简答题四.应用题一.单选题1.软件对可维护性、可重用性的要求越来越高，这是因为A.客观世界的复杂性B.软件的多样性C.客观世界的动态性D.软件的规模性2.时序网络用户描述 P58页A.数据内容B.程序执行的逻辑过程C.数据结果D.系统状态及......
  • 每日学学Java开发规范，集合处理(附阿里巴巴Java开发手册（终极版）)
    前言每次去不同的公司，码不同的代码，适应不同的规范，经常被老大教育规范问题，我都有点走火入魔的感觉，还是要去看看阿里巴巴Java开发规范，从中熟悉一下，纠正自己，码出高效，码出质量。想细看的可以去官网下载，或者下面自取阿里巴巴Java开发手册（终极版）五、集合处理【强制】关于hashCod......
  • AI程序开发体验之CRM系统
    一、CRM系统的核心功能CRM系统是企业用于管理与客户关系的软件，它通过集成多种功能来提升客户满意度和企业效率。以下是一些CRM系统的核心功能：客户数据管理：这是CRM系统的基础功能，允许企业存储和组织客户的联系信息、购买历史和偏好等数据，以便快速访问并提供个性化服务。销......
  • 作物与杂草的智能识别，基于YOLOv8全系列参数模型【n/s/m/lx/】开发构建田间低头作物杂
    一、背景田间杂草的有效管理是现代农业生产中面临的重要挑战之一。杂草不仅竞争作物的养分、水分和阳光，还可能成为害虫和病原体的寄主，从而降低农作物的产量和品质。因此，开发高效、精确的杂草检测和管理系统对于提高农业生产效率、降低化学除草剂的使用以及保护环境具有重要......
  • 基于Java+Springboot+Vue开发的健身房管理系统
    项目简介该项目是基于Java+Springboot+Vue开发的健身房管理系统（前后端分离），这是一项为大学生课程设计作业而开发的项目。该系统旨在帮助大学生学习并掌握Java编程技能，同时锻炼他们的项目设计与开发能力。通过学习基于Java的健身房管理系统项目，大学生可以在实践中学习和提升......
  • 前端开发设计模式——命令模式
    目录一、命令模式的定义和特点1.定义：         2. 特点：二、命令模式的结构与原理1.结构：2.原理：三、命令模式的实现方式1.定义接口命令：2.创建具体的命令类：3.定义接收者：4.创建调用者：四、命令模式的使用场景1.界面按钮的点击操作：    1.1 ......
  • Java毕设项目案例实战II基于Spring Boot的科研项目验收管理系统（开发文档+数据库+源码）
    目录一、前言二、技术介绍三、系统实现四、论文参考五、核心代码六、源码获取全栈码农以及毕业设计实战开发，CSDN平台Java领域新星创作者，专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末一、前言随着科研活动的日益增多，科研项目验收作为......
  • Java毕设项目案例实战II基于Spring Boot的校园资产管理系统（开发文档+数据库+源码）
    目录一、前言二、技术介绍三、系统实现四、论文参考五、核心代码六、源码获取全栈码农以及毕业设计实战开发，CSDN平台Java领域新星创作者，专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末一、前言在信息化技术日益普及的今天，高效、智能的......
  • Java毕设项目案例实战II基于Spring Boot的在线互动学习网站（开发文档+数据库+源码）
    目录一、前言二、技术介绍三、系统实现四、论文参考五、核心代码六、源码获取全栈码农以及毕业设计实战开发，CSDN平台Java领域新星创作者，专注于大学生项目实战开发、讲解和毕业答疑辅导。获取源码联系方式请查看文末一、前言随着互联网技术的飞速发展，教育领域也迎来......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99