JNI Types and Data Structures

转自: http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html

JNI Types and Data Structures

Chapter   3

This chapter discusses how the JNI maps Java types to native C types.

Primitive Types

Table 3-1 describes Java primitive types and their machine-dependent native equivalents.

Table 3-1 Primitive Types and Native Equivalents

Java Type	Native Type	Description
boolean	jboolean	unsigned 8 bits
byte	jbyte	signed 8 bits
char	jchar	unsigned 16 bits
short	jshort	signed 16 bits
int	jint	signed 32 bits
long	jlong	signed 64 bits
float	jfloat	32 bits
double	jdouble	64 bits
void	void	N/A

The following definition is provided for convenience.

#define JNI_FALSE  0 
#define JNI_TRUE   1 

The jsize integer type is used to describe cardinal indices and sizes:

typedef jint jsize; 

Reference Types

The JNI includes a number of reference types that correspond to different kinds of Java objects. JNI reference types are organized in the hierarchy shown in Figure 3-1.

Figure 3-1 Reference Type Hierarchy

In C, all other JNI reference types are defined to be the same as jobject. For example:

typedef jobject jclass; 

In C++, JNI introduces a set of dummy classes to enforce the subtyping relationship. For example:

class _jobject {}; 
class _jclass : public _jobject {}; 
... 
typedef _jobject *jobject; 
typedef _jclass *jclass; 

Field and Method IDs

Method and field IDs are regular C pointer types:

struct _jfieldID;              /* opaque structure */ 
typedef struct _jfieldID *jfieldID;   /* field IDs */ 
 
struct _jmethodID;              /* opaque structure */ 
typedef struct _jmethodID *jmethodID; /* method IDs */ 

The Value Type

The jvalue union type is used as the element type in argument arrays. It is declared as follows:

typedef union jvalue { 
    jboolean z; 
    jbyte    b; 
    jchar    c; 
    jshort   s; 
    jint     i; 
    jlong    j; 
    jfloat   f; 
    jdouble  d; 
    jobject  l; 
} jvalue; 

Type Signatures

The JNI uses the Java VM’s representation of type signatures. Table 3-2 shows these type signatures.

Table 3-2 Java VM Type Signatures

Type Signature	Java Type
Z	boolean
B	byte
C	char
S	short
I	int
J	long
F	float
D	double
L fully-qualified-class ;	fully-qualified-class
[ type	type[]
( arg-types ) ret-type	method type

For example, the Java method:

long f (int n, String s, int[] arr); 

has the following type signature:

(ILjava/lang/String;[I)J 

Modified UTF-8 Strings

The JNI uses modified UTF-8 strings to represent various string types. Modified UTF-8 strings are the same as those used by the Java VM. Modified UTF-8 strings are encoded so that character sequences that contain only non-null ASCII characters can be represented using only one byte per character, but all Unicode characters can be represented.

All characters in the range \u0001 to \u007F are represented by a single byte, as follows:

0

bits 6-0

The seven bits of data in the byte give the value of the character represented.

The null character ('\u0000') and characters in the range '\u0080' to '\u07FF' are represented by a pair of bytes x and y:

x:

1

1

0

bits 10-6

y:

1

0

bits 5-0

The bytes represent the character with the value ((x & 0x1f) << 6) + (y & 0x3f).

Characters in the range '\u0800' to '\uFFFF' are represented by 3 bytes x, y, and z:

x:

1

1

1

0

bits 15-12

y:

1

0

bits 11-6

z:

1

0

bits 5-0

The character with the value ((x & 0xf) << 12) + ((y & 0x3f) << 6) + (z & 0x3f) is represented by the bytes.

Characters with code points above U+FFFF (so-called supplementary characters) are represented by separately encoding the two surrogate code units of their UTF-16 representation. Each of the surrogate code units is represented by three bytes. This means, supplementary characters are represented by six bytes, u, v, w, x, y, and z:

u:

1

1

1

0

1

1

0

1

v:

1

0

1

0

(bits 20-16) - 1

w:

1

0

bits 15-10

x:

1

1

1

0

1

1

0

1

y:

1

0

1

1

bits 9-6

z:

1

0

bits 5-0

The character with the value 0x10000+((v&0x0f)<<16)+((w&0x3f)<<10)+(y&0x0f)<<6)+(z&0x3f) is represented by the six bytes.

The bytes of multibyte characters are stored in the class file in big-endian (high byte first) order.

There are two differences between this format and the standard UTF-8 format. First, the null character (char)0 is encoded using the two-byte format rather than the one-byte format. This means that modified UTF-8 strings never have embedded nulls. Second, only the one-byte, two-byte, and three-byte formats of standard UTF-8 are used. The Java VM does not recognize the four-byte format of standard UTF-8; it uses its own two-times-three-byte format instead.

For more information regarding the standard UTF-8 format, see section 3.9 Unicode Encoding Forms of The Unicode Standard, Version 4.0.

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

ZZZZZZZZ: http://www.rgagnon.com/javadetails/java-0286.html

Before calling a Java object's method from JNI, we need its signature. For example, the method

long myMethod (int n, String s, int[] arr);

is seen from JNI with the signature

(ILJAVA/LANG/STRING;[I)J

There are two parts to the signature. The first part is enclosed within the parentheses and represents the method's arguments. The second portion follows the closing parenthesis and represents the return type. The mapping between the Java type and C type is

Type     Chararacter 
boolean      Z 
byte         B 
char         C 
double       D 
float        F 
int          I 
long         J 
object       L 
short        S 
void         V 
array        [ 

Note that to specify an object, the "L" is followed by the object's class name and ends with a semi-colon, ';' .

The javap utility (included with the JDK) is very useful to show the signature to be used in JNI.

X:\>javap -s java.awt.Label
Compiled from Label.java
public class java.awt.Label extends java.awt.Component {
    public static final int LEFT;
        /*   I   */
    public static final int CENTER;
        /*   I   */
    public static final int RIGHT;
        /*   I   */
    java.lang.String text;
        /*   Ljava/lang/String;   */
    int alignment;
        /*   I   */
    static {};
        /*   ()V   */
    public java.awt.Label();
        /*   ()V   */
    public java.awt.Label(java.lang.String);
        /*   (Ljava/lang/String;)V   */
    public java.awt.Label(java.lang.String,int);
        /*   (Ljava/lang/String;I)V   */
    public void addNotify();
        /*   ()V   */
    java.lang.String constructComponentName();
        /*   ()Ljava/lang/String;   */
    public int getAlignment();
        /*   ()I   */
    public java.lang.String getText();
        /*   ()Ljava/lang/String;   */
    protected java.lang.String paramString();
        /*   ()Ljava/lang/String;   */
    public synchronized void setAlignment(int);
        /*   (I)V   */
    public void setText(java.lang.String);
        /*   (Ljava/lang/String;)V   */

The javap utility can be used on the java.* or your own classes.