intdjava的简单介绍

admin 2022-12-30 12:27:09 649

本篇文章给大家谈谈intdjava，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、如何使用C++程序运行一个jar文件
2、Java Reflection (JAVA反射)机制详解
3、java编程中，常提到的反射代码指的是什么？
4、java 调用so文件
5、怎么配置c++包含%java
6、获取屏幕分辨率：int width=（int）java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;

如何使用C++程序运行一个jar文件

首先需要先加载JVM，然后根据jar中的函数签名寻找到相应的函数，然后运行相应的函数

一段样例代码如下

#include iostream

#include jni.h

#include windows.h

#include cstring

#include direct.h

using namespace std;

#define DIRLEN 10000

char* GetJrepath(int BIT);

int CallJAR(int BIT,char*buf,char*classPath,char*functionName);

int main(int argc, char *argv[])

{

char * buff = new char[DIRLEN];

getcwd(buff,DIRLEN);

strcat(buff,"\\lib\\support.jar");

if (argc3)

{

cout"输入参数错误";

return 0;

}

int BIT = 32;

if(!strcmp(argv[2],"64"))

BIT = 64 ;

//-30 没有安装jre环境 -31 创建jvm失败 -32 缺少相关的库

if (!strcmp(argv[1],"0"))

{

//-20 配置文件错误 -21 JSON异常

return CallJAR(BIT,buff,"com/run/Author","StartAuthor");

}

else if(!strcmp(argv[1],"1"))

{

return CallJAR(BIT,buff,"com/run/UpdateStatus","UpdateStatus1");

}

else if(!strcmp(argv[1],"2"))

{

return CallJAR(BIT,buff,"com/run/SendMsg_webchinese","SendSMS");

}

else

{

return CallJAR(BIT,buff,"com/run/UpdateStatus","UpdateANDSMS");

}

char* GetJrepath(int BIT)

{

#define MYBUFF 123

HKEY hKey;

long lRet;

char* dir = new char[MYBUFF];

DWORD dwBufLen = MYBUFF;

char* s = new char[MYBUFF];

if(BIT == 64)

strcpy(s,"SOFTWARE\\Wow6432Node\\JavaSoft\\Java Runtime Environment\\");

else

strcpy(s,"SOFTWARE\\JavaSoft\\Java Runtime Environment\\");

lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,

TEXT((TCHAR*)s),

KEY_QUERY_VALUE,

hKey);

if(lRet!=ERROR_SUCCESS)

return NULL;

lRet = RegQueryValueEx(hKey,

TEXT((TCHAR*)"CurrentVersion"),

NULL,

(LPBYTE)dir,

dwBufLen);

RegCloseKey(hKey);

if(lRet!=ERROR_SUCCESS)

return NULL;

strcat(s,dir);

lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE,

TEXT((TCHAR*)s),

KEY_QUERY_VALUE,

hKey);

if(lRet!=ERROR_SUCCESS)

return NULL;

dwBufLen = MYBUFF;

lRet = RegQueryValueEx(hKey,

TEXT((TCHAR*)"RuntimeLib"),

NULL,

(LPBYTE)dir,

dwBufLen);

RegCloseKey(hKey);

if(lRet!=ERROR_SUCCESS)

return NULL;

return dir;

}

int CallJAR(int BIT,char*buf,char*classPath,char*functionName)

{

typedef jint (WINAPI *PFunCreateJavaVM)(JavaVM **, void **, void *);

int res;

JavaVMInitArgs vm_args;

JavaVMOption options[3];

JavaVM *jvm;

JNIEnv *env;

int len =strlen("-Djava.class.path=.;")+strlen(buf)+20;

char* temp = new char[len];

strcpy(temp,"-Djava.class.path=.;");

strcat(temp,buf);

/*设置初始化参数*/

//disable JIT，这是JNI文档中的解释，具体意义不是很清楚，能取哪些值也不清楚。

//从JNI文档里给的示例代码中搬过来的

options[0].optionString = "-Djava.compiler=NONE";

//设置classpath，如果程序用到了第三方的JAR包，也可以在这里面包含进来

options[1].optionString = temp;

//设置显示消息的类型，取值有gc、class和jni，如果一次取多个的话值之间用逗号格开，如-verbose:gc,class

//该参数可以用来观察C++调用JAVA的过程，设置该参数后，程序会在标准输出设备上打印调用的相关信息

options[2].optionString = "-verbose:NONE";

//设置版本号，版本号有JNI_VERSION_1_1，JNI_VERSION_1_2和JNI_VERSION_1_4

//选择一个根你安装的JRE版本最近的版本号即可，不过你的JRE版本一定要等于或者高于指定的版本号

vm_args.version = JNI_VERSION_1_4;

vm_args.nOptions = 3;

vm_args.options = options;

//该参数指定是否忽略非标准的参数，如果填JNI_FLASE，当遇到非标准参数时，JNI_CreateJavaVM会返回JNI_ERR

vm_args.ignoreUnrecognized = JNI_TRUE;

//加载JVM.DLL动态库

HINSTANCE hInstance = ::LoadLibrary(GetJrepath(BIT));

if (hInstance == NULL)

{

return -30;

}

//取得里面的JNI_CreateJavaVM函数指针

PFunCreateJavaVM funCreateJavaVM = (PFunCreateJavaVM)::GetProcAddress(hInstance, "JNI_CreateJavaVM");

//调用JNI_CreateJavaVM创建虚拟机

res = (*funCreateJavaVM)(jvm, (void**)env, vm_args);

if (res 0)

{

return -31;

}

//查找test.Demo类，返回JAVA类的CLASS对象

jclass cls = env-FindClass(classPath);

//根据类的CLASS对象获取该类的实例

if (cls==0)

{

printf("FindClass failed\n");

(jvm)-DestroyJavaVM();

return -32;

}

jobject obj = env-AllocObject(cls);

//获取类中的方法，最后一个参数是方法的签名，通过javap -s -p -classpath 路径文件名

jmethodID mid = env-GetMethodID(cls, functionName,"()I");

if (mid==0)

{

printf("getMethodID failed\n");

(jvm)-DestroyJavaVM();

return -32;

}

//构造参数并调用对象的方法

jstring msg = (jstring) env-CallObjectMethod(obj, mid);

//销毁虚拟机并释放动态库

jvm-DestroyJavaVM();

::FreeLibrary(hInstance);

return (int)msg;

}

Java Reflection (JAVA反射)机制详解

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。

Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。

Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。但是这些信息我们怎么得到啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我来处理这个对象clazz。

当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。

1．检测类：

reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

按如下语句执行：

java DumpMethods java.util.ArrayList

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象：

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类 java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释 field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数 -Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

反射性能：（转录别人的啊）

反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下：

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int acces

sReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：

图 1：字段接入时间：

我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。随着jdk6.0的推出，反射机制的性能也有了很大的提升。期待中….

总结：

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

一下是对应各个部分的例子：

具体的应用：

1、模仿instanceof 运算符号

class A {}

public class instance1 {

public static void main(String args[])

{

try {

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

}

catch (Throwable e) {

System.err.println(e);

}

2、在类中寻找指定的方法，同时获取该方法的参数列表，例外和返回值

import java.lang.reflect.*;

public class method1 {

private int f1(

Object p, int x) throws NullPointerException

{

if (p == null)

throw new NullPointerException();

return x;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

3、获取类的构造函数信息，基本上与获取方法的方式相同

import java.lang.reflect.*;

public class constructor1 {

public constructor1()

{

}

protected constructor1(int i, double d)

{

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i ctorlist.length; i++) {

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

4、获取类中的各个数据成员对象，包括名称。类型和访问修饰符号

import java.lang.reflect.*;

public class field1 {

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

{

try {

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i fieldlist.length; i++) {

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

}

catch (Throwable e) {

System.err.println(e);

}

5、通过使用方法的名字调用方法

import java.lang.reflect.*;

public class method2 {

public int add(int a, int b)

{

return a + b;

}

public static void main(String args[])

{

try {

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

}

catch (Throwable e) {

System.err.println(e);

}

6、创建新的对象

import java.lang.reflect.*;

public class constructor2 {

public constructor2()

{

}

public constructor2(int a, int b)

{

System.out.println(

"a = " + a + " b = " + b);

}

public static void main(String args[])

{

try {

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

}

catch (Throwable e) {

System.err.println(e);

}

7、变更类实例中的数据的值

import java.lang.reflect.*;

public class field2 {

public double d;

public static void main(String args[])

{

try {

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

}

catch (Throwable e) {

System.err.println(e);

}

使用反射创建可重用代码：

1、对象工厂

Object factory(String p) {

Class c;

Object o=null;

try {

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

} catch (Exception e) {

System.err.println("Can't make a " + p);

}

return o;

}

public class ObjectFoundry {

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException {

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

}

2、动态检测对象的身份，替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException {

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null ) {

if ( c==tClass ) return true;

c = c.getSuperclass();

}

return false;

}

java编程中，常提到的反射代码指的是什么？

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。

反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。13700863760

Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。

二、Java中的类反射：

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

1．检测类：

1.1 reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods {

public static void main(String args[]) {

try {

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i m.length; i++)

System.out.println(m[i].toString());

} catch (Throwable e) {

System.err.println(e);

}

按如下语句执行：

java DumpMethods java.util.Stack

它的结果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

1.2 Java类反射中的主要方法

l Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

l Constructor[] getConstructors() -- 获得类的所有公共构造函数

l Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

l Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

l Field getField(String name) -- 获得命名的公共字段

l Field[] getFields() -- 获得类的所有公共字段

l Field getDeclaredField(String name) -- 获得类声明的命名的字段

l Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

l Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

l Method[] getMethods() -- 获得类的所有公共方法

l Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

l Method[] getDeclaredMethods() -- 获得类声明的所有方法

1.3开始使用 Reflection：

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

2．处理对象：

如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

import java.lang.reflect.*;

import java.awt.*;

class SampleGet {

public static void main(String[] args) {

Rectangle r = new Rectangle(100, 325);

printHeight(r);

}

static void printHeight(Rectangle r) {

Field heightField;

Integer heightValue;

Class c = r.getClass();

try {

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

} catch (NoSuchFieldException e) {

System.out.println(e);

} catch (SecurityException e) {

System.out.println(e);

} catch (IllegalAccessException e) {

System.out.println(e);

}

三、安全性和反射：

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

n 从任意位置到类公共组件的接入

n 类自身外部无任何到私有组件的接入

n 受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity {

public static void main(String[] args) {

try {

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数-Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

四、反射性能：

程序如下：

public int accessSame(int loops) {

m_value = 0;

for (int index = 0; index loops; index++) {

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return m_value;

}

public int accessReference(int loops) {

TimingClass timing = new TimingClass();

for (int index = 0; index loops; index++) {

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

}

return timing.m_value;

}

public int accessReflection(int loops) throws Exception {

TimingClass timing = new TimingClass();

try {

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index loops; index++) {

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

}

return timing.m_value;

} catch (Exception ex) {

System.out.println("Error using reflection");

throw ex;

}

图 1：字段接入时间：

结束语：

利用反射实现类的动态加载

Bromon原创请尊重版权

最近在成都写一个移动增值项目，俺负责后台server端。功能很简单，手机用户通过GPRS打开Socket与服务器连接，我则根据用户传过来的数据做出响应。做过类似项目的兄弟一定都知道，首先需要定义一个类似于MSNP的通讯协议，不过今天的话题是如何把这个系统设计得具有高度的扩展性。由于这个项目本身没有进行过较为完善的客户沟通和需求分析，所以以后肯定会有很多功能上的扩展，通讯协议肯定会越来越庞大，而我作为一个不那么勤快的人，当然不想以后再去修改写好的程序，所以这个项目是实践面向对象设计的好机会。

首先定义一个接口来隔离类：

package org.bromon.reflect;

public interface Operator

{

public java.util.List act(java.util.List params)

}

根据设计模式的原理，我们可以为不同的功能编写不同的类，每个类都继承Operator接口，客户端只需要针对Operator接口编程就可以避免很多麻烦。比如这个类：

package org.bromon.reflect.*;

public class Success implements Operator

{

public java.util.List act(java.util.List params)

{

List result=new ArrayList();

java 调用so文件

用JNI实现

实例：

创建HelloWorld.java

class HelloWorld

{

private native void print();

public staticvoid main(String[] args)

{

new HelloWorld().print();

}

static

{

System.loadLibrary("HelloWorld");

}

注意print方法的声明，关键字native表明该方法是一个原生代码实现的。另外注意static代码段的System.loadLibrary调用，这段代码表示在程序加载的时候，自动加载libHelloWorld.so库。

编译HelloWorld.java

在命令行中运行如下命令：

javac HelloWorld.java

在当前文件夹编译生成HelloWorld.class。

生成HelloWorld.h

在命令行中运行如下命令：

javah -jni HelloWorld

在当前文件夹中会生成HelloWorld.h。打开HelloWorld.h将会发现如下代码：

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

#include jni.h

/* Header for class HelloWorld */

#ifndef _Included_HelloWorld

#define _Included_HelloWorld

#ifdef __cplusplus

extern "C" {

#endif

* Class: HelloWorld

* Method: print

* Signature: ()V

JNIEXPORT void JNICALL Java_HelloWorld_print

(JNIEnv *, jobject);

#ifdef __cplusplus

}

#endif

该文件中包含了一个函数Java_HelloWorld_print的声明。这里面包含两个参数，非常重要，后面讲实现的时候会讲到。

实现HelloWorld.c

创建HelloWorld.c文件输入如下的代码：

#include jni.h

#include stdio.h

#include "HelloWorld.h"

JNIEXPORT void JNICALL

Java_HelloWorld_print(JNIEnv *env, jobject obj)

{

printf("Hello World!\n");

}

注意必须要包含jni.h头文件，该文件中定义了JNI用到的各种类型，宏定义等。

另外需要注意Java_HelloWorld_print的两个参数，本例比较简单，不需要用到这两个参数。但是这两个参数在JNI中非常重要。

env代表java虚拟机环境，Java传过来的参数和c有很大的不同，需要调用JVM提供的接口来转换成C类型的，就是通过调用env方法来完成转换的。

obj代表调用的对象，相当于c++的this。当c函数需要改变调用对象成员变量时，可以通过操作这个对象来完成。

编译生成libHelloWorld.so

在Linux下执行如下命令来完成编译工作：

cc -I/usr/lib/jvm/java-6-sun/include/linux/

-I/usr/lib/jvm/java-6-sun/include/

-fPIC -shared -o libHelloWorld.so HelloWorld.c

在当前目录生成libHelloWorld.so。注意一定需要包含Java的include目录（请根据自己系统环境设定），因为Helloworld.c中包含了jni.h。

另外一个值得注意的是在HelloWorld.java中我们LoadLibrary方法加载的是

“HelloWorld”，可我们生成的Library却是libHelloWorld。这是Linux的链接规定的，一个库的必须要是：lib+库

名+.so。链接的时候只需要提供库名就可以了。

运行Java程序HelloWorld

大功告成最后一步，验证前面的成果的时刻到了：

java HelloWorld

如果你这步发生问题，如果这步你收到java.lang.UnsatisfiedLinkError异常，可以通过如下方式指明共享库的路径：

java -Djava.library.path='.' HelloWorld

当然还有其他的方式可以指明路径请参考《在Linux平台下使用JNI》。

我们可以看到久违的“Hello world!”输出了。

怎么配置c++包含%java

开发环境安装及配置

1.1 安装JDK

到SUN公司网站可以下载到最新版的JDK。下载下来后开始安装，一路选择默认配置即可，本文档中假定安装的是JDK1.4，安装目录为C:\j2sdk1.4.2_15。

1.2 配置VC6.0

通过Visual C++ 6的菜单Tools→Options打开选项对话框。在Directories标签页下添加JDK的相关目录到Include和目录下。

开发测试用到的JAVA类

2.1 开发JAVA类

在硬盘的任意地方新建一个名叫test的文件夹，本文档示例中将test文件夹建立在C盘根目录，然后在里面新建一个名称叫Demo.java的JAVA文件，将下面测试用的代码粘贴到该文件中。

Java代码

package test;

/**

* 该类是为了演示JNI如何访问各种对象属性等

public class Demo

{

//用于演示如何访问静态的基本类型属性

public static int COUNT = 8;

//演示对象型属性

private String msg;

private int[] counts;

public Demo()

{

this("缺省构造函数");

}

/**

* 演示如何访问构造器

public Demo(String msg)

{

this.msg = msg;

this.counts = null;

}

public String getMessage()

{

return msg;

}

/**

* 该方法演示如何访问一个静态方法

public static String getHelloWorld()

{

return "Hello world!";

}

/**

* 该方法演示参数的传入传出及中文字符的处理

public String append(String str, int i)

{

return str + i;

}

/**

* 演示数组对象的访问

public int[] getCounts()

{

return counts;

}

/**

* 演示如何构造一个数组对象

public void setCounts(int[] counts)

{

this.counts = counts;

}

/**

* 演示异常的捕捉

public void throwExcp()throws IllegalAccessException

{

throw new IllegalAccessException("exception occur.");

}

2.2 编译JAVA类

运行CMD控制台程序进入命令行模式，输入命令javac -classpath c:\ c:\test\Demo.java，-classpath参数指定classpath的路径，这里就是test目录所在的路径。（注意：如果你没有将JDK的环境变量设置好，就需要先进入JDK的bin目录下，如下图所示。）

2.3 查看方法的签名

我们知道Java中允许方法的多态，仅仅是通过方法名并没有办法定位到一个具体的方法，因此需要一个字符串来唯一表示一个方法。但是怎么利用一个字符串来表示方法的具体定义呢？JDK中已经准备好一个反编译工具javap，通过这个工具就可以得到类中每个属性、方法的签名。在CMD下运行javap -s -p -classpath c:\ test.Demo即可看到属性和方法的签名。如下图红色矩形框起来的字符串为方法String append(String str, int i)的签名。

在VC中调用JAVA类

3.1 快速调用JAVA中的函

在VC中新建一个控制台程序，然后新建一个CPP文件，将下面的代码添加到该文件中。运行该文件，即可得到Demo类中String append(String str, int i)函数返回的字符串。

Cpp代码

#include "windows.h"

#include "jni.h"

#include string

#include iostream

using namespace std;

jstring NewJString(JNIEnv *env, LPCTSTR str);

string JStringToCString (JNIEnv *env, jstring str);

int main()

{

//定义一个函数指针，下面用来指向JVM中的JNI_CreateJavaVM函数

typedef jint (WINAPI *PFunCreateJavaVM)(JavaVM **, void **, void *);

int res;

JavaVMInitArgs vm_args;

JavaVMOption options[3];

JavaVM *jvm;

JNIEnv *env;

/*设置初始化参数*/

//disable JIT，这是JNI文档中的解释，具体意义不是很清楚，能取哪些值也不清楚。

//从JNI文档里给的示例代码中搬过来的

options[0].optionString = "-Djava.compiler=NONE";

//设置classpath，如果程序用到了第三方的JAR包，也可以在这里面包含进来

options[1].optionString = "-Djava.class.path=.;c:\\";

//设置显示消息的类型，取值有gc、class和jni，如果一次取多个的话值之间用逗号格开，如-verbose:gc,class

//该参数可以用来观察C++调用JAVA的过程，设置该参数后，程序会在标准输出设备上打印调用的相关信息

options[2].optionString = "-verbose:NONE";

//设置版本号，版本号有JNI_VERSION_1_1，JNI_VERSION_1_2和JNI_VERSION_1_4

//选择一个根你安装的JRE版本最近的版本号即可，不过你的JRE版本一定要等于或者高于指定的版本号

vm_args.version = JNI_VERSION_1_4;

vm_args.nOptions = 3;

vm_args.options = options;

//该参数指定是否忽略非标准的参数，如果填JNI_FLASE，当遇到非标准参数时，JNI_CreateJavaVM会返回JNI_ERR

vm_args.ignoreUnrecognized = JNI_TRUE;

//加载JVM.DLL动态库

HINSTANCE hInstance = ::LoadLibrary("C:\\j2sdk1.4.2_15\\jre\\bin\\client\\jvm.dll");

if (hInstance == NULL)

{

return false;

}

//取得里面的JNI_CreateJavaVM函数指针

PFunCreateJavaVM funCreateJavaVM = (PFunCreateJavaVM)::GetProcAddress(hInstance, "JNI_CreateJavaVM");

//调用JNI_CreateJavaVM创建虚拟机

res = (*funCreateJavaVM)(jvm, (void**)env, vm_args);

if (res 0)

{

return -1;

}

//查找test.Demo类，返回JAVA类的CLASS对象

jclass cls = env-FindClass("test/Demo");

//根据类的CLASS对象获取该类的实例

jobject obj = env-AllocObject(cls);

//获取类中的方法，最后一个参数是方法的签名，通过javap -s -p 文件名可以获得

jmethodID mid = env-GetMethodID(cls, "append","(Ljava/lang/String;I)Ljava/lang/String;");

//构造参数并调用对象的方法

const char szTest[] = "电信";

jstring arg = NewJString(env, szTest);

jstring msg = (jstring) env-CallObjectMethod(obj, mid, arg, 12);

coutJStringToCString(env, msg);

//销毁虚拟机并释放动态库

jvm-DestroyJavaVM();

::FreeLibrary(hInstance);

return 0;

}

string JStringToCString (JNIEnv *env, jstring str)// (jstring str, LPTSTR desc, int desc_len)

{

if(str==NULL)

{

return "";

}

//在VC中wchar_t是用来存储宽字节字符(UNICODE)的数据类型

int len = env-GetStringLength(str);

wchar_t *w_buffer = new wchar_t[len+1];

char *c_buffer = new char[2*len+1];

ZeroMemory(w_buffer,(len+1)*sizeof(wchar_t));

//使用GetStringChars而不是GetStringUTFChars

const jchar * jcharString = env-GetStringChars(str, 0);

wcscpy(w_buffer,jcharString);

env-ReleaseStringChars(str,jcharString);

ZeroMemory(c_buffer,(2*len+1)*sizeof(char));

/调用字符编码转换函数(Win32 API)将UNICODE转为ASCII编码格式字符串

len = WideCharToMultiByte(CP_ACP,0,w_buffer,len,c_buffer,2*len,NULL,NULL);

string cstr = c_buffer;

delete[] w_buffer;

delete[] c_buffer;

return cstr;

}

jstring NewJString(JNIEnv *env, LPCTSTR str)

{

if(!env || !str)

{

return 0;

}

int slen = strlen(str);

jchar* buffer = new jchar[slen];

int len = MultiByteToWideChar(CP_ACP,0,str,strlen(str),buffer,slen);

if(len0 len slen)

{

buffer[len]=0;

}

jstring js = env-NewString(buffer,len);

delete [] buffer;

return js;

}

3.2 调用步骤分析及注意事项

a、加载jvm.dll动态库，然后获取里面的JNI_CreateJavaVM函数。这个步骤也可以通过在VC工程的LINK标签页里添加对jvm.lib的连接，然后在环境变量里把jvm.dll所在的路径加上去来实现。但后面这种方法在部署的时候会比前一个方法麻烦。

b、利用构造好的参数，调用JNI_CreateJavaVM函数创建JVM。JNI_CreateJavaVM函数内部会自动根据jvm.dll的路径来获取JRE的环境，所以千万不要把jvm.dll文件拷贝到别的地方，然后再通过LoadLibrary函数导入。

c、JVM创建成功后，JNI_CreateJavaVM函数会传出一个JNI上下文环境对象（JNIEnv），利用该对象的相关函数就可以调用JAVA类的属性和方法了。

d、以上面的代码为例：先调用JNIEnv的FindClass方法，该函数传入一个参数，该参数就是java类的全局带包名的名称，如上面示例中的test/Demo表示test包中的Demo类。这个方法会在你创建JVM时设置的classpath路径下找相应的类，找到后就会返回该类的class对象。 Class是JAVA中的一个类，每个JAVA类都有唯一的一个静态的Class对象，Class对象包含类的相关信息。为了使FindClass方法能找到你的类，请确保创建JVM时-Djava.class.path=参数设置正确。注意：系统环境变量中的CLASSPATH对这里创建JVM没有影响，所以不要以为系统CLASSPATH设置好了相关路径后这里就不用设置了。

e、利用FindClass返回的class对象，调用GetMethodID函数可以获得里面方法的ID，在这里GetMethodID函数传入了三个参数：第一个参数是class对象，因为方法属于某个具体的类；第二个参数是方法的名称；第三个参数是方法的签名，这个签名可以在前面3.3中介绍的方法获得。

f、利用class对象，可以通过调用AllocObject函数获得该class对象对应类的一个实例，即Demo类的对象。

g、利用上面获取的函数ID和Demo类的对象，就可以通过CallObjectMethod函数调用相应的方法，该函数的参数跟printf函数的参数一样，个数是不定的。第一个参数是类的对象；第二个参数是要调用的方法的ID；后面的参数就是需要传给调用的JAVA类方法的参数，如果调用的JAVA类方法没有参数，则调用CallObjectMethod时传前两个参数就可以了。

h、从上面的示例中可以看到，在调用JAVA的方法前，构造传入的字符串时，用到了NewJString函数；在调用该方法后，对传出的字符串调用了JstringToCString函数。这是由于Java中所有的字符都是Unicode编码，但是在本地方法中，例如用VC编写的程序，如果没有特殊的定义一般都没有使用Unicode的编码方式。为了让本地方法能够访问Java中定义的中文字符及Java访问本地方法产生的中文字符串，定义了两个方法用来做相互转换。

i、避免在被调用的JAVA类中使用静态final成员变量，因为在C++中生成一个JAVA类的对象时，静态final成员变量不会像JAVA中new对象时那样先赋值。如果出现这种情况，在C++中调用该对象的方法时会发现该对象的静态final成员变量值全为0或者null（根据成员变量的类型而定）。

3.3 调用JAVA中的静态方法

Cpp代码

//调用静态方法

jclass cls = env-FindClass("test/Demo");

jmethodID mid = env-GetStaticMethodID(cls, "getHelloWorld","()Ljava/lang/String;");

jstring msg = (jstring)env-CallStaticObjectMethod(cls, mid);

coutJStringToCString(env, msg);

3.4 调用JAVA中的静态属性

C代码

//调用静态方法

jclass cls = env-FindClass("test/Demo");

jfieldID fid = env-GetStaticFieldID(cls, "COUNT","I");

int count = (int)env-GetStaticIntField(cls, fid);

coutcountendl;

3.5 调用JAVA中的带参数构造函数

Cpp代码

//调用构造函数

jclass cls = env-FindClass("test/Demo");

jmethodID mid = env-GetMethodID(cls,"init","(Ljava/lang/String;)V");

const char szTest[] = "电信";

jstring arg = NewJString(env, szTest);

jobject demo = env-NewObject(cls,mid,arg);

//验证是否构造成功

mid = env-GetMethodID(cls, "getMessage","()Ljava/lang/String;");

jstring msg = (jstring)env-CallObjectMethod(demo, mid);

coutJStringToCString(env, msg);

3.6 传入传出数组

Cpp代码

//传入传出数组

//构造数组

long arrayCpp[] = {1,3,5,7,9};

jintArray array = env-NewIntArray(5);

env-SetIntArrayRegion(array, 0, 5, arrayCpp);

//传入数组

jclass cls = env-FindClass("test/Demo");

jobject obj = env-AllocObject(cls);

jmethodID mid = env-GetMethodID(cls,"setCounts","([I)V");

env-CallVoidMethod(obj, mid, array);

//获取数组

mid = env-GetMethodID(cls,"getCounts","()[I");

jintArray msg = (jintArray)env-CallObjectMethod(obj, mid, array);

int len =env-GetArrayLength(msg);

jint* elems =env- GetIntArrayElements(msg, 0);

for(int i=0; i len; i++)

{

cout"ELEMENT "i" IS "elems[i]endl;

}

env-ReleaseIntArrayElements(msg, elems, 0);

3.7 异常处理

由于调用了Java的方法，因此难免产生操作的异常信息，如JAVA函数返回的异常，或者调用JNI方法（如GetMethodID）时抛出的异常。这些异常没有办法通过C++本身的异常处理机制来捕捉到，但JNI可以通过一些函数来获取Java中抛出的异常信息。

Cpp代码

//异常处理

jclass cls = env-FindClass("test/Demo");

jobject obj = env-AllocObject(cls);

jmethodID mid = env-GetMethodID(cls,"throwExcp","()V");

env-CallVoidMethod(obj, mid);

//获取异常信息

string exceptionInfo = "";

jthrowable excp = 0;

excp = env-ExceptionOccurred();

if(excp)

{

jclass cls = env-GetObjectClass(excp);

env-ExceptionClear();

jmethodID mid = env-GetMethodID(cls, "toString","()Ljava/lang/String;");

jstring msg = (jstring) env-CallObjectMethod(excp, mid);

outJStringToCString(env, msg)endl;

env-ExceptionClear();

}

多线程

4.1 多线程中注意事项

JNIEnv和jobject对象都不能跨线程使用

对于jobject，解决办法是

a、m_obj = m_env-NewGlobalRef(obj);//创建一个全局变量

b、jobject obj = m_env-AllocObject(m_cls);//在每个线程中都生成一个对象

对于JNIEnv，解决办法是在每个线程中都重新生成一个env

JNIEnv *env;

m_jvm-AttachCurrentThread((void **)env, NULL);

获取屏幕分辨率：int width=（int）java.awt.Toolkit.getDefaultToolkit().getScreenSize().width;

把tomat/bin下的catalina.bat中的

set JAVA_OPTS=-Xms256m -Xmx512m -Djava.awt.headless=true

改为

set JAVA_OPTS=-Xms256m -Xmx512m -Djava.awt.headless=falsh

就OK了

intdjava的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、intdjava的信息别忘了在本站进行查找喔。

标签：intdjava