配置安全策略时，有两个概念需要清楚的区分 ，用户和角色，简单的说用户为使用计算机的人，可以是个人或组织。角色是一个抽象的概念，泛指职务或者权限。例如，张三，李四，王五三个人，有职员、主管和经理三个职务（权限），张三是用户，张三可以是主管职务，代表张三这个用户含有主管的权利。

不同的servlet容器所提供的用户和角色管理机制是不相同的。我使用的是Tomcat服务器，它提供的用户和角色管理机制文件是在其安装目录下的conf目录中的tomcat-users.xml文件，可以在这个文件里完成对用户和角色的编辑。例如：

<tomcat-users> 
    <role rolename="tomcat"/> 
    <role rolename="role1"/> 
    <user username="tomcat" password="tomcat" roles="tomcat"/> 
    <user username="both" password="tomcat" roles="tomcat,role1"/> 
    <user username="role1" password="tomcat" roles="role1"/> 
</tomcat-users> 

这个文件定义了2个角色(tomcat和role1)和3名用户(tomcat、both和role1)。你可以在tomcat-users.xml文件里定义任意多个用户和角色。

使用Struts 2保护应用程序的资源

Struts 2应用程序的安全策略是通过部署web.xml文件中的security-constraint元素实现的，该元素的语法定义：

<!ELEMENT security-constraint (display-name?, web-resource-collection+, auth-constraint?, user-data-constraint?)>  
<!ELEMENT display-name (#PCDATA)>  
<!ELEMENT web-resource-collection (web-resource-name, description?, url-pattern*, http-method*)>  
<!ELEMENT auth-constraint (description?, role-name*)>  
<!ELEMENT user-data-constraint (description?, transport-guarantee)> 

该语法说明了，security-constraint元素可以有一个可选的display-name子元素，至少一个web-resource-collection子元素，一个可选的auth-constraint子元素和一个可选的user-data-constraint子元素。

web-resource-collection子元素是用来列出打算保护的Web资源，具体的做法是为这些资源设置URL限制，它是通过设置web-resource-collection元素包含的子元素实现的：

◆  web-resource-name：是与受保护资源相关联的名称。该子元素为必须元素。

◆  description：对给定资源的描述。这个子元素为可选元素。

◆  url-pattern：用来设置URL表达式，与这个URL表达式相匹配的URL地址指向的资源将受到保护。该子元素为至少有一个，为必须元素。

◆  http-method：用来表明哪些HTTP方法将受到限制，例如设置为GET那么所有的GET请求就将受到限制。该元素为可选元素。

auth-constraint元素用于指定可以访问该资源用户角色集合。如果没有指定auth-constraint元素，就将安全约束应用于所有角色。它包含下面几个子元素：

◆  description：描述。该元素是可选元素。

◆  role-name：可以访问保护资源的用户角色。该元素可以有多个。

◆  user-data-constraint元素用来设置怎样保护在客户端和Web容器之间传递的数据。

◆  description： 描述。可选元素。

◆  transport-guarantee ：该元素有以下几个值

1. NONE，这意味着应用不需要传输保证。

2. INTEGRAL，意味着服务器和客户端之间的数据必须以某种方式发送，而且在传送中数据不能被篡改。

3. CONFIDENTIAL，这意味着传输的数据必须加密。

配置完毕security-constraint元素的基本信息，大致为下面的格式：

<security-constraint> 
    <web-resource-collection> 
        <web-resource-name>Admin Arew</web-resource-name> 
        <url-pattern>*.action</url-pattern> 
    </web-resource-collection> 
    <auth-constraint> 
        <role-name>myeclipseWeb</role-name> 
    </auth-constraint> 
</security-constraint> 

这个security-constraint元素的效果为：只要与表达式"*.action"匹配的请求不是来自拥有"myeclipseWeb"权限的用户，Web容器就会阻断它。在这里还可以使用http-method元素，阻断特定方法的请求，因为没有使用会阻断所有方法提交的请求。

设置完安全策略后，还需要设置让用户有机会提供证明，证明自己有权限访问这个受限资源的登陆方法。允许使用的登陆方法使用login-config元素设置，下面为login-config元素的语法定义：

<!ELEMENT login-config (auth-method?, realm-name?, form-login-config?)>  
<!ELEMENT auth-method (#PCDATA)>  
<!ELEMENT realm-name (#PCDATA)>  
<!ELEMENT form-login-config (form-login-page, form-error-page)> 

login-config子元素的描述如下：
◆  auth-method指定用来验证用户身份的方法。它的值为下面的一个：BASIC、DIGEST、FORM或 CLIENT-CERT
◆  realm-name指定HTTP Basic验证中在标准登陆框中显示的一条提示。
◆  form-login-config元素是在<auth-method>元素值为"FORM"时使用的。它是指定基于表单的登录中应该使用的登录页面和出错页面。如果没有使用基于表单的验证，则忽略这些元素。这个元素的定义如下，其中form-login-page用于指定显示登录页面的资源路径， form-error-page则用于指定用户登录失败时显示出错页面的资源路径。

<!ELEMENT form-login-config (form-login-page, form-error-page)>  
<!ELEMENT form-login-page (#PCDATA)>  
<!ELEMENT form-error-page (#PCDATA)> 

设置完登陆方法后，还应该使用security-role元素，注册允许用来访问受保护资源所有角色。在该元素内部使用一个role-name子元素来注册一个角色。例如：

<security-role> 
    <role-name>myeclipseWeb</role-name> 
</security-role> 

注册了一个"myeclipseWeb"的角色。

演示示例：使用BASIC登陆方法验证用户身份

1.我使用的Servlet容器是Tomcat，找到它的目录下conf目录中的tomcat-users.xml文件打开内容如下：

<?xml version='1.0' encoding='utf-8'?> 
<tomcat-users> 
    <role rolename="myeclipseWeb"/> 
    <role rolename="myeclipseWebservices"/> 
    <user username="webservices" password="webservices-pwd" roles="myeclipseWebservices"/> 
    <user username="admin" password="admin-pwd" roles="myeclipseWeb,myeclipseWebservices"/> 
    <user username="web" password="web-pwd" roles="myeclipseWeb"/> 
</tomcat-users> 

我使用的IDE是myEclipse9.0，它配置好Tomcat下的tomcat-users.xml文件内容如上，我直接使用它了，你也可以添加自己的角色和用户。该文件定义了2个角色和3个用户，每一个用户都由自己的角色(或者说权限，可以有多重权限)。

2.创建Web项目，找到web.xml，配置它，使它支持Struts 2并且启动Struts 2的安全策略

<?xml version="1.0" encoding="UTF-8"?> 
<web-app id="WebApp_9" version="2.4"  
         xmlns="http://java.sun.com/xml/ns/j2ee"  
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> 
    <display-name>Struts Blank</display-name> 
    <filter> 
        <filter-name>struts2</filter-name> 
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> 
    </filter> 
    <filter-mapping> 
        <filter-name>struts2</filter-name> 
        <url-pattern>/*</url-pattern> 
    </filter-mapping> 
    <welcome-file-list> 
        <welcome-file>index.html</welcome-file> 
    </welcome-file-list> 
    <!--  配置应用程序需要保护的资源与什么角色才可以访问它   --> 
    <security-constraint> 
        <web-resource-collection> 
            <web-resource-name>Admin Arew</web-resource-name> 
            <url-pattern>*.action</url-pattern> 
        </web-resource-collection> 
        <auth-constraint> 
            <role-name>myeclipseWeb</role-name> 
        </auth-constraint> 
    </security-constraint> 
    <!-- 注册可以访问保护资源的角色  --> 
    <security-role> 
        <role-name>myeclipseWeb</role-name> 
    </security-role> 
    <security-role> 
        <role-name>myeclipseWebservices</role-name> 
    </security-role> 
    <!--  设置登录方法  --> 
    <login-config> 
        <auth-method>BASIC</auth-method> 
        <realm-name>User Basic Authentication</realm-name> 
    </login-config> 
</web-app> 

3. 创建接收一个字段信息的动作类：

public class SecureAction extends ActionSupport { 
    private static final long serialVersionUID = 1961430702313132722L; 
    private String username; 
    public String getUsername() { 
        return username; 
    } 
    public void setUsername(String username) { 
        this.username = username; 
    } 
    @Override 
    public String execute() 
    { 
        return SUCCESS; 
    } 
} 

4. 创建struts.xml配置文件，声明动作

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE struts PUBLIC 
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" 
    "http://struts.apache.org/dtds/struts-2.0.dtd"> 
<struts> 
    <package name="securePackage" extends="struts-default"> 
        <action name="secure" class="struts2.action.SecureAction"> 
            <result name="success">/index.jsp</result> 
        </action> 
    </package> 
</struts> 

5. 创建输入页面input.jsp和结果页面index.jsp

input.jsp:

<body> 
    <s:form action="secure"> 
        <s:textfield name="username" label="Enter your name"></s:textfield> 
        <s:submit value="submit"></s:submit> 
    </s:form> 
</body> 

index.jsp

<body> 
    <s:property value="username"/>,Welcome 
</body> 

6.测试效果，在浏览器输入：http://localhost:8081/SecureTest/input.jsp，得到如下自力式温度调节阀界面：输入"Tom"，点击"submit"按钮，查看效果：

看到了登陆框了吧，此时我们要访问的资源是一个受限资源所以要求权限验证顶装式球阀，还记得我们的用户表吧，查看用户表输入用户信息查看结果：

输入"webservices"与"webservices-pwd"的用户信息：

提示了一个"403"错误，这是因为虽然用户信息正确，但是"webservices"用户的没有"myeclipseWeb"权限。

这次输入一个不存在的用户信息：

这次获得了一个"401"错误，这是登陆失败的提示结果，这里会因浏览器的不同而需要不同次数的失败登陆才会得到这个结果。

接下来输入一个正确的用户，并且拥有"webservices"权限的用户信息：

点击"确定"，获得如下结果：

可以看到，我们成功的访问了受保护的资源。若要传中文字，解决方案我已经在前面"配置Struts2"时介绍过了，需要修改Struts 2默认的编码方式还需要修改页面的编码方式，都改为"GBK"。

　　基本参数说明：

　　-client，-server

　　这两个参数用于设置虚拟机使用何种运行模式，client模式启动比较快，但运行时性能和内存管理效率不如server模式，通常用于客户端应用程序。相反，server模式启动比client慢，但可获得更高的运行性能。

　　在 windows上，缺省的虚拟机类型为client模式，如果要使用server模式，就需要在启动虚拟机时加-server参数，以获得更高性能，对服务器端应用，推荐采用server模式，尤其是多个CPU的系统。在Linux，Solaris上缺省采用server模式。

　　-hotspot

　　含义与client相同，jdk1.4以前使用的参数，jdk1.4开始不再使用，代之以client.

　　-classpath，-cp

　　虚拟机在运行一个类时，需要将其装入内存，虚拟机搜索类的方式和顺序如下：

　　Bootstrap classes，Extension classes，User classes.

　　Bootstrap 中的路径是虚拟机自带的jar或zip文件，虚拟机首先搜索这些包文件，用System.getProperty（"sun.boot.class.path"）可得到虚拟机搜索的包名。

　　Extension是位于jre\lib\ext目录下的jar文件，虚拟机在搜索完Bootstrap后就搜索该目录下的jar文件。用System. getProperty（"java.ext.dirs“）可得到虚拟机使用Extension搜索路径。

　　User classes搜索顺序为当前目录、环境变量 CLASSPATH、-classpath.

　　-classpath告知虚拟机搜索目录名、jar文档名、zip文档名，之间用分号；分隔。

　　例如当你自己开发了公共类并包装成一个common.jar包，在使用common.jar中的类时，就需要用-classpath common.jar 告诉虚拟机从common.jar中查找该类，否则虚拟机就会抛出java.lang.NoClassDefFoundError异常，表明未找到类定义。

　　在运行时可用System.getProperty（“java.class.path”）得到虚拟机查找类的路径。

　　使用-classpath后虚拟机将不再使用CLASSPATH中的类搜索路径，如果-classpath和CLASSPATH都没有设置，则虚拟机使用当前路径（。）作为类搜索路径。

　　推荐使用-classpath来定义虚拟机要搜索的类路径，而不要使用环境变量 CLASSPATH的搜索路径，以减少多个项目同时使用CLASSPATH时存在的潜在冲突。例如应用1要使用a1.0.jar中的类G，应用2要使用 a2.0.jar中的类G，a2.0.jar是a1.0.jar的升级包，当a1.0.jar，a2.0.jar都在CLASSPATH中，虚拟机搜索到第一个包中的类G时就停止搜索，如果应用1应用2的虚拟机都从CLASSPATH中搜索，就会有一个应用得不到正确版本的类G.

　　-D<propertyName>=value

　　在虚拟机的系统属性中设置属性名/值对，运行在此虚拟机之上的应用程序可用System.getProperty（“propertyName”）得到value的值。

　　如果value中有空格，则需要用双引号将该值括起来，如-Dname=“space string”。

　　该参数通常用于设置系统级全局变量值，如配置文件路径，应为该属性在程序中任何地方都可访问。

　　-verbose[：class|gc|jni]

　　在输出设备上显示虚拟机运行信息。

　　verbose和verbose：class含义相同，输出虚拟机装入的类的信息，显示的信息格式如下：

　　[Loaded java.io.FilePermission$1 from shared objects file]

　　当虚拟机报告类找不到或类冲突时可用此参数来诊断来查看虚拟机从装入类的情况。

　　-verbose：gc在虚拟机发生内存回收时在输出设备显示信息，格式如下：

　　[Full GC 268K->168K（1984K）， 0.0187390 secs]

　　该参数用来监视虚拟机内存回收的情况。

　　-verbose：jni在虚拟机调用native方法时输出设备显示信息，格式如下：

　　[Dynamic-linking native method HelloNative.sum …… JNI]

　　该参数用来监视虚拟机调用本地方法的情况，在发生jni错误时可为诊断提供便利。

　　-version

　　显示可运行的虚拟机版本信息然后退出。一台机器上装有不同版本的JDK时

　　-showversion

　　显示版本信息以及帮助信息。

　　-ea[：<packagename>……|：<classname>]

　　-enableassertions[：<packagename>……|：<classname>]

　　从JDK1.4开始，java可支持断言机制，用于诊断运行时问题。通常在测试阶段使断言有效，在正式运行时不需要运行断言。断言后的表达式的值是一个逻辑值，为true时断言不运行，为false时断言运行，抛出java.lang.AssertionError错误。

　　上述参数就用来设置虚拟机是否启动断言机制，缺省时虚拟机关闭断言机制，用-ea可打开断言机制，不加<packagename>和 classname时运行所有包和类中的断言，如果希望只运行某些包或类中的断言，可将包名或类名加到-ea之后。例如要启动包com.foo.util 中的断言，可用命令 –ea：com.foo.util .

　　-da[：<packagename>……|：<classname>]

　　-disableassertions[：<packagename>……|：<classname>]

　　用来设置虚拟机关闭断言处理，packagename和classname的使用方法和-ea相同。

　　-esa | -enablesystemassertions

　　设置虚拟机显示系统类的断言。

　　-dsa | -disablesystemassertions

　　设置虚拟机关闭系统类的断言。

　　-agentlib：<libname>[=<options>]

　　该参数是JDK5新引入的，用于虚拟机装载本地代理库。

　　Libname为本地代理库文件名，虚拟机的搜索路径为环境变量PATH中的路径，options为传给本地库启动时的参数，多个参数之间用逗号分隔。在Windows平台上虚拟机搜索本地库名为libname.dll的文件，在 Unix上虚拟机搜索本地库名为libname.so的文件，搜索路径环境变量在不同系统上有所不同，Linux、SunOS、IRIX上为 LD_LIBRARY_PATH，AIX上为LIBPATH，HP-UX上为SHLIB_PATH.

　　例如可使用-agentlib：hprof来获取虚拟机的运行情况，包括CPU、内存、线程等的运行数据，并可输出到指定文件中，可用-agentlib：hprof=help来得到使用帮助列表。在jre\bin目录下可发现hprof.dll文件。

　　-agentpath：<pathname>[=<options>]

　　设置虚拟机按全路径装载本地库，不再搜索PATH中的路径。其他功能和agentlib相同。

　　-javaagent：<jarpath>[=<options>]

　　虚拟机启动时装入java语言设备代理。Jarpath文件中的mainfest文件必须有Agent-Class属性。代理类要实现public static void premain（String agentArgs， Instrumentation inst）方法。当虚拟机初始化时，将按代理类的说明顺序调用premain方法。

　　参见：java.lang.instrument

　　扩展参数说明

　　-Xmixed

　　设置-client模式虚拟机对使用频率高的方式进行Just-In-Time编译和执行，对其他方法使用解释方式执行。该方式是虚拟机缺省模式。

　　-Xint

　　设置-client模式下运行的虚拟机以解释方式执行类的字节码，不将字节码编译为本机码。

　　-Xbootclasspath：path

　　-Xbootclasspath/a：path

　　-Xbootclasspath/p：path

　　改变虚拟机装载缺省系统运行包rt.jar而从-Xbootclasspath中设定的搜索路径中装载系统运行类。除非你自己能写一个运行时，否则不会用到该参数。

　　/a：将在缺省搜索路径后加上path 中的搜索路径。

　　/p：在缺省搜索路径前先搜索path中的搜索路径。

　　-Xnoclassgc

　　关闭虚拟机对class的垃圾回收功能。

　　-Xincgc

　　启动增量垃圾收集器，缺省是关闭的。增量垃圾收集器能减少偶然发生的长时间的垃圾回收造成的暂停时间。但浓浆泵增量垃圾收集器和应用程序并发执行，因此会占用部分CPU在应用程序上的功能。

　　-Xloggc：<file>

　　将虚拟机每次垃圾回收的信息写到日志文件中，文件名由file指定，文件格式是平文件，内容和-verbose：gc输出内容相同。

　　-Xbatch

　　虚拟机的缺省运行方式是在后台编译类代码，然后在前台执行代码，使用-Xbatch参数将关闭虚拟机后台编译，在前台编译完成后再执行。

　　-Xms<size>

　　设置虚拟机可用内存堆的初始大小，缺省单位为字节，该大小为1024的整数倍并且要大于1MB，可用k（K）或m（M）为单位来设置较大的内存数。初始堆大小为2MB.

　　例如：-Xms6400K，-Xms256M

　　-Xmx<size>

　　设置虚拟机内存堆的最大可用大小，缺省单位为字节。该值必须为1024整数倍，并且要大于2MB.可用k（K）或m（M）为单位来设置较大的内存数。缺省堆最大值为64MB.

　　例如：-Xmx81920K，-Xmx80M

　　当应用程序申请了大内存运行时虚拟机抛出java.lang.OutOfMemoryError： Java heap space错误，就需要使用-Xmx设置较大的可用内存堆泵。

　　-Xss<size>

　　设置线程栈的大小，缺省单位为字节。与-Xmx类似，也可用K或M来设置较大的值。通常操作系统分配给线程栈的缺省大小为1MB.

　　另外也可在java中创建线程对象时设置栈的大小，构造函数原型为Thread（ThreadGroup group， Runnable target， String name， long stackSize）。

　　-Xprof

　　输出CPU运行时的诊断信息。

　　-Xfuture

　　对类文件进行严格格式检查，以保证类代码符合类代码规范。为保持向后兼容，虚拟机缺省不进行严格的格式检查。

　　-Xrs

　　减少虚拟机中操作系统的信号（singals）的使用。该参数通常用在虚拟机以后台服务方式运行时使用（如Servlet）。

　　-Xcheck：jni

　　调用JNI函数时进行附加的检查，特别地虚拟机将校验传递给JNI函数参数的合法性，在本地代码中遇到非法数据时，虚拟机将报一个致命错误而终止。使用该阀参数后将造成性能下降。

　　Ergonomics相关的逻辑大都在hotspot/src/share/vm/runtime/arguments.cpp中，值得留意的是使用了FLAG_SET_ERGO（）的地方。

　　于是我们可以留意一下几个版本的HotSpot对UseCompressedOops参数的处理的差异：

　　HotSpot 16：

　　C++代码

　　HotSpot 17:

　　C++代码

　　HotSpot 19 / HotSpot 20:

　　C++代码

　　（注：HotSpot VM的版本号与JDK的版本号之间的关系，请参考另一篇笔记：Sun/Oracle JDK、OpenJDK、HotSpot VM版本之间的对应关系）

　　可以看到，UseCompressedOops参数从HotSpot 19开始终于开始受ergonomics控制，会在下述条件满足的时候默认开启管道磁力泵：

　　1、是64位系统（#ifdef _LP64）并且不是client VM（#ifndef COMPILER1）；

　　2、Java堆的最大大小不大于一个阈值（MaxHeapSize <= max_heap_for_compressed_oops（））；

　　3、没有通过。hotspotrc或命令行参数手动设定过UseCompressedOops参数的值；

　　4、没有使用Garbage-First （G1） GC.

　　还是看回代码，HotSpot 20：

　　C++代码

　　（注：其中 （uint64_t（max_juint） + 1） 的值也被称为NarrowOopHeapMax，也就是2的32次方，0x100000000；

　　ObjectAlignmentInBytes在64位HotSpot上默认为8；

　　HeapWord在globalDefinitions.hpp里定义，大小跟一个char*一样；

　　HeapWordSize在同一个文件里定义，等于sizeof（HeapWord），在64位系统上值为8；

　　LogHeapWordSize也在同一文件里，在64位系统上定义为3）

　　跟踪一下里面几个参数的计算，在64位HotSpot上有，

　　C++代码

　　于是，前面提到的第2个条件在64位HotSpot VM上默认是：

　　C++代码

　　os：：vm_page_size（）是操作系统的虚拟内存的分页大小，在Linux上等于sysconf（_SC_PAGESIZE）的值；在x86_64上的Linux默认分页大小为4KB.

　　MaxHeapSize的值基本上等于-Xmx参数设置的值（会根据分页大小、对齐等因素做调整）。

　　MaxPermSize就是perm gen设置的最大大小。

　　这下可以确认，在我现在用的环境里，当包括perm gen在内的GC堆大小在32GB - 4KB以下的时候，使用64位的JDK 6 update 23或更高版本就会自动开启UseCompressedOops功能

Java中的栈

每当启用一个线程时，JVM就为他分配一个Java栈，栈是以帧为单位保存当前线程的运行状态。某个线程正在执行的方法称为当前方法，当前方法使用的栈帧称为当前帧，当前方法所属的类称为当前类，当前类的常量池称为当前常量池。当线程执行一个方法时，它会跟踪当前常量池。

每当线程调用一个Java方法时，JVM就会在该线程对应的栈中压入一个帧，这个帧自然就成了当前帧。当执行这个方法时，它使用这个帧来存储参数、局部变量、中间运算结果等等。

Java栈上的所有数据都是私有的。任何线程都不能访问另一个线程的栈数据。所以我们不用考虑多线程情况下栈数据访问同步的情况。

像方法区和堆一样，Java栈和帧在内存中也不必是连续的,帧可以分布在连续的栈里，也可以分布在堆里

Java栈的组成元素——栈帧

栈帧由三部分组成：局部变量区、操作数栈、帧数据区。局部变量区和操作数栈的大小要视对应的方法而定，他们是按字长计算的。但调用一个方法时，它从类型信息中得到此方法局部变量区和操作数栈大小，并据此分配栈内存，然后压入Java栈。

局部变量区 局部变量区被组织为以一个字长为单位、从0开始计数的数组，类型为short、byte和char的值在存入数组前要被转换成int值，而long和 double在数组中占据连续的两项，在访问局部变量中的long或double时，只需取出连续两项的第一项的索引值即可,如某个long值在局部变量区中占据的索引时3、4项，取值时，指令只需取索引为3的long值即可。

下面就看个例子，好让大家对局部变量区有更深刻的认识。这个图来自《深入JVM》：

public static int runClassMethod(int i,long l,float f,double d,Object o,byte b) {     
        return 0;     
    }     
         
    public int runInstanceMethod(char c,double d,short s,boolean b) {     
        return 0;     
    }    

上面代码片的方法参数和局部变量在局部变量区中的存储结构如下图：

上面这个图没什么好说的，大家看看就会懂。但是，在这个图里，有一点需要注意：

runInstanceMethod的局部变量区第一项是个reference（引用），它指定的就是对象本身的引用，也就是我们常用的this,但是在runClassMethod方法中，没这个引用，那是因为runClassMethod是个静态方法。

操作数栈和局部变量区一样，操作数栈也被组织成一个以字长为单位的数组。但和前者不同的是，它不是通过索引来访问的，而是通过入栈和出栈来访问的。可把操作数栈理解为存储计算时，临时数据的存储区域。下面我们通过一段简短的程序片段外加一幅图片来了解下操作数栈的作用。

int a = 100;

int b = 98;

int c = a+b;

从图中可以得出：操作数栈其实就是个临时数据存储区域，它是通过入栈和出栈来进行操作的。

帧数据区除了局部变量区和操作数栈外，Java栈帧还需要一些数据来支持常量池解析、正常方法返回以及异常派发机制。这些数据都保存在Java栈帧的帧数据区中。
当JVM执行到需要常量池数据的指令时，它都会通过帧数据区中指向常量池的指针来访问它。

除了处理常量池解析外，帧里的数据还要处理Java方法的正常结束和异常终止。如果是通过return正常结束，则当前栈帧从Java栈中弹出，恢复玻璃钢液下泵发起调用的方法的栈。如果方法又返回值，JVM会把返回值压入到发起调用方法的操作数栈。

为了处理Java方法中的异常情况，帧数据区还必须保存一个对此方法异常引用表的引用。当异常抛出时，JVM给catch块中的代码。如果没发现，方法立即终止，然后JVM用帧区数据的信息恢复发起调用的方法的帧。然后再发起调用方法的上下文重新抛出同样的异常。

栈的整个结构

在前面就描述过：栈是由栈帧组成，每当线程调用一个Java方法时，JVM就会在该线程对应的栈中压入一个帧，而帧是由局部变量区、操作数栈和帧数据区组成。那在一个代码块中，栈到底是什么形式呢？下面是我从《深入JVM》中摘抄的一个例子，大家可以看看：

代码片段：

执行过程中的三个快照：

上面所给的图，只想说明两件事情，我们也可用此来理解Java中的栈：

1、只有在调用一个方法时，才为当前栈分配一个帧，然后将该帧压入栈。

2、帧中存储了对应方法的局部数据，方法执行完，对应的帧则从栈中弹出，并把返回结果存储在调用方法的帧的操作数栈中。

　　（1）"模糊"类文件，加大反编译器反编译源代码文件的难度。然而，可以修改反编译器，使之能够处理这些模糊类文件。所以仅仅依赖"模糊类文件"来保证代码的安全是不够的。

　　（2）流行的加密工具对源文件进行加密，比如PGP（Pretty Good Privacy）或GPG（GNU Privacy Guard）。这时，最终用户在运行应用之前必须先进行解密。但解密之后，最终用户就有了一份不加密的类文件，这和事先不进行加密没有什么差别。

　　（3）加密类文件，在运行中JVM用定制的类装载器（Class Loader）解密类文件。Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改。JVM每次装入类文件时都需要一个称为ClassLoader的对象，这个对象负责把新的类装入正在运行的JVM。JVM给ClassLoader一个包含了待装入类（例如java.lang.Object）名字的字符串，然后由ClassLoader负责找到类文件，装入原始数据，并把它转换成一个Class对象。

　　用户下载的是加密过的类文件，在加密类文件装入之时进行解密，因此可以看成是一种即时解密器。由于解密后的字节码文件永远不会保存到文件系统，所以窃密者很难得到解密后的代码。

　　由于把原始字节码转换成Class对象的过程完全由系统负责，所以创建定制ClassLoader对象其实并不困难，只需先获得原始数据，接着就可以进行包含解密在内的任何转换。

　　Java密码体系和Java密码扩展

　　Java密码体系(JCA)和Java密码扩展(JCE)的设计目的是为Java提供与实现无关的加密函数API。它们都用factory方法来创建类的例程，然后把实际的加密函数委托给提供者指定的底层引擎,引擎中为类提供了服务提供者接口在Java中实现数据的加密/解密，是使用其内置的JCE(Java加密扩展)来实现的。Java开发工具集1.1为实现包括数字签名和信息摘要在内的加密功能，推出了一种基于供应商的新型灵活应用编程接口。Java密码体系结构支持供应商的互操作,同时支持硬件和软件实现。

　　Java密码学结构设计遵循两个原则:

　　(1)算法的独立性和可靠性。

　　(2)实现的独立性和相互作用性。

　　算法的独立性是通过定义密码服务类来获得。用户只需了解密码算法的概念,而不用去关心如何实现这些概念。实现的独立性和相互作用性通过密码服务提供器来实现。密码服务提供器是实现一个或多个密码服务的一个或多个程序包。软件开发商根据一定接口,将各种算法实现后,打包成一个提供器,用户可以安装不同的提供器。安装和配置提供器,可将包含提供器的ZIP和JAR文件放在CLASSPATH下,再编辑Java安全属性文件来设置定义一个提供器。Java运行环境Sun版本时, 提供一个缺省的提供器Sun。

　　下面介绍DES算法及如何利用DES算法加密和解密类文件的步骤。

　　DES算法简介

　　DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。

　　DES算法工作流程如下：若Mode为加密模式，则利用Key 对数据Data进行加密， 生成Data的密码形式（64位）作为DES的输出结果；如Mode为解密模式，则利用Key对密码形式的数据Data进行解密，还原为Data的明码形式（64位）作为DES的输出结果。在上海针型阀通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据在公共通信网中传输的安全性和可靠性。

　　也可以通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性。
　　利用DES算法加密的步骤

　　（1）生成一个安全密钥。在加密或解密任何数据之前需要有一个密钥。密钥是随同被加密的应用程序一起发布的一段数据，密钥代码如下所示。

　　【生成一个密钥代码】

view plaincopy to clipboardprint?
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 为我们选择的DES算法生成一个KeyGenerator对象
KeyGenerator kg = KeyGenerator.getInstance ("DES" );
Kg.init (sr);
// 生成密钥
Secret Key key = kg.generateKey();
// 将密钥数据保存为文件供以后使用，其中key Filename为保存的文件名
Util.writeFile (key Filename, key.getEncoded () );
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 为我们选择的DES算法生成一个KeyGenerator对象
KeyGenerator kg = KeyGenerator.getInstance ("DES" );
Kg.init (sr);
// 生成密钥
Secret Key key = kg.generateKey();
// 将密钥数据保存为文件供以后使用，其中key Filename为保存的文件名
Util.writeFile (key Filename, key.getEncoded () );

　　（2）加密数据。得到密钥之后，接下来就可以用它加密数据。如下所示。

　　【用密钥加密原始数据】

view plaincopy to clipboardprint?
// 产生一个可信任的随机数源
SecureRandom sr = new SecureRandom();
//从密钥文件key Filename中得到密钥数据
Byte rawKeyData = Util.readFile (key Filename);
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec (rawKeyData);
// 创建一个密钥工厂，然后用它把DESKeySpec转换成Secret Key对象
SecretKeyFactory key Factory = SecretKeyFactory.getInstance("DES" );
Secret Key key = keyFactory.generateSecret( dks );
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密钥初始化Cipher对象
cipher.init( Cipher.ENCRYPT_MODE, key, sr );
// 通过读类文件获取需要加密的数据
Byte data = Util.readFile (filename);
// 执行加密操作
Byte encryptedClassData = cipher.doFinal(data );
// 保存加密后的文件，覆盖原有的类文件。
Util.writeFile( filename, encryptedClassData );
// 产生一个可信任的随机数源
SecureRandom sr = new SecureRandom();
//从密钥文件key Filename中得到密钥数据
Byte rawKeyData = Util.readFile (key Filename);
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec (rawKeyData);
// 创建一个密钥工厂，然后用它把DESKeySpec转换成Secret Key对象
SecretKeyFactory key Factory = SecretKeyFactory.getInstance("DES" );
Secret Key key = keyFactory.generateSecret( dks );
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密钥初始化Cipher对象
cipher.init( Cipher.ENCRYPT_MODE, key, sr );
// 通过读类文件获取需要加密的数据
Byte data = Util.readFile (filename);
// 执行加密操作
Byte encryptedClassData = cipher.doFinal(data );
// 保存加密后的文件，覆盖原有的类文件。
Util.writeFile( filename, encryptedClassData );

　　（3）解密数据。运行经过加密的程序时，ClassLoader分析并解密类文件。操作步骤如下所示。

　　【用密钥解密数据】

view plaincopy to clipboardprint?
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从密钥文件中获取原始密钥数据
Byte rawKeyData = Util.readFile( keyFilename );
// 创建一个DESKeySpec对象
DESKeySpec dks = new DESKeySpec (rawKeyData);
// 创建一个密钥工厂，然后用它把DESKeySpec对象转换成Secret Key对象
SecretKeyFactory key Factory = SecretKeyFactory.getInstance( "DES" );
SecretKey key = keyFactory.generateSecret( dks );
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密钥初始化Cipher对象
Cipher.init( Cipher.DECRYPT_MODE, key, sr );
// 获得经过加密的数据
Byte encrypted Data = Util.readFile (Filename);
//执行解密操作
Byte decryptedData = cipher.doFinal( encryptedData );
// 然后将解密后的数据转化成原来的类文件。
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从密钥文件中获取原始密钥数据
Byte rawKeyData = Util.readFile( keyFilename );
// 创建一个DESKeySpec对象
DESKeySpec dks = new DESKeySpec (rawKeyData);
// 创建一个密钥工厂，然后用它把DESKeySpec对象转换成Secret Key对象
SecretKeyFactory key Factory = SecretKeyFactory.getInstance( "DES" );
SecretKey key = keyFactory.generateSecret( dks );
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance( "DES" );
// 用密钥初始化Cipher对象
Cipher.init( Cipher.DECRYPT_MODE, key, sr );
// 获得经过加密的数据
Byte encrypted Data = Util.readFile (Filename);
//执行解密操作
Byte decryptedData = cipher.doFinal( encryptedData );
// 然后将解密后的数据转化成原来的类文件。

　　将上述代码与自定义的类装载器结合就可以做到边解密边运行，从而起到保护源代码的作用。

　　结束语

　　加密/解密是数据传输中保证数据安全性和完整性的常用方法，Java语言因其平台无关性，在Internet上的应用非常之广泛。使用DES算法加密Java源码在一定程度上能保护软件的产权。

UserDao 接口：

/**  
 * 远程接口     必须继承与Remote对象  
 * @author spring sky  
 * date: 2012年2月7日 10:55:05  
 * Email:vipa1888@163.com  
 * QQ:840950105  
 */ 
public interface UserDao extends Remote{  
    /**  
     * 简单的测试方法  
     * @param name  
     */ 
    public void sayName(String name) throws RemoteException;   
 
 
} 

UserDaoImpl实现类

/**  
 *   
 *  接口的实现类    必须继承UnicastRemoteObject(单一远程对象)   实现UserDao自己的接口  
 * @author spring sky  
 * date: 2012年2月7日 10:56:05  
 * Email:vipa1888@163.com  
 * QQ:840950105  
 */ 
public class UserDaoImpl extends UnicastRemoteObject implements UserDao {  
 
    public UserDaoImpl() throws RemoteException {  
    }  
    @Override 
    public void sayName(String name) {  
        if(name!=null&&!name.equals(""))  
        {  
            System.out.println("我的名字是："+name);  
        }else{  
            System.err.println("名字不为空....");  
        }  
    }  
 
} 

对外的提供一个服务，服务中已经共享了url给外界访问

/**  
 * 使用main方法启动一个服务，用于外界环境访问  
 * @author spring sky  
 * date:2012年2月7日 10:57:37  
 * Email:vipa1888@163.com  
 * QQ:840950105  
 */ 
public class StartService {  
    private static final String IP = "127.0.0.1";  
    private static final int PORT = 9999;  
    private static final String REMOTE_NAME = "userDao";  
    private static final String REMOTE_URL = "rmi://"+IP+":"+PORT+"/"+REMOTE_NAME;  
    public static void main(String[] args) {  
        try {  
            UserDao userDao = new UserDaoImpl();    //实例化对象  
            LocateRegistry.createRegistry(PORT);    //注册端口  
            Naming.bind(REMOTE_URL, userDao);       //绑定远程服务对象  
            System.out.println("远程"+REMOTE_NAME+"启动成功....");  
        } catch (RemoteException e) {  
            System.err.println("远程对象出错");  
            e.printStackTrace();  
        } catch (MalformedURLException e) {  
            System.err.println("URL出错了");  
            e.printStackTrace();  
        } catch (AlreadyBoundException e) {  
            System.err.println("绑定的对象已经存在了");  
            e.printStackTrace();  
        }  
    }  
} 

上面是服务端的代码，如果启动没有任何问题，就可以做客户端访问了，其实上海旋塞阀客户端的访问更加的简单，只需要远程的接口类和查询rmi中的url就可以了！

代码如下：

/**  
 * 远程方法调用测试  
 * @author spring sky  
 * date:2012年2月7日 11:12:46  
 * Email:vipa1888@163.com  
 * QQ:840950105  
 * name:石明政  
 */ 
public class TestRemote {  
    public static void main(String[] args) {  
        try {  
            //在rmi服务中查询userdao的对象  
            UserDao userDao = (UserDao) Naming.lookup("rmi://127.0.0.1:9999/userDao");     
            //调用远程服务的方法  
            userDao.sayName("spring sky");  
        } catch (MalformedURLException e) {  
            System.err.println("URL出错");  
            e.printStackTrace();  
        } catch (RemoteException e) {  
            System.err.println("远程对象出错");  
            e.printStackTrace();  
        } catch (NotBoundException e) {  
            System.err.println("没有找到绑定的对象");  
            e.printStackTrace();  
        }  
    }  
} 

以上就是所有的rmi远程调用代码了！运行结果如下：

好了，本人也只是简单的了解了rmi，如果以后有项目做rmi就可以深入了！ 呵呵  ，在这里我突然感觉，想web service也应该和他一样的原理的把！

1、如何判断横竖屏切换

横竖屏切换由手机系统自动完成的，在J2ME中只能检测到这种变换，判断横竖屏切换的方法有2种：

A)线程中每次检测法(轮询方式)

这种方式是在程序的线程中每隔一定的时间间隔，就获得一次屏幕的宽度和高度，然后判断宽度和高度是否变化，如果宽度和高度和已有的宽度和高度相比发生了变化，至于是变化成横屏还是竖屏则只需要比较宽高就可以实现。在判断到横竖屏切换时，执行逻辑代码即可。

使用这种方式由于每次线程循环都需要检测，所以执行效率不高，但是由于一些转屏手机不支持sizeChanged的方法回调，所以使用这种方式的通用性是最高的，是经常被使用的方法。

B)sizeChanged法(中断方式)

这种方式是指如果转屏手机对于MIDP支持比较规范，则当横竖屏切换时会自动调用Canvas类中的sizeChanged方法，这样就需要在Canvas的子类中覆盖该方法即可，在该方法内部书写横竖屏切换的逻辑处理代码即可。

使用这种方式由于是系统自动调用，所以执行效率很好，但是由于部分手机实现的不规范，所以通用性没有第一种方式高。

说明：高级用户界面自动切换，不需要书写处理的代码。

2、如何处理横竖屏切换

在检测到横竖屏切换以后，就需要对于横竖屏切换进行处理了，处理的方式一般有也有两种：

A)简单提示法

这种处理方式时指只实现一种屏幕模式下的逻辑，而在另外一种屏幕方式下显示提示。例如只实现竖屏模式的界面，在横屏模式下，只出现提示：“请在竖屏模式下使用本程序”。

使用这种方式程序实现比较简单，只需要实现一套界面即可，适合于比较简单的程序。

B)实现两套UI法

这种处理方式时指在一个程序中实现两套界面：一套横屏一套竖屏。可以在程序中设置一个screenType的参数，在每个节目的绘制上海电磁阀方法中根据该参数判断是横屏还是竖屏，然后执行不同的绘制代码即可。

使用这种方式程序实现比较友好，但是程序开发和测试的工作量都要稍微大一点，而且横竖屏切换时数据的变换也比较麻烦。

3、其它说明

在实现横竖屏切换时，有些知识会帮助你实现一些很实用的功能：

在Nokia手机上禁止横竖屏切换：

在S60 5th 及以上版本中，可以通过在jad或manifest文件中通过指定如下属性来指定程序运行时的屏幕类型：

竖屏：Nokia-MIDlet-App-Orientation：portrait

横屏：Nokia-MIDlet-App-Orientation：landscape

不足之处希望大家积极指正、交流和完善！

　　但是我们一般都是用Java ME开发，开发出来的程序是jar格式，可以运行在大部分型号的手机上。可是BlackBerry是不支持jar的，它支持的是cod格式。所以如果你想你开发的Java ME程序运行在BlackBerry上，就必须先把它转为cod格式。

　　要把一般Java ME程序转为cod可以在程序开发编译过程序中转，也可以对打包好的jar转。

　　◆对已经打包好的jar文件转为BlackBerrycod格式:进入jar文件所在目录，在cmd(命令行)中进入相应目录，输入下边命令就可以了：引用rapc import="C:\Program Files\Research In Motion\BlackBerry JDE 4.2.1\lib\net_rim_api.jar" codename=TestBB jad=TestBB.jad TestBB.jar

　　(注：这里rapc 是 C:\Program Files\Research In Motion\BlackBerry JDE 4.2.1\bin\ 目录里的 rapc.exe, 如果环境变量没有设置，这里就要用绝对路径：C:\Program Files\Research In Motion\BlackBerry JDE 4.2.1\bin\rapc, 当然你可以把它写成一个.bat文件来执行。而网上你可以搜索到一个名为Java2Cod.exe的小程序可以直接转换。)

　　◆在JDE中编译程序:无论你是用BlackBerry API或者Java ME/midp API来开发Java ME程序，都可以在JDE上编译。最终他会自动打包成cod文件。

　　◆在其IDE中编译打包：因为我是用NetBeans来开发的，所以本人只能提供NetBeans开发BlackBerry程序的见解。而本人是在 NetBeans中用Java ME polish来整合开发的。下边介绍Java ME polish中开发BlackBerry程序

　　（可以参考http://www.j2mepolish.org/docs/platform-blackberry.html）

　　一、在Java ME polish安装目录里找到platforms.xml,在里边的BlackBerry部分中，加上<capability name="build.Finalizer" value="jar2cod" />（我用的是Preview 2.0版本，里边这一句是注释掉，所以要把它activate，也可以在devices.xml中在你想用的emulator 属性里加上这一句。如果没有这一句编译时就不会自动把jar转换为cod文件的.）

　　polish里支持的版本最新系4.2.0,如果你安装BlackBerry版本最新的如4.2.1/4.3.0,哪么你要把${BlackBerry目录}/lib/net_rim_API.jar copy到${Java MEpolish}/import里，在platforms.xml的BlackBerry中修改<capability name="build.BootClassPath" value="net_rim_API.jar" />

　　二、在工程的build.xml中添加blackberry.home属性（你安装的BlackBerry JDE目录）

　　Java代码

　　三、如果你编译后打包的jad文件中缺少MicroEdition-Configuration和MicroEdition-Profile两个属性是不能成功转成cod文件的。这可以在工程的build.xml中的<build>属性里的<jad>元素中添加：

　　Java代码

<jad>     <attribute target="jad" name="
MicroEdition-Configuration" value="CLDC-1.1" 
if="polish.cldc11"/>     <attribute target="jad" 
name="MicroEdition-Profile" value="MIDP-2.0"/>    
</jad>

　　四、如果你用了混淆器的（obfuscator），要把它unactivate,不要用它，因为BlackBerry中的rapc转换过程中会对程序混淆的。

　　Java代码

<obfuscator name="ProGuard" unless="test or polish.blackberry" >    
</obfuscator>

　　五、在工程的build.xml中的<Java MEpolish>属性requirements用你想编译的BlackBerryemulator,如：

　　Java代码

<deviceRequirements>      
<requirement name="Identifier" value="BlackBerry/8800" />              
</deviceRequirements>

　　如果你的程序是一般的Java ME程序，那么就可以编译运行了。但如果你是用BlackBerry API开发的上海柱塞阀，就要就把build.xml里<build>元素中的<midlet>,改为<main>，同时要添加polish.classes.midlet-1的variable。如：

　　Java代码

<!-- midlets definition -->   
<main class="com.protel.BlackBerryim.ui.BlackBerryIMMidlet" />     
<!-- project-wide variables - used for preprocessing  -->   
<variables> <variable name="polish.classes.midlet-1" value=" " />    
</variables>

　　(注：polish.classes.midlet-1的value是" "，中间有一个空格的，我试过了，如果没有这个定义变量或者这个值中间没有空格，jar是不能转为cod格式。)

　　这是我初接触BlackBerry时的一点心得。我用BlackBerry API在NetBeans+Java ME polish的环境下写过一个test app，是能成功运行的，希望对初接触BlackBerry的朋友有帮助。

在我的项目中要用到一个聚类算法，Affinity Propagation（AP），由多伦多大学的Brendan J. Frey发表于2007年。相比其他的聚类算法，AP算法的聚类结果更加准确。

在AP的官方网站公布了AP算法的动态链接库，我的目标就是实现在Java工程中调用这个动态链接库。

在网上查了资料，发现，如果仅仅是想调用Windows的Native API还是比较省事的，这里我主要针对第三方dll的调用。

下面进入正题。

这里主要用的方法是JNI。在网上查资料时看到很多人说用JNI非常的复杂，不仅要看很多的文档，而且要非常熟悉C/C++编程。恐怕有很多人在看到诸如此类的评论时已经决定绕道用其他方法了。但是，假如你要实现的功能并不复杂（简单的参数传递，获取返回值等等），我还是支持使用这个方法的。

Java Native Interface，简称JNI，是Java平台的一部分，可用于让Java和其他语言编写的代码进行交互。下面是从网上摘取的JNI工作示意图。

图1 JNI的工作模式

下面就举具体的例子说明一下使用步骤：

1） 编写一个类，声明native方法

public class APCluster {   
    public native int[] CallAPClusterDll( int         arg_Int,   
                                          double[]    arg_DoubleArray,   
                                          boolean     arg_boolean);  
    static 
    {  
        System.loadLibrary("APClusterDllMedium");  
    }  
} 

上面是APCluster.java文件，定义了一个APCluster类，其中有一个方法CallAPClusterDll()，需要传递三种不同类型的参数，并且返回一个整型数组。

注意，这里只需要声明这个方法，并不需要实现，具体实现就在APClusterDllMedium中。

APClusterDllMedium就像中介一样，Java通过调用这个中介Dll中的CallAPClusterDll方法，间接调用真正的第三方Dll。

2）编译生成.h文件

第一步：

javac APCluster.java 生成APCluster.class

第二步：

javah APCluster 生成APCluster.h头文件，内容如下：

/* DO NOT EDIT THIS FILE - it is machine generated */ 
#include <jni.h>  
/* Header for class APCluster */ 
#ifndef _Included_APCluster  
#define _Included_APCluster  
#ifdef __cplusplus  
extern "C" {  
#endif10 /*  
 * Class:     APCluster  
 * Method:    CallAPClusterDll  
 * Signature: (I[DZ)[I  
 */ 
JNIEXPORT jintArray JNICALL Java_APCluster_CallAPClusterDll  
  (JNIEnv *, jobject, jint, jdoubleArray, jboolean);  
#ifdef __cplusplus  
}  
#endif21
#endif 

注意，APCluster.h这个头文件的内容是不能修改的，否则JNI会找不到相对应的CallAPClusterDll()的实现。

3）创建C/C++工程，实现CallAPClusterDll()方法。

创建一个C/C++工程，工程名为APClusterDllMedium（其实，生成的dll名为APClusterDllMedium即可），导入APCluster.h这个头文件，并创建一个CPP文件，实现.h文件中的方法。

 
图2 新建工程结构

由于我创建的工程是win32控制台程序，所以最后默认生成的是.exe文件，所以还要做一步工程属性修改，让它生成.dll后缀文件。

打开Project Property ->General，做以下修改：

 
图3 修改工程属性

下面就是实现 JNIEXPORT jintArray JNICALL Java_APCluster_CallAPClusterDll (JNIEnv *, jobject, jint, jdoubleArray, jboolean); 这个方法了。先贴代码再慢慢解释吧。

#include "APCluster.h"   
#include <stdio.h>   
#include <windows.h>  
#ifdef __cplusplus   
extern "C" {  
#endif  
typedef int*  (__stdcall *APCLUSTER32)(double*, unsigned int, bool);  
JNIEXPORT jintArray JNICALL Java_APCluster_CallAPClusterDll  
  (JNIEnv *env, jobject _obj, jint _arg_int, jdoubleArray _arg_doublearray, jboolean _arg_boolean)  
{  
    HMODULE dlh = NULL;  
    APCLUSTER32 apcluster32;  
    if (!(dlh=LoadLibrary("apclusterwin.dll")))        //第三方DLL位置  
    {  
        printf("LoadLibrary() failed: %d\n", GetLastError());   
    }  
    if (!(apcluster32 = (APCLUSTER32)GetProcAddress(dlh, "apcluster32")))    //具体调用apcluster32方法  
    {  
        printf("GetProcAddress() failed: %d\n", GetLastError());   
    }  
    int        m_int = _arg_int;  //类型转换  
    double*    m_doublearray = env->GetDoubleArrayElements(_arg_doublearray, NULL);  
    bool       m_boolean = _arg_boolean;  
    int* ret = (*apcluster32)(m_doublearray, m_int, m_boolean); /* actual function call */ 
    jintArray result = env->NewIntArray(_arg_int);  
    env->SetIntArrayRegion(result, 0, _arg_int, (const jint*)ret);  
    FreeLibrary(dlh); /* unload DLL and free memory */ 
    if(ret)   
    {  
         free(ret);   
    }  
    return result;  
}  
#ifdef __cplusplus  
}  
#endif 

a）首先为了#include <jni.h>，必须添加JNI所在的目录。

打开Project Property -> C/C++ -> General -> Additional Include Directories添加相应目录：

 
图4 添加JNI目录

b）在APCluster.h文件中自动生成的函数，只标识了函数参数类型，为了引用这些参数，自己起一个相应的名字：

JNIEXPORT jintArray JNICALL Java_APCluster_CallAPClusterDll
(JNIEnv *env, jobject _obj, jint _arg_int, jdoubleArray _arg_doublearray, jboolean _arg_boolean) ......

c）声明函数指针，就是你要调用的第三方dll中函数的类型。

d）LoadLibrary，导入真正的第三方Dll，并找到要调用的方法的函数地址。

把这个函数地址赋值给函数指针，接下来就可以通过这个函数指针调用真正的apcluster函数了！

e）类型转换：

读读jni.h文件就知道jdouble和double其实是一个东西，jboolean就是unsigned char类型，jni.h中是这么声明的：

typedef unsigned char    jboolean;  
typedef unsigned short   jchar;  
typedef short            jshort;  
typedef float            jfloat;  
typedef double           jdouble; 

但是数组类型就没有这么简单，获取数组要使用类型相对应的env->GetTypeArrayElement(jTypeArray...)。

最后，要返回一个jint类型的数组，就要新创建一个此类型的数组，再为其赋值：

jintArray result = env->NewIntArray(_arg_int);  
env->SetIntArrayRegion(result, 0, _arg_int, (const jint*)ret); 

其中，_arg_int代表的是创建数组的长度。

最后return result。

4）Build这个工程。

Build，生成相应的APCluster.dll文件，将这个dll放到java工程目录下。

 
图5 将生成的dll放到java工程下

5）编写测试java程序，调用dll库。

以下为测试程序，Test.java：

public class Test    
{  
    public static void main(String[] args)   
    {   
        double     arg_doublearray[] = {0.1, 0.2, 0.3};   
        int        arg_int = 3;   
        boolean    arg_boolean = true;   
        int[]  result = new APCluster().CallAPClusterDll(arg_int, arg_doublearray, arg_boolean);  
        .....  
    }  
} 

到此，java调用第三方dll就基本完成了。

本文也主要是介绍大概的操作流程，至于具体应该使用哪些API就只有去研究官方文档了。

另外还有一些需要注意的问题，比如64位的程序去调用32位的dll会报错啊等等...这些都是细节问题了。

最后，个人认为，自己动手实践还是很重要，网上都说这个复杂那个难，但是至于难还是不难，还是要实践了才知道...不能不去尝试...