Java JNI 编程进阶

原文：http://www.iteye.com/topic/295776

JNI一直以来都很少去关注，但却是我心中的一个结，最近这几天刚好手头有点时间，因此抽空看了一下这方面的东西，整理了一份文档，JNI技术的出现主要是基于三个方面的应用需求：

1.
解决性能问题
Java具有平台无关性，这使人们在开发企业级应用的时候总是把它作为主要候选方案之一，但是性能方面的因素又大大削弱了它的竞争力。为此，提高Java的性能就显得十分重要。Sun公司及Java的支持者们为提高Java的运行速度已经做出了许多努力，其中大多数集中在程序设计的方法和模式选择方面。由于算法和设计模式的优化是通用的，对Java有效的优化算法和设计模式，对其他编译语言也基本同样适用，因此不能从根本上改变Java程序与编译型语言在执行效率方面的差异。由此，于是人们开始引入JIT(Just
In
Time，及时编译)的概念。它的基本原理是：首先通过Java编译器把Java源代码编译成平台无关的二进制字节码。然后在Java程序真正执行之前，系统通过JIT编译器把Java的字节码编译为本地化机器码。最后，系统执行本地化机器码，节省了对字节码进行解释的时间。这样做的优点是大大提高了Java程序的性能，缩短了加载程序的时间；同时，由于编译的结果并不在程序运行间保存，因此也节约了存储空间。缺点是由于JIT编译器对所有的代码都想优化，因此同样也占用了很多时间。

动态优化技术是提高Java性能的另一个尝试。该技术试图通过把Java源程序直接编译成机器码，以充分利用Java动态编译和静态编译技术来提高Java的性能。该方法把输入的Java源码或字节码转换为经过高度优化的可执行代码和动态库
(Windows中的. dll文件或Unix中的. so文件)。该技术能大大提高程序的性能，但却破坏了Java的可移植性。

JNI(Java Native Interface,
Java本地化方法)技术由此闪亮登场。因为采用JNI技术只是针对一些严重影响Java性能的代码段，该部分可能只占源程序的极少部分，所以几乎可以不考虑该部分代码在主流平台之间移植的工作量。同时，也不必过分担心类型匹配问题，我们完全可以控制代码不出现这种错误。此外，也不必担心安全控制问题，因为Java安全模型已扩展为允许非系统类加载和调用本地方法。根据Java规范，从JDK
1. 2开始，FindClass将设法找到与当前的本地方法关联的类加载器。如果平台相关代码属于一个系统类，则无需涉及任何类加载器;
否则，将调用适当的类加载器来加载和链接已命名的类。换句话说，如果在Java程序中直接调用C/C++语言产生的机器码，该部分代码的安全性就由Java虚拟机控制。

2.
解决本机平台接口调用问题
JAVA以其跨平台的特性深受人们喜爱，而又正由于它的跨平台的目的，使得它和本地机器的各种内部联系变得很少，约束了它的功能。解决JAVA对本地操作的一种方法就是JNI。JAVA通过JNI调用本地方法，而本地方法是以库文件的形式存放的（在WINDOWS平台上是DLL文件形式，在UNIX机器上是SO文件形式）。通过调用本地的库文件的内部方法，使JAVA可以实现和本地机器的紧密联系，调用系统级的各接口方法。

3. 嵌入式开发应用
“一次编程，到处使用”的Java软件概念原本就是针对网上嵌入式小设备提出的，几经周折，目前SUN公司已推出了J2ME(Java
2 P1atform Micro
Edition)针对信息家电的Java版本，其技术日趋成熟，开始投入使用。SUN公司Java虚拟机(JVM)技术的有序开放，使得Java软件真正实现跨平台运行，即Java应用小程序能够在带有JVM的任何硬软件系统上执行。加上Java语言本身所具有的安全性、可靠性和可移植性等特点，对实现瘦身上网的信息家电等网络设备十分有利，同时对嵌入式设备特别是上网设备软件编程技术产生了很大的影响。也正是由于JNI解决了本机平台接口调用问题，于是JNI在嵌入式开发领域也是如火如荼。

不失直观性，我们首先写一个JNI小例子：

Java代码  

  1. public class HelloJni {

  2. public native void displayHelloJni();

  3. static {

  4. System.loadLibrary("helloJni");

  5. }

  6. public static void main(String[] args) {

  7. //System.out.println(System.getProperty("java.library.path"));

  8. new HelloJni().displayHelloJni();

  9. }

  10. }

在class文件生成的相应目录执行命令如下：
----------------------------------------------------
E:\projects\jni\target\classes>javah
HelloJni
----------------------------------------------------

得到C++文件HelloJni.h

Cpp代码  

  1. /* DO NOT EDIT THIS FILE - it is machine generated */

  2. #include <jni.h>

  3. /* Header for class HelloJni */

  4. #ifndef _Included_HelloJni

  5. #define _Included_HelloJni

  6. #ifdef __cplusplus

  7. extern "C" {

  8. #endif

  9. /*

  10. * Class:     HelloJni

  11. * Method:    displayHelloJni

  12. * Signature: ()V

  13. */

  14. JNIEXPORT void JNICALL Java_HelloJni_displayHelloJni

  15. (JNIEnv *, jobject);

  16. #ifdef __cplusplus

  17. }

  18. #endif

  19. #endif

JNI函数名称分为三部分：首先是Java关键字，供Java虚拟机识别；然后是调用者类名称(全限定的类名，其中用下划线代替名称分隔符)；最后是对应的方法名称，各段名称之间用下划线分割。

JNI函数的参数也由三部分组成：首先是JNIEnv
*,是一个指向JNI运行环境的指针；第二个参数随本地方法是静态还是非静态而有所不同一一非静态本地方法的第二个参数是对对象的引用，而静态本地方法的第二个参数是对其Java类的引用；其余的参数对应通常Java方法的参数，参数类型需要根据一定规则进行映射。

编写C++文件HelloJni.h的实现类，我是比较常用VC6.0来生成dll文件（helloJni.dll）的

Cpp代码  

  1. #include <jni.h>

  2. #include "HelloJni.h"

  3. #include <stdio.h>

  4. JNIEXPORT void JNICALL

  5. Java_HelloJni_displayHelloJni(JNIEnv *env, jobject obj)

  6. {

  7. printf("Hello Dynamic Link Library has been calling!\n");

  8. printf("Java_HelloJni_displayHelloJni method has been executed!\n");

  9. return;

  10. }

其实此时，我们的工程目前还暂时不能生成我们想要的 helloJni.dll 文件，问题就出在了“#include
<jni.h>”。由于VC6.0里没有我们需要的“jni.h”文件，因此就需要手动加入到VC6.0的环境中去。在JAVA_HOME路径下我们可以找到include文件夹，其中就可以找到我们需要的“jni.h”文件。为了避免以后麻烦起见，将所有的C++文件全部拿出来，放在“%CPP_HOME%\VC98\Include”路径下。然后将工程进行打包就可以得到我们需要的“helloJni.dll”文件了。

将helloJni.dll文件放置于工程classes目录，执行命令如下：
-----------------------------------------------
E:\projects\jni\target\classes>java
HelloJni
-----------------------------------------------

运行结果如下：
-----------------------------------------------------------------
Hello
Dynamic Link Library has been calling!
Java_HelloJni_displayHelloJni method
has been
executed!
-----------------------------------------------------------------

但是要想在eclipse中运行helloJni.dll文件，就需要将文件拷贝到工程的根目录，或者将其放在诸如C:\WINDOWS\system32;C:\WINDOWS;等目录下。因为，eclipse在运行helloJni.dll文件时首先会去在当前根目录找，如果找不到则在path上去找，因此你还可以为了方便管理生成的dll文件，将所有工程中的dll文件都放到一个特定的目录，然后将该目录加入到你的本地path环境变量中去，这样每次只需要将生成的dll文件放入path目录下就可以访问了。注，如果需要加环境变量最好在加好以后重新启动一下eclipse，确保eclipse能够加载到最新的path环境。

接下来，对小例子进行重构：
1. 新增一个基础类

Java代码  

  1. package org.danlley.jni.test;

  2. public class BaseClass {

  3. public BaseClass(String arg) {

  4. loadLibrary(arg);

  5. }

  6. private static void loadLibrary(String arg) {

  7. System.loadLibrary(arg);

  8. }

  9. }

2. 定义新类继承基础类

Java代码  

  1. package org.danlley.jni.test;

  2. public class HelloJniTest extends BaseClass {

  3. public HelloJniTest(String arg){

  4. super(arg);

  5. }

  6. public native void displayHelloJni();

  7. }

3. 编写调用类

Java代码  

  1. package org.danlley.jni.test;

  2. public class RunMain {

  3. public static void main(String[] args) {

  4. new HelloJniTest("helloJniTest").displayHelloJni();

  5. }

  6. }

此次，将dll文件定义为：helloJniTest.dll。

执行结果：
------------------------------------------------------------------------------------
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni
has been
called!
------------------------------------------------------------------------------------

例子相当简单，没有传入参数，也没有返回值，那么是不是可以让本地方法返回一些参数，同时又可以传入数据进行处理，并把处理结果返回给方法的调用者呢，先拿基本类型开刀。接下来对
HelloJniTest 继续进行改造：新增两个本地方法，如下：

Java代码  

  1. package org.danlley.jni.test;

  2. public class HelloJniTest extends BaseClass {

  3. public HelloJniTest(String arg){

  4. super(arg);

  5. }

  6. public native void displayHelloJni();

  7. public native int getDynamicIntDataNoParam();

  8. public native int getDynamicIntData(int i);

  9. }

重新生成org_danlley_jni_test_HelloJniTest.h文件，并改写其实现类org_danlley_jni_test_HelloJniTest.cpp如下：

Cpp代码  

  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.

  2. //

  3. //////////////////////////////////////////////////////////////////////

  4. #include "org_danlley_jni_test_HelloJniTest.h"

  5. #include <jni.h>

  6. #include <stdio.h>

  7. JNIEXPORT void JNICALL

  8. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)

  9. {

  10. printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");

  11. return;

  12. }

  13. JNIEXPORT jint JNICALL

  14. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)

  15. {

  16. return 65535;

  17. }

  18. JNIEXPORT jint JNICALL

  19. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)

  20. {

  21. i*=i;

  22. return i;

  23. }

修改 RunMain 类：

Java代码  

  1. package org.danlley.jni.test;

  2. public class RunMain {

  3. public static void main(String[] args) {

  4. HelloJniTest tester=new HelloJniTest("helloJniTest");

  5. tester.displayHelloJni();

  6. int i=tester.getDynamicIntDataNoParam();

  7. System.out.println("tester.getDynamicIntDataNoParam()="+i);

  8. int j=tester.getDynamicIntData(100);

  9. System.out.println("tester.getDynamicIntData(100)="+j);

  10. }

  11. }

运行RunMain：

-----------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni
has been
called!
-----------------------------------------------------------------------

OK，一切正常。

还是不过瘾，简单对象可以处理了，如果是一个java对象，还可以处理吗，答案是当然可以，接下来我们来继续对 helloJniTest
类进行改造。新增一个方法如下：

Java代码  

  1. package org.danlley.jni.test;

  2. public class HelloJniTest extends BaseClass {

  3. public HelloJniTest(String arg){

  4. super(arg);

  5. }

  6. public native void displayHelloJni();

  7. public native int getDynamicIntDataNoParam();

  8. public native int getDynamicIntData(int i);

  9. public native String getDynamicStringData(String arg);

  10. }

重新生成org_danlley_jni_test_HelloJniTest.h文件：

Cpp代码  

  1. /* DO NOT EDIT THIS FILE - it is machine generated */

  2. #include <jni.h>

  3. /* Header for class org_danlley_jni_test_HelloJniTest */

  4. #ifndef _Included_org_danlley_jni_test_HelloJniTest

  5. #define _Included_org_danlley_jni_test_HelloJniTest

  6. #ifdef __cplusplus

  7. extern "C" {

  8. #endif

  9. /*

  10. * Class:     org_danlley_jni_test_HelloJniTest

  11. * Method:    displayHelloJni

  12. * Signature: ()V

  13. */

  14. JNIEXPORT void JNICALL Java_org_danlley_jni_test_HelloJniTest_displayHelloJni

  15. (JNIEnv *, jobject);

  16. /*

  17. * Class:     org_danlley_jni_test_HelloJniTest

  18. * Method:    getDynamicIntDataNoParam

  19. * Signature: ()I

  20. */

  21. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam

  22. (JNIEnv *, jobject);

  23. /*

  24. * Class:     org_danlley_jni_test_HelloJniTest

  25. * Method:    getDynamicIntData

  26. * Signature: (I)I

  27. */

  28. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData

  29. (JNIEnv *, jobject, jint);

  30. /*

  31. * Class:     org_danlley_jni_test_HelloJniTest

  32. * Method:    getDynamicStringData

  33. * Signature: (Ljava/lang/String;)Ljava/lang/String;

  34. */

  35. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData

  36. (JNIEnv *, jobject, jstring);

  37. #ifdef __cplusplus

  38. }

  39. #endif

  40. #endif

改写org_danlley_jni_test_HelloJniTest.cpp文件：

Cpp代码  

  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.

  2. //

  3. //////////////////////////////////////////////////////////////////////

  4. #include "org_danlley_jni_test_HelloJniTest.h"

  5. #include <jni.h>

  6. #include <stdio.h>

  7. JNIEXPORT void JNICALL

  8. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)

  9. {

  10. printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");

  11. return;

  12. }

  13. JNIEXPORT jint JNICALL

  14. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)

  15. {

  16. return 65535;

  17. }

  18. JNIEXPORT jint JNICALL

  19. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)

  20. {

  21. i*=i;

  22. return i;

  23. }

  24. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData

  25. (JNIEnv *env, jobject obj, jstring arg){

  26. //Get the native string from javaString

  27. const char *nativeString = env->GetStringUTFChars(arg, 0);

  28. printf("%s", nativeString);

  29. //DON‘T FORGET THIS LINE!!!

  30. env->ReleaseStringUTFChars(arg, nativeString);

  31. return arg;

  32. }

重新对C++工程打包成dll文件，运行结果：
---------------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
tester.getDynamicStringData=My
first String test
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has
been called!
My first String
test
---------------------------------------------------------------------------

我们不仅把Java的一个String对象成功的传给了dll，而且还将处理后的结果返回了出来。

但是总觉得还是不够，那我们就再来个比较复杂的对象把，我们这次将一个整形数组通过java传给dll，看看是不是也可以处理，继续还是对
helloJniTest 类进行改造，新增一个方法：

Java代码  

  1. package org.danlley.jni.test;

  2. public class HelloJniTest extends BaseClass {

  3. public HelloJniTest(String arg){

  4. super(arg);

  5. }

  6. public native void displayHelloJni();

  7. public native int getDynamicIntDataNoParam();

  8. public native int getDynamicIntData(int i);

  9. public native String getDynamicStringData(String arg);

  10. public native int[] getDynamicArrayData(int[] args);

  11. }

重新生成org_danlley_jni_test_HelloJniTest.h文件

Cpp代码  

  1. /* DO NOT EDIT THIS FILE - it is machine generated */

  2. #include <jni.h>

  3. /* Header for class org_danlley_jni_test_HelloJniTest */

  4. #ifndef _Included_org_danlley_jni_test_HelloJniTest

  5. #define _Included_org_danlley_jni_test_HelloJniTest

  6. #ifdef __cplusplus

  7. extern "C" {

  8. #endif

  9. /*

  10. * Class:     org_danlley_jni_test_HelloJniTest

  11. * Method:    displayHelloJni

  12. * Signature: ()V

  13. */

  14. JNIEXPORT void JNICALL Java_org_danlley_jni_test_HelloJniTest_displayHelloJni

  15. (JNIEnv *, jobject);

  16. /*

  17. * Class:     org_danlley_jni_test_HelloJniTest

  18. * Method:    getDynamicIntDataNoParam

  19. * Signature: ()I

  20. */

  21. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam

  22. (JNIEnv *, jobject);

  23. /*

  24. * Class:     org_danlley_jni_test_HelloJniTest

  25. * Method:    getDynamicIntData

  26. * Signature: (I)I

  27. */

  28. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData

  29. (JNIEnv *, jobject, jint);

  30. /*

  31. * Class:     org_danlley_jni_test_HelloJniTest

  32. * Method:    getDynamicStringData

  33. * Signature: (Ljava/lang/String;)Ljava/lang/String;

  34. */

  35. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData

  36. (JNIEnv *, jobject, jstring);

  37. /*

  38. * Class:     org_danlley_jni_test_HelloJniTest

  39. * Method:    getDynamicArrayData

  40. * Signature: ([I)[I

  41. */

  42. JNIEXPORT jintArray JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicArrayData

  43. (JNIEnv *, jobject, jintArray);

  44. #ifdef __cplusplus

  45. }

  46. #endif

  47. #endif

改写org_danlley_jni_test_HelloJniTest.cpp文件：

Cpp代码  

  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.

  2. //

  3. //////////////////////////////////////////////////////////////////////

  4. #include "org_danlley_jni_test_HelloJniTest.h"

  5. #include <jni.h>

  6. #include <stdio.h>

  7. JNIEXPORT void JNICALL

  8. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)

  9. {

  10. printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");

  11. return;

  12. }

  13. JNIEXPORT jint JNICALL

  14. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)

  15. {

  16. return 65535;

  17. }

  18. JNIEXPORT jint JNICALL

  19. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)

  20. {

  21. i*=i;

  22. return i;

  23. }

  24. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData

  25. (JNIEnv *env, jobject obj, jstring arg){

  26. //Get the native string from javaString

  27. const char *nativeString = env->GetStringUTFChars(arg, 0);

  28. printf("%s", nativeString);

  29. //DON‘T FORGET THIS LINE!!!

  30. env->ReleaseStringUTFChars(arg, nativeString);

  31. return arg;

  32. }

  33. JNIEXPORT jintArray JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicArrayData

  34. (JNIEnv *env, jobject  obj, jintArray args){

  35. jint buf[10];

  36. jint i;

  37. env->GetIntArrayRegion(args, 0, 10, buf);

  38. jint j=0;

  39. for (i = 0; i < 10; i++) {

  40. j=buf[i];

  41. j*=j;

  42. buf[i]=j;

  43. }

  44. env->SetIntArrayRegion(args, 0, 10, buf);

  45. return args;

  46. }

改写RunMain：

Java代码  

  1. package org.danlley.jni.test;

  2. public class RunMain {

  3. public static void main(String[] args) {

  4. HelloJniTest tester = new HelloJniTest("helloJniTest");

  5. tester.displayHelloJni();

  6. int i = tester.getDynamicIntDataNoParam();

  7. System.out.println("tester.getDynamicIntDataNoParam()=" + i);

  8. int j = tester.getDynamicIntData(100);

  9. System.out.println("tester.getDynamicIntData(100)=" + j);

  10. String str = tester.getDynamicStringData("My first String test");

  11. System.out.println("tester.getDynamicStringData=" + str);

  12. int[] args_int = new int[10];

  13. for (int ii = 0; ii < 10; ii++) {

  14. args_int[ii] = ii;

  15. }

  16. int[] args_arr = tester.getDynamicArrayData(args_int);

  17. for (int ii = 0; ii < 10; ii++) {

  18. System.out.println(args_arr[ii]);

  19. }

  20. }

  21. }

运行结果：
--------------------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
tester.getDynamicStringData=My
first String
test
0
1
4
9
16
25
36
49
64
81
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni
has been called!
My first String
test
--------------------------------------------------------------------------------

参考资料：

http://en.wikipedia.org/wiki/Java_Native_Interface
http://www.yesky.com/20011004/199789.shtml
http://www.21ic.com/news/html/63/show13260.htm
http://java.ccidnet.com/art/297/20060228/439729_1.html
http://www.blogjava.net/soft/archive/2006/11/13/posoft.html
http://www.blogjava.net/soft/archive/2006/11/13/80788.html
http://www.blogjava.net/soft/archive/2006/11/13/80789.html

时间： 2024-08-28 00:32:58

Java JNI 编程进阶的相关文章

Java并发编程高阶技术 高性能并发框架源码解析与实战

第1章 课程介绍(Java并发编程进阶课程)什么是Disruptor?它一个高性能的异步处理框架,号称"单线程每秒可处理600W个订单"的神器,本课程目标:彻底精通一个如此优秀的开源框架,面试秒杀面试官.本章会带领小伙伴们先了解课程大纲与重点,然后模拟千万,亿级数据进行压力测试.让大家感性认知到Disruptor的强大.... 第2章 并发编程框架核心讲解本章带大家学习并发编程框架的基本使用与API,并介绍其内部各种组件的原理和运行机制.从而为后面的深入学习打下坚实的基础.如果对Dis

android开发教程（4）— jni编程之采用 javah 从java调用C++

用Java调用C/C++代码 当无法用 Java 语言编写整个应用程序时,JNI 允许您使用本机代码.在下列典型情况下,您可能决定使用本机代码: 希望用更低级.更快的编程语言去实现对时间有严格要求的代码. 希望从 Java 程序访问旧代码或代码库. 需要标准 Java 类库中不支持的依赖于平台的特性. 须知:SWIG和javah的区别(强烈推荐) 我看了网上的关于 jni编程 的教程很多,但不尽相同,刚开始会犯迷糊.我想笔者往往忽略了一个关键点,那就是采用了什么方式决定了步骤的流程.有两种生成

【Java】Java网络编程菜鸟进阶：TCP和套接字入门

Java网络编程菜鸟进阶:TCP和套接字入门 JDK 提供了对 TCP(Transmission Control Protocol,传输控制协议)和 UDP(User Datagram Protocol,用户数据报协议)这两个数据传输协议的支持.本文开始探讨 TCP. TCP 基础知识 在“服务器-客户端”这种架构中,服务器和客户端各自维护一个端点,两个端点需要通过网络进行数据交换.TCP 为这种需求提供了一种可靠的流式连接,流式的意思是传出和收到的数据都是连续的字节,没有对数据量进行大小限制.

编程基础知识——Java JNI开发流程（2）

android中使用jni调用本地C++库 android平台上的本地库文件后缀 .so.类似windows上的dll文件. 要在android上使用jni,首先需要下载android ndk. 操作步骤,正常建立android工程,然后在android工程那里右键,属性,选择Android Tools -> Add Native Support.就可以为android工程增加本地库支持. 添加支持后的android工程,会增加jni目录,C++代码就写在这个目录里. 新建一个类,并且使用nat

JNI编程(二) —— 让C++和Java相互调用(1)

自己在外面偷偷的算了下,又有将近两个月没更新过blog了.趁着今天有兴致,来更新JNI编程的第二篇文章.在第一篇里,大概介绍了JNI的特点.用途和优劣.并且做一个最简单的JNI的例子,不过说实话那个例子在实际的开发中没有太大的价值,实际开发中所需要的JNI程序要远远比那个复杂.所以这一篇就来介绍下如何通过JNI实现java和C++的相互通信,来满足实际开发的需要. 所谓”通信“,其实说白了无非也就是我们所说的方法调用,在上一篇的例子里介绍了如何在Java中调用本地的DLL,其实在Java代码中,

JNI编程(二) —— 让C++和Java相互调用(2)

3.getRamdomOrder() 这个方法会从backend得到一个随机的Order对象(抱歉这里“Random”拼错了),然后再调用java中相应的通知方法来通知foreground.getRamdomOrder方法没有参数,但是所对应的C++方法里却有两个参数,一定有人会不解.其实细心的朋友一定会发现,JNI里所有对应Java方法的C++ 方法都会比Java方法多两个参数,第一个参数是我们很熟悉的JNIEnv*指针,第二个参数有时是jobject有时是个jclass.针对这第二个参数在这

解析Java的JNI编程中的对象引用与内存泄漏问题

JNI,Java Native Interface,是 native code 的编程接口.JNI 使 Java 代码程序可以与 native code 交互--在 Java 程序中调用 native code:在 native code 中嵌入 Java 虚拟机调用 Java 的代码.JNI 编程在软件开发中运用广泛,其优势可以归结为以下几点: 利用 native code 的平台相关性,在平台相关的编程中彰显优势. 对 native code 的代码重用.native code 底层操作,更

java进阶学习 --java网络编程一（转）

Java - 网络编程完全总结(基础介绍) 本文主要是在网络编程方面的学习总结,先主要介绍计算机网络方面的相关内容,包括计算机网络基础,OSI参考模型,TCP/IP协议簇,常见的网络协议等等,在此基础上,主要介绍Java中的网络编程. 目录 一.概述 二.计算机网络 1.网络协议 2.网络体系结构 三.OSI参考模型 四.TCP/IP参考模型 五.常见网络协议 1.TCP协议 2.UDP协议 3.HTTP协议 六.计网常见问题 一.概述 计算机网络是通过传输介质.通信设施和网络通信协议,把分散在

java进阶--java网络编程

java网络编程 一.概述 网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来. java.net 包中 J2SE 的 API 包含有类和接口,它们提供低层次的通信细节.你可以直接使用这些类和接口,来专注于解决问题,而不用关注通信细节. java.net 包中提供了两种常见的网络协议的支持: TCP:TCP 是传输控制协议的缩写,它保障了两个应用程序之间的可靠通信.通常用于互联网协议,被称 TCP / IP. UDP:UDP 是用户数据报协议的缩写,一个无连接的协议.提供