主音King
主音King

音视频学习(一)JNI入门

前言

Android平台从一开始就支持C/C++了，Android支持JNI编程方式第三方应用完全可以通过JNI调用自己的C动态库，于是NDK(Native Develop Kit)就诞生了。

介绍

JNI是Java程序设计语言功能最强的特征，允许Java类的某些方法原生实现(C/C++)。

环境配置

安装AS+NDK+CMAKE+LLDB
AS：AndroidStudio 4.0
NDK：允许Android使用C和C++代码。
CMake：外部构建工具，可与Gradle搭配使用来构建原生苦，如果使用ndk-build，则不需要此组件。
LLDB：debug调试

简单例子

1、创建 native c++ 工程


image.png

JNI入门学习

1、数据类型和类型描述符

Java 中有两种数据类型:
基本数据类型: boolean 、char、byte、int、short、long、float、double。
引用数据类型: String、Object[]、Class、Object 及其它类。

1.1基本数据类型

Java基本数据类型可以直接与C/C++相应的基本数据类型映射；如下映射关系

Java 类型 JNI 类型 C/C++ 类型
boolean jboolean unsigned char (无符号 8 位整型)
byte jbyte char (有符号 8 位整型)
char jchar unsingned short (无符号 16 位整型)
short jshort short (有符号 16 位整型)
int jint int (有符号 32 位整型)
long jlong long (有符号 64 位整型)
float jfloat float (有符号 32 位浮点型)
double jdouble double (有符号 64 位双精度型)

1.1引用类型

与基本类型不同，引用类型对原生方法时不透明的，它的内部数据结构并不直接向原生代码公开。

Java 类型 原生类型
Java.lang.Class jclass
Java.lang.Throwable jthrowable
Java.lang.String jstring
Other object jobject
Java.lang.Object[] jobjectArray
boolean[] jbooleanArray
byte[] jbyteArray
char[] jcharArray
short[] jshortArray
int[] jintArray
long[] jlongArray
float[] jfloatArray
double[] jdoubleArray
Other arrays jarray

1.1数据类型描述符

在JVM虚拟机中，存储数据类型名称时，是使用指定的描述来存储，而不是我们习惯的int，float等

Java 类型 签名 (描述符)
boolean Z
byte B
char C
short S
int I
long J
float F
double D
void V
其它引用类型 L + 全类名 + ；
type[] [
method type (参数)返回值

例如：

  • 表示一个 String

Java 类型 : java.lang.String

JNI 描述符: Ljava/lang/String; (L + 类全名 + ；)

先执行javac Person.java（如果是当前目录，可以不写路径，否则需要写绝对路径）生成Person.class
javap Person 查看类
javap -s 来获取方法签名（描述符）

george@bogon myapplication % javac Person.java
george@bogon myapplication % javap Person
警告: 二进制文件Person包含com.george.myapplication.Person
Compiled from "Person.java"
public class com.george.myapplication.Person {
  public com.george.myapplication.Person();
  public java.lang.String getName();
  public void setName(java.lang.String);
}
george@bogon myapplication % javap -s Person
警告: 二进制文件Person包含com.george.myapplication.Person
Compiled from "Person.java"
public class com.george.myapplication.Person {
  public com.george.myapplication.Person();
    descriptor: ()V

  public java.lang.String getName();
    descriptor: ()Ljava/lang/String;

  public void setName(java.lang.String);
    descriptor: (Ljava/lang/String;)V

  public native java.lang.String stringFromJNI();
    descriptor: ()Ljava/lang/String;
}
george@bogon myapplication %

2. JNIEnv 和JavaVm

2.1 JNIEnv

JNIEnv 表示Java调用native语言的环境，是一个封装了几乎全部JNI方法的指针。
JNIEnv只在创建它的线程生效，不能垮线程传递，不同线程的JNIEnv彼此独立。
native环境创建的线程，如果需要JNI，必须调用AttachCurrentThread关联，并使用DetachCurrentThread解除链接。

2.2 JavaVM：

JavaVM是虚拟机在JNI层的代表，一个进程只有一个JavaVM，所有的线程公用一个JavaVM

2.3 代码风格 (C/C++)

C: (*env)->NewStringUTF(env, “Hellow World!”);
C++: env->NewStringUTF(“Hellow World!”);

3.JNI API

参考官方 API 文档 或者 JNI 方法大全及使用示例

4.数据类型操作

JNI 处理 Java 传递过来的数据

    // 定义native函数
    public native void test1(
            boolean b,
            byte b1,
            char c,
            short s,
            long l,
            float f,
            double d,
            String name,
            int age,
            int[] i,
            String[] strs,
            Person person,
            boolean[] bArray

    );
      // 调用native函数
        test1(true,
                (byte) 1,
                ',',
                (short) 3,
                4,
                3.3f,
                2.2d,
                "小明",
                28,
                new int[]{1, 2, 3, 4, 5, 6, 7},
                new String[]{"1", "2", "4"},
                new Person("小明"),
                new boolean[]{false, true}
        );

jni处理Java传递过来的数据

#include 
#include 
#include 
#include 

#define TAG "native-lib"
// __VA_ARGS__ 代表 ...的可变参数
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__);
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__);
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__);

extern "C" // 支持C语言的代码
JNIEXPORT void JNICALL // 返回值为空
Java_com_george_myjni_MainActivity_test1(JNIEnv *env, jobject instance,
        jboolean jboolean1,
        jbyte jbyte1,
        jchar jchar1,
        jshort jshort1,
        jlong jlong1,
        jfloat jfloat1,
        jdouble jdouble1,
        jstring name_,
        jint age,
        jintArray i_,
        jobjectArray strs,
        jobject person,
        jbooleanArray bArray_){
    //1\. 接收 Java 传递过来的 boolean 值
    unsigned char b_boolean = jboolean1;
    LOGD("boolean-> %d", b_boolean);

    //2\. 接收 Java 传递过来的 boolean 值
    char c_byte = jbyte1;
    LOGD("jbyte-> %d", c_byte);

    //3\. 接收 Java 传递过来的 char 值
    unsigned short c_char = jchar1;
    LOGD("char-> %d", c_char);

    //4\. 接收 Java 传递过来的 short 值
    short s_short = jshort1;
    LOGD("short-> %d", s_short);

    //5\. 接收 Java 传递过来的 long 值
    long l_long = jlong1;
    LOGD("long-> %d", l_long);

    //6\. 接收 Java 传递过来的 float 值
    float f_float = jfloat1;
    LOGD("float-> %f", f_float);

    //7\. 接收 Java 传递过来的 double 值
    double d_double = jdouble1;
    LOGD("double-> %f", d_double);

    //8\. 接收 Java 传递过来的 String 值
    const char *name_string = env->GetStringUTFChars(name_, 0);
    LOGD("string-> %s", name_string);

    //9\. 接收 Java 传递过来的 int 值
    int age_java = age;
    LOGD("int:%d", age_java);

    //10\. 打印 Java 传递过来的 int []
    jint *intArray = env->GetIntArrayElements(i_, NULL);
    //拿到数组长度
    jsize intArraySize = env->GetArrayLength(i_);
    for (int i = 0; i < intArraySize; ++i) {
        LOGD("intArray->%d：", intArray[i]);
    }
    //释放数组
    env->ReleaseIntArrayElements(i_, intArray, 0);

    //11\. 打印 Java 传递过来的 String[]
    jsize stringArrayLength = env->GetArrayLength(strs);
    for (int i = 0; i < stringArrayLength; ++i) {
        jobject jobject1 = env->GetObjectArrayElement(strs, i);
        //强转 JNI String
        jstring stringArrayData = static_cast(jobject1);

        //转 C  String
        const char *itemStr = env->GetStringUTFChars(stringArrayData, NULL);
        LOGD("String[%d]: %s", i, itemStr);
        //回收 String[]
        env->ReleaseStringUTFChars(stringArrayData, itemStr);
    }

    //12\. 打印 Java 传递过来的 Object 对象
    //12.1 获取字节码
    const char *person_class_str = "com/george/myjni/Person";
    //12.2 转 jni jclass
    jclass person_class = env->FindClass(person_class_str);
    //12.3 拿到方法签名 javap -a
    const char *sig = "()Ljava/lang/String;";
    jmethodID jmethodID1 = env->GetMethodID(person_class, "getName", sig);

    jobject obj_string = env->CallObjectMethod(person, jmethodID1);
    jstring perStr = static_cast(obj_string);
    const char *itemStr2 = env->GetStringUTFChars(perStr, NULL);
    LOGD("Person: %s", itemStr2);
    env->DeleteLocalRef(person_class); // 回收
    env->DeleteLocalRef(person); // 回收

    //13\. 打印 Java 传递过来的 booleanArray
    jsize booArrayLength = env->GetArrayLength(bArray_);
    jboolean *bArray = env->GetBooleanArrayElements(bArray_, NULL);
    for (int i = 0; i < booArrayLength; ++i) {
        bool b =  bArray[i];
        jboolean b2 =  bArray[i];
        LOGD("boolean:%d",b)
        LOGD("jboolean:%d",b2)
    }
    //回收
    env->ReleaseBooleanArrayElements(bArray_, bArray, 0);
}

JNI 处理 Java 对象(JNI把对象传递给Java)
定义java对象

public class Person {
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private int age;
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;
}

定义native接口

public native Person getPerson();

JNI处理

extern "C" // 支持C语言的代码
JNIEXPORT jobject JNICALL // 返回值为空
Java_com_george_myjni_MainActivity_getPerson(JNIEnv *env, jobject instance){
    // 1. 拿到java类的全路径
    const char *person_java = "com/george/myjni/Person";
    const char *method = "";// java构造方法标示
    // 2. 找到需要处理的java对象class
    jclass j_person_class = env->FindClass(person_java);
    //3.拿到空参构造方法
    jmethodID person_constructor = env->GetMethodID(j_person_class,method,"()V");
    //4. 创建对象
    jobject person_obj = env->NewObject(j_person_class,person_constructor);
    //5. 拿到 setName 方法的签名，并拿到对应的setName方法
    const char *nameSig = "(Ljava/lang/String;)V";
    jmethodID nameMethodId = env->GetMethodID(j_person_class,"setName",nameSig);
    //6. 拿到setAge 方法的签名，并拿到setAge方法
    const char *ageSig = "(I)V";
    jmethodID ageMethod = env->GetMethodID(j_person_class,"setAge",ageSig);
    // 7. 正在调用 java对象函数
    const char *name = "小明";
    jstring newStringName = env->NewStringUTF(name);
    env->CallVoidMethod(person_obj,nameMethodId,newStringName);
    env->CallVoidMethod(person_obj,ageMethod,28);
    const char *sig = "()Ljava/lang/String;";
    jmethodID jtoString = env->GetMethodID(j_person_class, "toString", sig);
    jobject obj_string = env->CallObjectMethod(person_obj, jtoString);
    jstring  perStr = static_cast(obj_string);
    const char *itemStr2 = env->GetStringUTFChars(perStr,NULL);
    LOGD("Person:%s",itemStr2);
    return person_obj;
}

5.JNI动态注册

上面介绍的都是静态注册；
静态注册：优点是简单方便；
缺点：当前类定义的native方法名改变或者包改变，就需要改动cpp里的代码。动态注册可以解决这个问题。

    public native void dynamicRegister(String name);

/**
 * 对应java类的全路径名，.用/代替
 */
const char *classPathName = "com/george/myjni/MainActivity";
extern "C" // 支持c语言
JNIEXPORT void JNICALL // 告诉虚拟机，这是jni函数
native_dynamicRegister(JNIEnv *env, jobject instance, jstring name) {
    const char *j_name = env->GetStringUTFChars(name, NULL);
    LOGD("动态注册:%s", j_name)
    // 释放
    env->ReleaseStringUTFChars(name, j_name);
}
/**
 * 源码结构
 * typedef struct{
 *  const char* name;
 *  const char* signature;
 *  void* fnPtr;
 * } JNINativeMethod
 */
static const JNINativeMethod jniNativeMethod[] = {
        {"dynamicRegister", "(Ljava/lang/String;)V", (void *) (native_dynamicRegister)}
};

/**
 * 该函数定义在jni.h头文件中，System.loadLibrary()时会调用JNI_OnLoad()函数
 * @param javaVm
 * @param pVoid
 * @return
 */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *javaVm, void *pVoid) {
    // 通过虚拟机 创建全新的 env
    JNIEnv *jniEnv = nullptr;
    jint result = javaVm->GetEnv(reinterpret_cast(&jniEnv), JNI_VERSION_1_6);
    if (result != JNI_OK) {
        return JNI_ERR; // 主动报错
    }
    jclass mainActivityClass = jniEnv->FindClass(classPathName);
    jniEnv->RegisterNatives(mainActivityClass, jniNativeMethod,
                            sizeof(jniNativeMethod) / sizeof(JNINativeMethod));// 动态注册的数量
    return JNI_VERSION_1_6;
}

6.异常处理

JNI的异常行为和Java有所不同。Java抛出一个异常时，虚拟机停止执行代码块，并进入调用栈反向检查能处理特定类型异常的程序代码块，叫捕获异常。虚拟机清除异常并将控制权交给异常处理程序。相比之下，JNI要求开发人员在异常发生后显式地实现异常处理流。

   public native void dynamicRegister2(String name);

    /**
     * 测试抛出异常
     *
     * @throws NullPointerException
     */
    private void testException() throws NullPointerException {
        throw new NullPointerException("MainActivity testException NullPointerException");
    }

使用动态注册的方式，主要代码如下(具体代码参考动态注册补全)

extern "C" //支持 C 语言
JNIEXPORT void JNICALL // 告诉虚拟机，这是jni函数
native_dynamicRegister2(JNIEnv *env, jobject instance, jstring name) {
    const char *j_name = env->GetStringUTFChars(name, NULL);
    LOGD("动态注册2: %s", j_name)

    jclass clazz = env->GetObjectClass(instance);//拿到当前类的class
    jmethodID mid =env->GetMethodID(clazz, "testException", "()V");//执行 Java 测试抛出异常的代码
    env->CallVoidMethod(instance, mid); // 执行会抛出一个异常
    if(env->ExceptionCheck()){
        LOGD("检测异常")
        env->ExceptionDescribe();
        env->ExceptionClear();
        jclass newExcCls = env->FindClass("java/lang/IllegalArgumentException");
        env->ThrowNew(newExcCls, "JNI 中发生了一个异常信息"); // 返回一个新的异常到 Java
    }
//  注释掉：这种方法抓不到异常，为什么？
//    jthrowable exc = env->ExceptionOccurred(); // 检测是否发生异常，测试中直接down掉了，找不到异常信息了。
//    LOGD("动态注册2-exc: %s", exc)
//    if (exc) {//如果发生异常
//        env->ExceptionDescribe(); // 打印异常信息
//        env->ExceptionClear(); // 清除掉发生的异常
//        jclass newExcCls = env->FindClass("java/lang/IllegalArgumentException");
//        env->ThrowNew(newExcCls, "JNI 中发生了一个异常信息"); // 返回一个新的异常到 Java
//    }
    //释放
    env->ReleaseStringUTFChars(name, j_name);
}

static const JNINativeMethod jniNativeMethod2[] = {
        {"dynamicRegister2", "(Ljava/lang/String;)V", (void *) (native_dynamicRegister2)}
};

/**
 * 该函数定义在jni.h头文件中，System.loadLibrary()时会调用JNI_OnLoad()函数
 * @param javaVm
 * @param pVoid
 * @return
 */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *javaVm, void *pVoid) {
    // 通过虚拟机 创建全新的 env
    JNIEnv *jniEnv = nullptr;
    jint result = javaVm->GetEnv(reinterpret_cast(&jniEnv), JNI_VERSION_1_6);
    if (result != JNI_OK) {
        return JNI_ERR; // 主动报错
    }
    jclass mainActivityClass = jniEnv->FindClass(classPathName);
    jniEnv->RegisterNatives(mainActivityClass, jniNativeMethod,
                            sizeof(jniNativeMethod) / sizeof(JNINativeMethod));// 动态注册的数量
    jniEnv->RegisterNatives(mainActivityClass, jniNativeMethod2,
                            sizeof(jniNativeMethod2) / sizeof(JNINativeMethod));// 动态注册的数量
    return JNI_VERSION_1_6;
}

7.局部和全局引用

Java程序中，虚拟机通过追踪类实例，引用并回收不在的引用，垃圾管理类实例的使用期限。JNI提供了一组函数允许原生代码显式地管理对象引用及使用期间源代码。JNI支持三种引用：局部引用、全局引用和弱引用。
局部引用：
局部引用不能在后续的调用中被缓存及重用。如：FindClass返回局部引用，当原生方法返回时，它被自动释放，可以使用DeleteLocalRef函数显式的释放原生代码。
例如（参考上面动态注册补全）:

jclass personClass;
extern "C"  //支持 C 语言
JNIEXPORT void JNICALL //告诉虚拟机，这是jni函数
native_test4(JNIEnv *env, jobject instance) {
    LOGD("测试局部引用")
    if (personClass == NULL) {
        const char *person_class = "com/george/myjni/Person";
        personClass = env->FindClass(person_class);
        LOGD("personClass == null 执行了。")
    }
    //Java Person 构造方法实例化
    const char *sig = "()V";
    const char *method = "";//Java 构造方法标识
    jmethodID init = env->GetMethodID(personClass, method, sig);
    //创建出来
    env->NewObject(personClass, init);
}

static const JNINativeMethod jniNativeMethod3[] = {
        {"dynamicTest4", "()V", (void *) (native_test4)}
};

全局引用

jclass personClass2;
extern "C" // 支持c语言
JNIEXPORT void JNICALL // 告诉虚拟机，这是jni函数
native_test5(JNIEnv *env, jobject instance){
    LOGD("测试全局引用")
    if (personClass2 == NULL){
        // 提升全局解决不能重复使用问题
        const char *person_class = "com/george/myjni/Person";
        jclass jclass1 = env->FindClass(person_class);
        personClass2 = static_cast(env->NewGlobalRef(jclass1));
        LOGD("personClass2 == null 执行了。")
    }
    // java person 构造方法实例化
    const char *sig = "()V";
    const char *method = "";// Java 构造方法标识
    jmethodID  init = env->GetMethodID(personClass2, method, sig);
    // 创建出来
    env->NewObject(personClass2, init);
    // 显式释放主动删除全局引用
    env->DeleteLocalRef(personClass2);
    personClass2 = NULL;
}

删除全局引用：
当不再需要一个全局引用时，用DeleteGlobalRef函数释放

env->DeleteLocalRef(personClass);
personClass = NULL;

弱全局引用
并不阻止潜在的对象被垃圾回收

jclass personClass3;
extern "C"
JNIEXPORT void JNICALL
native_test6(JNIEnv *env, jobject instance){
    LOGD("测试弱全局引用")
    if (personClass3 == NULL){
        const char *person_class = "com/george/myjni/Person";
        jclass jclass1 = env->FindClass(person_class);
        personClass3 = static_cast(env->NewWeakGlobalRef(jclass1));
        LOGD("personClass == null 执行力")
    }
    const char *sig = "()V";
    const char *method = "";
    jmethodID  init = env->GetMethodID(personClass3, method, sig);
    env->NewObject(personClass3, init);
    env->DeleteWeakGlobalRef(personClass3);
    personClass3 = NULL;
}

可以用IsSameObject函数检验一个弱全局引用是否仍然指向活动的类实例。

8.JNI线程操作

  • 局部引用不能在多线程间共享，只有全局引用可以被多线程共享
  • JNIEvn接口指针不能被其它线程缓存或使用
    同步：同步是多线程设计最终特征。
    MonitorEnter函数与对MonitorExit调用匹配，避免死锁。
    public native void nativeCount();

    private void test4(){
        Log.d(TAG,"多线程");
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    count();
                    nativeCount();
                }
            }).start();
        }
    }
    private int count;
    private void count(){
        synchronized (this){
            count++;
            Log.d(TAG,"count="+count);
        }
    }

extern "C"
JNIEXPORT void JNICALL
native_count(JNIEnv *env, jobject instance){
    jclass cls = env->GetObjectClass(instance);
    jfieldID fieldId = env->GetFieldID(cls, "count","I");
    int val = env->GetIntField(instance, fieldId);
    val++;
    LOGI("count=%d",val);
    env->SetIntField(instance, fieldId, val);
}

发现运行结果多样性(有些没有打印出，有些重复打印，有些顺序不对等)，通过多线程对count字段操作，无法保证count可见性了。需要JNI本地实现同步。
通过MonitorEnter 和MonitorExit来保证count可见性(访问有序)。

extern "C"
JNIEXPORT void JNICALL
native_count(JNIEnv *env, jobject instance){
    jclass cls = env->GetObjectClass(instance);
    jfieldID fieldId = env->GetFieldID(cls, "count","I");
    if (env->MonitorEnter(instance)!=JNI_OK){
        LOGE("%s:MonitorEnter（）failed",__FUNCTION__)
    }
    int val = env->GetIntField(instance, fieldId);
    val++;
    LOGI("count=%d",val);
    env->SetIntField(instance, fieldId, val);
    if (env->ExceptionOccurred()){
        LOGE("ExceptionOccurred()...")
        if (env->MonitorExit(instance)!=JNI_OK){
            LOGE("%s:MonitorExit() failed",__FUNCTION__)
        }
    }
    if (env->MonitorExit(instance)!=JNI_OK){
        LOGE("%s:MonitorExit() failed",__FUNCTION__)
    }
}

原生线程
为了执行特定任务，原生构建可以并行使用原生线程。

JNI通过JavaVM提供AttachCurrentThread函数，JavaVM接口指针应尽早被缓存，否则不能被获取
java通过native在c++中开启子线程，然后在子线程中调用java主线程更新ui

   public void test5(){
        Log.d(TAG,"原生线程");
        testThread();
    }

    /**
     * AndroidUI操作，让C++线程里面来调用
     */
    public void updateUI(){
        if (Looper.getMainLooper() == Looper.myLooper()){
            new AlertDialog.Builder(this)
                    .setTitle("UI")
                    .setMessage("native 运行在主线程,直接更新 UI ...")
                    .setPositiveButton("确认",null)
                    .show();
        }else {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    new AlertDialog.Builder(MainActivity.this)
                            .setTitle("UI")
                            .setMessage("native 运行在子线程切换为主线程更新 UI...")
                            .setPositiveButton("确认",null)
                            .show();
                }
            });
        }
    }

    public native void testThread();
    public native void unThread();

jvm参数是在JNI_OnLoad中初始化的。

JavaVM *jvm;
jobject instance;
void *customThread(void *pVoid) {
    // 调用的话，一定需要JNIEnv *env
    // JNIEnv *env 无法跨越线程，只有JavaVM才能跨越线程
    JNIEnv *env = NULL; // 全新的env
    // jvm是在 JNI_OnLoad中初始化过的，别忘记了，否则报错
    int result = jvm->AttachCurrentThread(&env, 0); // 把native的线程，附加到JVM
    if (result != 0) {
        return 0;
    }

    jclass mainActivityClass = env->GetObjectClass(instance);

    // 拿到MainActivity的updateUI
    const char *sig = "()V";
    jmethodID updateUI = env->GetMethodID(mainActivityClass, "updateUI", sig);

    env->CallVoidMethod(instance, updateUI);

    // 解除 附加 到 JVM 的native线程
    jvm->DetachCurrentThread();

    return 0;
}

extern "C"
JNIEXPORT void JNICALL
native_testThread(JNIEnv *env, jobject thiz) {
    LOGD("native_testThread")
    instance = env->NewGlobalRef(thiz);// 全局的就不会被释放，所以可以在线程里面用
    // 如果非全局的，函数一结束，就被释放了
    pthread_t pthreadID;
    pthread_create(&pthreadID, 0, customThread, instance);
    pthread_join(pthreadID, 0);
    LOGD("native_testThread-end")
}

extern "C"
JNIEXPORT void JNICALL
native_unThread(JNIEnv *env, jobject thiz) {
    if (NULL != instance) {
        env->DeleteGlobalRef(instance);
        instance = NULL;
    }
}
/**
 * 该函数定义在jni.h头文件中，System.loadLibrary()时会调用JNI_OnLoad()函数
 * @param javaVm
 * @param pVoid
 * @return
 */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *javaVm, void *pVoid) {
    jvm = javaVm;
    // 通过虚拟机 创建全新的 env
    JNIEnv *jniEnv = nullptr;
    jint result = javaVm->GetEnv(reinterpret_cast(&jniEnv), JNI_VERSION_1_6);
    if (result != JNI_OK) {
        return JNI_ERR; // 主动报错
    }
    jclass mainActivityClass = jniEnv->FindClass(classPathName);
    jniEnv->RegisterNatives(mainActivityClass, jniNativeMethod9,
                            sizeof(jniNativeMethod9) / sizeof(JNINativeMethod));// 动态注册的数量
    return JNI_VERSION_1_6;
}

总结

JNI技术实现Java应用程序与原生代码通信。

你可能感兴趣的:(音视频学习(一)JNI入门)

  • .NET Core属性依赖注入的3大秘密，你猜对了几个？ 墨瑾轩 C#乐园.netcore
    关注墨瑾轩，带你探索编程的奥秘！超萌技术攻略，轻松晋级编程高手技术宝库已备好，就等你来挖掘订阅墨瑾轩，智趣学习不孤单即刻启航，编程之旅更有趣嘿，小伙伴们！今天我们要深入探讨的是.NETCore中的一个神秘武器——属性依赖注入（PropertyDependencyInjection,DI）。你知道吗？虽然它不像构造函数注入那样被广泛推崇，但在某些特定场景下，属性注入却能发挥意想不到的作用。那么问题来
  • 【项目实战】Electron最佳实践 本本本添哥 007-大前端技术electronjavascript前端
    一、Electron的入门介绍1.1Electron是什么？Electron由GitHub开发团队创建，最初是为了构建GitHub客户端而设计的。Electron是一个开源的框架，用于构建跨平台桌面应用程序。Electron是一个强大的框架，它可以帮助您使用Web技术构建跨平台桌面应用程序。Electron是一个流行的跨平台框架，可以使用HTML、CSS和JavaScript构建桌面应用程序。1.
  • 【PyQt】学习PyQt进行GUI开发从基础到进阶逐步掌握详细路线图和关键知识点 shanks66 pyqtpython
    学习PyQt的必要性PyQt是开发跨平台GUI应用的强大工具，适合需要构建复杂、高性能界面的开发者。无论是职业发展还是项目需求，学习PyQt都具有重要意义。1.跨平台GUI开发跨平台支持：PyQt基于Qt框架，支持Windows、macOS、Linux等多个平台，开发的应用可以轻松移植。统一代码库：只需维护一套代码，减少跨平台开发的复杂性。2.丰富的UI组件多样化控件：PyQt提供按钮、文本框、表
  • PHP DateTime基础用法 CodingBrother PHPphp
    PHPDateTime的用法详解一、引言在开发PHP应用程序时，处理日期和时间是一个至关重要的任务。PHP提供了强大的日期和时间处理功能，其中DateTime类是最常用的工具之一。DateTime类提供了丰富的方法来创建、格式化、计算和比较日期时间，使得处理时间变得简单而高效。本文将深入探讨PHP的DateTime类，包括其基本用法、常见方法、格式化、时区处理以及实际应用示例。二、DateTime
  • 分词实现小案例 CodingBrother 性能优化架构架构中文分词
    MySQL并不是一个专门设计用于处理自然语言处理（NLP）或文本分词的数据库，但可以通过一些方法和技巧实现基本的分词功能，尤其是在处理中文文本或其他语言的应用场景中。以下是一些在MySQL中实现分词的常用方案和设计策略。1.使用FULLTEXT索引MySQL提供了FULLTEXT索引，允许在文本字段上进行全文搜索。此功能可以在英文等语言中有效支持分词。创建FULLTEXT索引CREATETABLE
  • c++背包九讲之二维费用背包问题 永不为辅
    一、背包九讲总述关于动态规划问题，最典型的就是背包九讲，先理解背包九讲后再总结关于动态规划的问题1、01背包问题2、完全背包问题3、多重背包问题4、混合背包问题5、二维费用的背包问题6、分组背包问题7、背包问题求方案数8、求背包问题的方案9、有依赖的背包问题往前四篇博文已经介绍了前四个问题，有需要的同学可以看一下！！二、二维费用背包问题二维费用的背包问题是指：对于每件物品，具有两种不同的费用，选择
  • spring mysql jdbc insert 占位符_深入浅出JDBC(三) - Spring JdbcTemplate weixin_39943000 springmysqljdbcinsert占位符
    上一次我们讨论了Dbutils的用法，其实现原理很简单，就是对JDBC的原始操作进行封装。但是无论什么操作，首先得创建Connection或者DataSource对象。在业务项目的开发中，手动地创建和销毁Connection比较繁琐，且不能充分地利用资源。于是有了连接池DBCP和C3P0两个框架的出现，但是业务开发过程中，对连接资源的获取和释放同业务是完全无关的，那能不能就不关心连接的获取和释放，
  • python之异常处理_Python 简明教程 --- 23，Python 异常处理 weixin_39853968 python之异常处理
    要么做第一个，要么做最好的一个。目录我们在编写程序时，总会不自觉的出现一些错误，比如逻辑错误，语法错误和一些其它的运行时错误等。逻辑错误：这种错误不会导致程序崩溃，它不容易被发现，只有在执行结果不是我们预期的时候，才会被发现。语法错误：这种错误是不符合语法规定的错误，说白了，就是编译器或者解释器无法理解的代码。出现这种错误时，程序是不能运行的。其它运行时错误：这种错误是程序在运行的过程中出现的，一
  • 多维多重背包问题_各种背包五（二维费用背包问题） zLiM5 多维多重背包问题
    问题二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值(背包容量)。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值(两种背包容量)分别为V和U。物品的价值为w[i]。算法费用加了一维，只需状态也加一维即可。设f[i][v][u]
  • 动态规划-二维费用的背包问题 炙热的大叔 动态规划动态规划算法
    文章目录1.一和零（474）2.盈利计划（879）1.一和零（474）题目描述：状态表示：我们之前的01背包问题以及完全背包问题都是一维的，因为我们只有一个要求或者说是限制那就是背包的容量，但是这里不同这题有两个限制，其实和一个限制是类似的，只不过给数组多加上一维而已。因此我们建立三维数组dp[i][j][k]表示我们在前i个二进制字符串中选择，要求选中的字符串中的0以及1字符的总数分别不能超过i
  • 【二维费用的完全背包问题】 羊毛多一点 算法学习动态规划
    前言简单写一下算法设计与分析这门课的一次实验原题要求是用0-1背包来做，但是老师要求用完全背包来做！一、完全背包与0-1背包有什么区别？0-1背包，顾名思义对于每件物品只能拿1次或者0次；而完全背包对于每件物品的拿取没有次数限制。二、二维费用背包二维费用背包是对于每件物品的拿取要付出两项代价，如：重量和体积。三、0-1背包理解0-1背包对我们理解其他背包问题十分重要，首先说一下0-1背包。问题描述
  • 使用mongodb进行文章的存储 薛定谔的猫1982 mongodb数据库mongodb
    简单文档存储存储思路：把文章或页面信息拆分成标题、正文、作者等字段，组成一个文档，每个文档对应一篇文章或一个页面。示例文档{"title":"技术新趋势","author":"李华","content":"近期技术领域呈现出诸多新趋势……","publish_date":"2025-02-03"}操作步骤：使用MongoDB客户端（如MongoShell），连接数据库后选择集合，用insertOn
  • 【背包问题】二维费用背包问题 HeyBlog 数据结构与算法背包问题动态规划算法
    一、问题二维费用的背包问题是指：对于每件物品，具有两种不同的费用，选择这件物品必须同时付出这两种费用。对于每种费用都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设第iii件物品所需的两种费用分别为CiC_iCi和DiD_iDi。两种费用可付出的最大值（也即两种背包容量）分别为VVV和UUU。物品的价值为WiW_iWi。二、思路费用加了一维，只需状态也加一维即可。设dp[i]
  • 第一章 什么是JavaScript Sheldon一蓑烟雨任平生 开发语言JavaScriptJavaScript基础ECMAScript什么是JavaScript
    第一章什么是JavaScript1.历史梗概2.JavaScript的实现（ECMAScript、DOM、BOM）2.1ECMAScript2.2DOM（文档对象模型）2.3BOM（浏览器对象模型，在第12章会有详细介绍）3.支持（所有浏览器基本都支持ES5）1.历史梗概（1）初始目的：代替服务器语言，作为脚本语言，在客户端处理输入验证，判断输入值是否填写及其有效性；（2）开发时间：1995年；（
  • LoongArch32 指令集探索学习1：初入龙芯 星林湖月 龙芯学习
    1.1.发现问题1.1.LoongArch是个啥？龙芯这个名字一听就是咱这龙的传人该用的东西，这是从MIPS指令集中新设计的指令集，官方名字叫LoongArch，简称LA。这个指令集分为开放的LoongArch32精简版和LoongArch64，前者的32位指令集全部开源，后者64位只开放基础指令集，高级部分的二进制翻译暂且没有详细文档，而是由开发者在对GCC、Linux等基础软件贡献中露出。为何
  • Nuxt后端接口实战：从0到1连接MongoDB数据库 2KMnO₄ nuxt数据库前端mongodbvue
    总所周知next框架是一个全栈框架，可以一把梭哈，同时nuxt也支持编写后端接口。网上有很多nuxt教程但是我注意到对于nuxt后端接口的教程比较少，所以我决定写一篇关于nuxt链接数据库编写后端接口的文章，数据库的选择就使用MongoDB。1·安装相关库首先我们需要安装一些依赖mongoose和dotenv，当然dotenv并不是必须的，但是我建议使用dotenv来管理环境变量，这样可以更好的保
  • Spring 事务与 MySQL 事务：深度解析与实战指南 一叶飘零_sweeeet 果酱紫springmysqlspringmysqljava
    一、引言在企业级应用开发中，事务处理是确保数据一致性和完整性的关键环节。Spring框架作为广泛应用的Java开发框架，提供了强大的事务管理功能。而MySQL作为流行的关系型数据库，也具备完善的事务支持。本文将深入探讨Spring事务与MySQL事务的原理、特性、使用方法以及在实际项目中的应用，帮助开发者更好地理解和运用事务处理机制，确保应用的可靠性和数据的准确性。二、事务的基本概念（一）什么是事
  • 第06章 07 VTK体绘制中的2D纹理映射和3D纹理映射 捕鲸叉 VTK编程学习3dVTK信息可视化
    在VTK（VisualizationToolkit）中，体绘制是一种将三维数据转换为二维图像的技术，VTK提供了多种方法来实现体绘制，其中2DTexture-Mapped和3DTexture-Mapped技术是两种常见且重要的技术。下面将分别介绍这两种技术的特点和应用场合，并提供C++示例代码。2DTexture-Mapped技术2DTexture-Mapped技术在VTK中通常用于切片渲染。在这
  • 从0开始C语言（7） 岁ovo寒 c语言算法c++
    二维数组查找#includevoidfind(intA[][3],introws,intcols,int*max_value,int*max_row,int*max_col){*max_value=A[0][0];//初始假设第一个元素是最大值；*max_row=0;*max_col=0;for(inti=0;i*max_value){*max_value=A[i][j];*max_row=i;*
  • 从0开始C语言（2） 岁ovo寒 c语言开发语言
    宏定义众所周知，头文件是扩展名为.h的文件，包含了C函数声明和宏定义，被多个源文件中引用共享。那么什么是宏定义呢？宏定义是C语言中的一种预处理器功能，用于在代码编译之前进行文本替换和条件编译。以下是对宏定义的详细介绍：基本概念宏定义：宏定义通过#define指令实现，用于将一个标识符（宏名）定义为一个字符串或代码片段。在预处理阶段，所有出现的宏名都会被替换为定义的字符串。宏替换：预处理程序将所有出
  • 潜水员 ← 二维费用的背包问题 hnjzsyjyj 信息学竞赛#动态规划二维费用的背包问题
    【题目来源】https://www.acwing.com/problem/content/1022/【题目描述】潜水员为了潜水要使用特殊的装备。他有一个带2种气体的气缸：一个为氧气，一个为氮气。让潜水员下潜的深度需要各种数量的氧和氮。潜水员有一定数量的气缸。每个气缸都有重量和气体容量。潜水员为了完成他的工作需要特定数量的氧和氮。他完成工作所需气缸的总重的最低限度的是多少？例如：潜水员有5个气缸。每
  • ssGSEA中GSVA调用报错的解决方法 影林握雪 生信R语言r语言大数据r语言-4.2.1chatgpt笔记经验分享AI编程
    ssGSEA中GSVA调用报错问题expr是表达谱，表达数据矩阵，行是基因，列是样本。cellMarker是一个包含基因集的列表。在R中使用GSVA的2.0.2版本gsva_data<-gsva(expr,cellMarker,method="ssgsea")会报错：Callinggsva(expr=.,gset.idx.list=.,method=.,…)isdefunct;useamethod
  • M｜一一 影林握雪 其他
    rating:9.0豆瓣:9.1M｜一一2000/剧情家庭/中国台湾日/173m两个一，支棱起来是“人”，躺下去是“死”——从生到死。如果人只能看到事物的一半，那么出生的时候不就接近死亡了吗？小的时候我们以为长大了能看清事物的全貌，可历经沧桑我们才明白“人”的缺陷，接受人生的苦痛。诚如大田君，记下所有牌面才有了魔术。《这个杀手不太冷》里的台词很合适：Dialogue:人生总是这么痛苦吗?Islif
  • M｜完美的日子 影林握雪 其他
    rating:9.5豆瓣:8.5上映时间:"2023""2024"类型:M剧情音乐导演:维姆·文德斯WimWenders主演:役所广司KôjiYakusho国家/地区:日本德国片长/分钟:125分钟M｜完美的日子上善若水，佳人如木。物质是快乐下限，精神是幸福上限。文青男死前的幻想。原谅我给9.5吧，不过是一个死文青罢了，他还期望什么呢。音乐很喜欢。这个电影有两大争议点，主要的一点是一个东亚的厕所清
  • 安心即美的生活方式 CIb0la 生活程序人生
    如果你的心是安定的，那么，外界也就安静了。就像陶渊明说的：心远地自偏。不是走到偏远无人的边荒才能得到片刻清净，不需要使用洪荒之力去挣脱生活的枷锁，这是陶渊明式的中国知识分子的雅量。如果你自己是好的男人或女人，那么，你就会遇见好的女人或男人。如果你的心是喜乐的，那么，无论做什么，即使只是随便走一走，你也会变得很健康。如果你的心是美丽的，那么你只要做回你自己，做回上苍赋予你的那个样子，你就是美丽的。不
  • 【数据结构与算法】力扣 5. 最长回文子串 秀秀_heo 数据结构与算法leetcode算法职场和发展
    题目描述5.最长回文子串给你一个字符串s，找到s中最长的回文子串。示例1：输入：s="babad"输出："bab"解释："aba"同样是符合题意的答案。示例2：输入：s="cbbd"输出："bb"提示：1=0&&rightmaxLen){start=oddStart;maxLen=oddLen;}//处理偶数长度回文let[evenStart,evenLen]=expandAroundCenter
  • 探索Web3世界：算法与挖矿详解 Java先进事迹 web3算法
    哈希算法：区块链的“数字指纹”区块链的结构类似于链表，数据块一个连着一个，链接在一条或多条链上。每个数据块都至少记录着数据、自己的地址和前一个数据块的地址。每个数据块的“地址”的编码都是独一无二的，通过一种称为哈希算法的技术生成。哈希算法能够将任意长度的数据映射为一个固定长度的唯一编码（哈希值）。即使输入数据发生微小变化，生成的哈希值也会截然不同。我们可以将哈希算法比作一台神奇的调色机。无论你放入
  • 全网最全JAVA面试八股文，终于整理完了 Java先进事迹 面试java职场和发展springbootspringjava-eemaven
    前言又到一年金三银四面试跳槽季，你准备好了吗？今天为大家整理了目前互联网出现率最高的大厂面试题，所谓八股文也就是指文章的八个部分，文体有固定格式:由破题、承题、起讲、入题、起股、中股、后股、束股八部分组成，题目一律出自四书五经中的原文。而JAVA面试八股文也就是为了考验大家的JAVA基础功底，所以强烈建议背诵全文。1、并发编程三要素？（1）原子性原子性指的是一个或者多个操作，要么全部执行并且在执行
  • c++ · binarySearch ( 二分法 ) Le_ee c++算法蓝桥杯c语言
    2025.2.3一：过程二分例1：查找有序数组中某个元素；intbinarySearch(vector&arr,inttarget){//接受有序数组arr和目标值targetintleft=0,right=arr.size()-1;//定义左指针指向数组起始位置（即0下标），右指针为数组最后一个元素的下标while(left&arr,inttarget){intleft=0,right=arr.
  • 关于博弈论 总思霖 概率论论文笔记
    最近看了一本书叫《消失的凶手》，里面的侦探邓教授在某一次探案中与未实施犯罪的凶手玩了读数游戏运用到博弈论，阻止了一场悲剧的发生，借此我了解了一些关于博弈论的知识。博弈论有许多种，如：零和博弈&非零和博弈：博弈双方的收益总和为零，一方的利益的增加就意味着另一方利益的减少；博弈双方的收益总和不为零，可以存在双赢的情况。顺序博弈&同时博弈：博弈双方的行动是依次进行的，每个人的行动都受之前人的行动所影响；
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他