初学JNA

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

利用  Java  调用  C。首先 打成 jar包。

首先 准备 两个文件：

jnaerator-0.9.7.jar

jnaerator.bat。

打开jnaerator.bat：

@echo off
set dst=libvideoDownloadSDK.jar// 打成 jar包 的文件名。
set dll=libvideoDownloadSDK.so // 动态链接库。Linux下 是 .so      Windows下是 .dll.
set inc=videoDownloadSDK.h kdvtype.h  // 需要的头文件。
set sdk=libvideoDownloadSDK  // package。
java -jar jnaerator-0.9.7.jar -jar %dst% -library %sdk%  -direct -noComments -noMangling  %dll% %inc% 

利用  dos 命令 就可以打成 Java包，来用了。找到 jnaerator.bat 文件的路径 运行就可以。

    

===============================================================================================

Java 与 C 进行Socket通讯需注意的地方：


1、Java与C的各种数据类型存储的字节数是不同的：
 Java与C的数据类型的比较   
  Type      Java      C   
  short      2-Byte   2-Byte   
  int        4-Byte   4-Byte   
  long       8-Byte   4-Byte   
  float      4-Byte   4-Byte   
  double     8-Byte   8-Byte   
  boolean    1-bit     N/A   
  byte       1-Byte    N/A   
  char       2-Byte    1-Byte 


所以在通讯前，需要进行类型转换，对于C定义的unsign char为一个字节存储，对应Java这边用byte存储;对于C定义的int, long, float对应Java用int存储，具体可以参考以上的表。


2、Socket通讯是按字节传输的（即8个bit位传输），而对于超过一个字节的类型如short 为两个字节.
就存在两种传输入方式，一种是高字节在前传输；一种是高字节在后传输。即Little-Endian和Big-Endian。
Little-Endian和Big-Endian是表示计算机字节顺序的两种格式,所谓的字节顺序指的是长度跨越多个字节的数据的存放形式. 
        假设从地址0x00000000开始的一个字中保存有数据0x1234abcd,那么在两种不同的内存顺序的机器上从字节的角度去看的话分别表示为: 
       1)little endian:在内存中的存放顺序是0x00000000-0xcd,0x00000001-0xab,0x00000002-0x34,0x00000003-0x12 
       2)big  endian:在内存中的存放顺序是0x00000000-0x12,0x00000001-0x34,0x00000002-0xab,0x00000003-0xcd 
       需要特别说明的是,以上假设机器是每个内存单元以8位即一个字节为单位的. 
       简单的说,ittle endian把低字节存放在内存的低位；而big endian将低字节存放在内存的高位. 
       现在主流的CPU,intel系列的是采用的little endian的格式存放数据,而motorola系列的CPU采用的是big endian. 


网络协议都是Big-Endian的，Java编译的都是Big-Endian的,C编译的程序是与机器相关的，具体是否要进行转换是需要沟通的。假设这里需要转换，以下提供short转的换成字节数组的方式：


  
  public static byte[] ShorttoByteArray(short n) {
    byte[] b = new byte[2];
    b[1] = (byte) (n & 0xff);
    b[0] = (byte) (n >> 8 & 0xff);
    return b;
  }


  
  public static byte[] toLH(short n) {
    byte[] b = new byte[2];
    b[0] = (byte) (n & 0xff);
    b[1] = (byte) (n >> 8 & 0xff);
    return b;
  }
其它的类型转换类似，无非是根据类型在判断用几个字节进行存储而已。


3、由于Socket通讯是按字节进行传输的，而在Java中只有byte是一个字节，故可以将其它类型都转换成byte数组来存储，
如：short用两位的字节数组存储，需转换了换以上方法进行，而int用四位的字节数组来存储，对String类型，直接用String.getBytes()来得到它的字节数组。


4、Java的byte与C语言的unsign char虽然都是一个字节存储，但具体的表示内容是不同的，
C的无符号char是取值的范围0--255，而Java中byte取值的范围是-128—127,故在实现C语言的字符串时（C是用char[]来表示字符串的）.
Java这边需要进行转换来模仿C语的unsign char，具体实现函数如下：
  // 将有符号的char转换成无符号的char
  public static char[] ToUnsignedChar(char[] signChar) {
    for (int i = 0; i < signChar.length; i++) {
      int x = ((byte) signChar[i]) >= 0 ? signChar[i] : ((byte) signChar[i]) + 256;
      signChar[i] = (char) x;
    }
    return signChar;
  }
这里的关键点是当signChar[i] < 0时，即加上256,将其转换到0--255中来。


通过以上四个方面的注意，基本上就可以实现Java与C进行Socket通讯了。

参考：http://blog.csdn.net/shendl/article/details/3589676

JNA快速启动

 

     现在让我们直接进入JNA的世界。

 

你只需要下载一个jar包，就可以使用JNA的强大功能方便地调用动态链接库中的C函数。

1，下载jna.jar。

在这里https://jna.dev.java.net/servlets/ProjectDocumentList?folderID=7408&expandFolder=7408&folderID=0

 

 

2，现在你已经可以使用JNA了。

为了方便你参考JNA的java类库，我制作了《JNA3.09API参考手册》，是CHM格式的。你可以到这里下载http://download.csdn.net/source/900438

 

 

 

 

JNA例子

 

例子1   

现在让我们运行一个JNA程序，感受它的强大威力。

1，在Java项目中引入jna.jar包。

2，创建一个类：

 

package com.kedacom.kdkkdevmgr;

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;

public class HelloWorld {
	
	 //编写一个接口，必须继承Library，他要在加载库文件时用 
	 public interface CLibrary extends Library {
		 	
		 	//加载库文件，Platform.isWindows()可以判断系统类型  
	        CLibrary INSTANCE = (CLibrary) Native.loadLibrary((Platform.isWindows() ? "msvcrt" : "c"),CLibrary.class);
	        //定义方法，与c语言标准的一致  
	        void printf(String format, Object... args);
	    }
	 
	    public static void main(String[] args) {
	        CLibrary.INSTANCE.printf("Hello, World/n");
	        for (int i=0;i < args.length;i++) {
	            CLibrary.INSTANCE.printf("Argument %d: %s/n", i, args[i]);
	        }
	    }
}

 

 

 

 

3，执行，可以看到控制台中打印出了

Hello, World

 

    但是，请注意，这个程序实际上是使用msvcrt.dll这个C运行时库中的printf函数打印出上面这些字符的。

 

    看，多简单，不需要写一行C代码，就可以直接在Java中调用外部动态链接库中的函数！

 

例子2   

 

    上面那个例子使用了操作系统自带的动态链接库，现在我们再自己写一个动态链接库试试。

 

 

1，在VS中选择C++语言，然后选择创建一个Win32程序。 选择dll类型。

 

2，发布的C函数是：

 

#define MYLIBAPI  extern   "C"     __declspec( dllexport ) 

 

MYLIBAPI void say(wchar_t* pValue);

 

 

这个函数的实现是：

 

void  say(wchar_t* pValue){

     std::wcout.imbue(std::locale("chs"));

 

     std::wcout<<L"上帝说："<<pValue<<std::endl;

}

 

它需要传入一个Unicode编码的字符数组。然后在控制台上打印出一段中文字符。

 

3，生成dll。然后把生成的dll文件复制到Eclipse项目中，放在项目下面。

4，在Eclipse中编写以下代码：

 

import com.sun.jna.Library;

import com.sun.jna.Native;

import com.sun.jna.WString;

 

/**

 * @author 沈东良 Edward Shen shendl_s@hotmail.com

 * 2008-11-23 下午05:07:14

 *TestDll1.dll

 */

public class TestDll1Service {

 

         public interface TestDll1 extends Library {

                   /**

                    * 当前路径是在项目下，而不是bin输出目录下。

                    */

                   TestDll1 INSTANCE = (TestDll1)Native.loadLibrary("TestDll1", TestDll1.class);

                   public void say(WString value);

                  

         }

         /**

          *

          */

         public TestDll1Service() {

                   // TODO Auto-generated constructor stub

         }

 

         /**

          * @param args

          */

         public static void main(String[] args) {

                   // TODO Auto-generated method stub

                  

                   TestDll1.INSTANCE.say(new WString("Hello World!"));

                   System.out.println("HHEEH我我们无法万恶");

         }

 

}

 

5，执行这个Java类。可以看到控制台下如下输出：

上帝说：Hello World!

HHEEH我我们无法万恶

 

6，上面一行是C语言使用C++的std::wcout输出的。

下面一行是Java语言输出的。

 

 

 

JNA技术解密

JNA工作原理

JNA是建立在JNI技术基础之上的一个Java类库，它使您可以方便地使用java直接访问动态链接库中的函数。

原来使用JNI，你必须手工用C写一个动态链接库，在C语言中映射Java的数据类型。

JNA中，它提供了一个动态的C语言编写的转发器，可以自动实现Java和C的数据类型映射。你不再需要编写C动态链接库。

当然，这也意味着，使用JNA技术比使用JNI技术调用动态链接库会有些微的性能损失。可能速度会降低几倍。但影响不大。

 

JNA技术难点

 

 

1，当前路径是在项目下，而不是bin输出目录下。

2，数据结构的对应关系：

Java—C和操作系统数据类型的对应表

Java Type	C Type	Native Representation
boolean	int	32-bit integer (customizable)
byte	char	8-bit integer
char	wchar_t	platform-dependent
short	short	16-bit integer
int	int	32-bit integer
long	long long, __int64	64-bit integer
float	float	32-bit floating point
double	double	64-bit floating point
Buffer Pointer	pointer	platform-dependent (32- or 64-bit pointer to memory)
<T>[] (array of primitive type)	pointer array	32- or 64-bit pointer to memory (argument/return) contiguous memory (struct member)
除了上面的类型，JNA还支持常见的数据类型的映射。
String	char*	NUL-terminated array (native encoding or jna.encoding)
WString	wchar_t*	NUL-terminated array (unicode)
String[]	char**	NULL-terminated array of C strings
WString[]	wchar_t**	NULL-terminated array of wide C strings
Structure	struct* struct	pointer to struct (argument or return) (or explicitly) struct by value (member of struct) (or explicitly)
Union	union	same as Structure
Structure[]	struct[]	array of structs, contiguous in memory
Callback	<T> (*fp)()	function pointer (Java or native)
NativeMapped	varies	depends on definition
NativeLong	long	platform-dependent (32- or 64-bit integer)
PointerType	pointer	same as Pointer

 

 

JNA编程过程

 

JNA把一个dll/.so文件看做是一个Java接口。

Dll是C函数的集合、容器，这正和接口的概念吻合。

 

    我们定义这样一个接口，

public interface TestDll1 extends Library {

                   /**

                    * 当前路径是在项目下，而不是bin输出目录下。

                    */

                   TestDll1 INSTANCE = (TestDll1)Native.loadLibrary("TestDll1", TestDll1.class);

                   public void say(WString value);

                  

         }

 

 

如果dll是以stdcall方式输出函数，那么就继承StdCallLibrary。否则就继承默认的Library接口。

 

接口内部需要一个公共静态常量：instance。

 

TestDll1 INSTANCE = (TestDll1)Native.loadLibrary("TestDll1", TestDll1.class);

 

通过这个常量，就可以获得这个接口的实例，从而使用接口的方法。也就是调用外部dll的函数！

 

注意：

1，Native.loadLibrary()函数有2个参数：

    1，dll或者.so文件的名字，但不带后缀名。这符合JNI的规范，因为带了后缀名就不可以跨操作系统平台了。

搜索dll的路径是：

1）项目的根路径

2）操作系统的全局路径、

3）path指定的路径。

 

2，第二个参数是本接口的Class类型。

 

JNA通过这个Class类型，根据指定的dll/.so文件，动态创建接口的实例。

 

2，接口中你只需要定义你需要的函数或者公共变量，不需要的可以不定义。

public void say(WString value);

 

参数和返回值的类型，应该和dll中的C函数的类型一致。

这是JNA，甚至所有跨平台调用的难点。

 

这里，C语言的函数参数是：wchar_t*。

JNA中对应的Java类型是WStirng。

 

 

所有跨平台、跨语言调用的难点

有过跨语言、跨平台开发的程序员都知道，跨平台、语言调用的难点，就是不同语言之间数据类型不一致造成的问题。绝大部分跨平台调用的失败，都是这个问题造成的。

关于这一点，不论何种语言，何种技术方案，都无法解决这个问题。

这需要程序员的仔细开发和设计。这是程序员的责任。

 

常见的跨平台调用有：

1，Java调用C语言编写的dll、.so动态链接库中的函数。

2，.NET通过P/Invoke调用C语言编写的dll、.so动态链接库中的函数。

3，通过WEBService，在C,C++,Java,.NET等种种语言间调用。

    WebService传递的是xml格式的数据。

 

即使是强大的P/Invoke或者WebService，在遇到复杂的数据类型和大数据量的传递时，还是会碰到很大的困难。

 

因为，一种语言的复杂的数据类型，很难用另一种语言来表示。这就是跨平台调用问题的本质。

如，WEBService调用中，很多语言，如Java，.NET都有自动实现的Java/.NET类型和XML类型之间的映射的类库或者工具。

但是，在现实的编程环境中，如果类型非常复杂，那么这些自动转换工具常常力不从心。

要么Object-XML映射错误。

要么映射掉大量的内存。

 

因此，我个人对这些Object-XML映射框架相当不感冒。

我现在使用WEBService，都是直接手工使用xml处理工具提取xml中的数据构建对象。或者反过来，手工根据Object中的属性值构建xml数据。

 

 

Java和C语言之间的调用问题，也是如此。

Java要调用C语言的函数，那么就必须严格按照C语言要求的内存数量提供Java格式的数据。要用Java的数据类型完美模拟C语言的数据类型。

JNA已经提供了大量的类型匹配C语言的数据类型。

 

 

 

跨平台、跨语言调用的第一原则：就是尽量使用基本、简单的数据类型，尽量少跨语言、平台传递数据！

只有你才能拯救你自己。

如果在你的程序中，有复杂的数据类型和庞大的跨平台数据传递。那么你必须另外写一些Façade接口，把需要传递的数据类型简化，把需要传递的数据量简化。

否则，不论是实现的难度还是程序的性能都很难提高。