BlogJava-lanxin1020-随笔分类-j2se

try…catch…finally(转)

lanxin1020 — Fri, 08 May 2009 07:23:00 GMT

1 引子
try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
public class TestException
{
    public TestException()
    {
    }
    boolean testEx() throws Exception
    {
        boolean ret = true;
        try
        {
            ret = testEx1();
        }
        catch (Exception e)
        {
            System.out.println("testEx, catch exception");
            ret = false;
            throw e;
        }
        finally
        {
            System.out.println("testEx, finally; return value=" + ret);
            return ret;
        }
    }
    boolean testEx1() throws Exception
    {
        boolean ret = true;
        try
        {
            ret = testEx2();
            if (!ret)
            {
                return false;
            }
            System.out.println("testEx1, at the end of try");
            return ret;
        }
        catch (Exception e)
        {
            System.out.println("testEx1, catch exception");
            ret = false;
            throw e;
        }
        finally
        {
            System.out.println("testEx1, finally; return value=" + ret);
            return ret;
        }
    }
    boolean testEx2() throws Exception
    {
        boolean ret = true;
        try
        {
            int b = 12;
            int c;
            for (int i = 2; i >= -2; i--)
            {
                c = b / i;
                System.out.println("i=" + i);
            }
            return true;
        }
        catch (Exception e)
        {
            System.out.println("testEx2, catch exception");
            ret = false;
            throw e;
        }
        finally
        {
            System.out.println("testEx2, finally; return value=" + ret);
            return ret;
        }
    }
    public static void main(String[] args)
    {
        TestException testException1 = new TestException();
        try
        {
            testException1.testEx();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}
你的答案是什么？是下面的答案吗？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。
现在公布正确答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false

2 基础知识

2.1 相关概念
例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。
Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。
2.2 Throwable类及其子类
　用面向对象的方法处理例外，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。
从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。
　

2.3 　异常处理关键字
Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：
Throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
Try： Opening exception-handling statement.
Catch： Captures the exception.
Finally： Runs its code before terminating the program.
2.3.1 try语句　
try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
2.3.2 catch语句　
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。　
2.3.3 finally语句　
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。
2.3.4 throws语句　
throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException，或它们的子类，这个规则不起作用，因为这在程序的正常部分中是不期待出现的。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。
2.3.5 throw语句　
throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

3 关键字及其中语句流程详解

3.1 try的嵌套
你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。
class MultiNest {
    static void procedure() {
        try {
            int a = 0;
            int b = 42/a;
        } catch(java.lang.ArithmeticException e) {
            System.out.println("in procedure, catch ArithmeticException: " + e);
        }
    }
    public static void main(String args[]) {
        try {
            procedure();
        } catch(java.lang. Exception e) {
            System.out.println("in main, catch Exception: " + e);
        }
    }
}
这个例子执行的结果为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
成员函数procedure里有自己的try/catch控制，所以main不用去处理 ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
in main, catch Exception: java.lang.ArithmeticException: / by zero

3.2 try-catch程序块的执行流程以及执行结果
相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
    1．如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。
    2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
-->如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
-->如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。
    3．如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。

3.3 try-catch-finally程序块的执行流程以及执行结果
try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
-->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
-->如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：
-->如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
-->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
-->如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：
-->如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。
这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）
-->如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3．如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：
-->如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
3.4 try-catch-finally程序块中的return
从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。
例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。
3.5 如何抛出异常
如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：
第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。
    boolean testEx2() throws Exception{
        boolean ret = true;
        int b=12;
        int c;
        for (int i=2;i>=-2;i--){
            c=b/i;
            System.out.println("i="+i);
        }
        return true;
}
第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
    boolean testEx2() throws Exception{
        boolean ret = true;
        try{
            int b=12;
            int c;
            for (int i=2;i>=-2;i--){
                c=b/i;
                System.out.println("i="+i);
            }
            return true;
        }catch (Exception e){
            System.out.println("testEx2, catch exception");
            Throw e;
        }
    }
第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
    boolean testEx2() throws Exception{
        boolean ret = true;
        try{
            int b=12;
            int c;
            for (int i=2;i>=-2;i--){
                c=b/i;
                System.out.println("i="+i);
                throw new Exception("aaa");
            }
            return true;
        }catch (java.lang.ArithmeticException e){
            System.out.println("testEx2, catch exception");
            ret = false;
            throw new Exception("aaa");
        }finally{
            System.out.println("testEx2, finally; return value="+ret);
        }
    }
4 关于abrupt completion
前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。
4.1 Normal and Abrupt Completion of Evaluation
每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。
与表达式、操作符相关的运行期异常有：
-->A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
-->An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
-->A field access throws a NullPointerException if the value of the object reference expression is null.
-->A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
-->An array access throws a NullPointerException if the value of the array reference expression is null.
-->An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
-->A cast throws a ClassCastException if a cast is found to be impermissible at run time.
-->An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
-->An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：
-->break, continue, and return 语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。
-->某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。
如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.
导致abrupt completion的几种原因：
-->A break with no label
-->A break with a given label
-->A continue with no label
-->A continue with a given label
-->A return with no value
-->A return with a given value A
-->throw with a given value, including exceptions thrown by the Java virtual machine
5 关于我们的编程的一点建议
弄清楚try-catch-finally的执行情况后我们才能正确使用它。
如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。（我们需要记住：不仅throw语句是abrupt completion 的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。）

lanxin1020 2009-05-08 15:23 发表评论

xml解析

lanxin1020 — Fri, 08 May 2009 02:52:00 GMT

    1.详解

    1）DOM（JAXP Crimson解析器）
    DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

    2）SAX

    SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

    选择DOM还是选择SAX？对于需要自己编写代码来处理XML文档的开发人员来说，选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。

    DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

    SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

    3）JDOM http://www.jdom.org

    JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

    JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。

    JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题”（根据学习曲线假定为20%）。JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习DOM或JDOM接口都更有意义的工作。

    JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档（尽管它还可以将以前构造的DOM表示作为输入）。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

    4）DOM4J http://dom4j.sourceforge.net

    虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始，它就一直处于开发之中。

    为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。

    在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。

    DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J.

    2。比较

    1）DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

    2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在JavaScript中使用DOM）。

    3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

    3. 四种xml操作方式的基本使用方法
    xml文件：

Xml代码

xml version="1.0" encoding="gbk"?><list><node><name>weideweiname><space>http://wishlife.javaeye.comspace>node><node><name>flyingname><space>http://user.qzone.qq.com/94611981space>node>list>

weideweihttp://wishlife.javaeye.comflyinghttp://user.qzone.qq.com/94611981

程序代码:

Java代码

import java.io.File;
import java.util.Iterator;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.dom4j.io.SAXReader;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
/**
* DOM方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void DOM() {
long lasting = System.currentTimeMillis();
try {
File f = new File("F:/xmltest.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("node");
for (int i = 0; i < nl.getLength(); i++) {
System.out.println("|| Name: |"
+ doc.getElementsByTagName("name").item(i)
.getFirstChild().getNodeValue());
System.out.println("||Space: |"
+ doc.getElementsByTagName("space").item(i)
.getFirstChild().getNodeValue());
System.out.println("-------------------------------------------------"); }
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("DOM RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
/**
* SAX方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void SAX() {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("F:/xmltest.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("SAX RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
public void startElement(String uri, String localName, String qName,
Attributes attrs) {
tags.push(qName);
}
public void characters(char ch[], int start, int length)
throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("name")) {
System.out.println("|| Name: |" + new String(ch, start, length));
}
if (tag.equals("space")) {
System.out.println("||Space: |" + new String(ch, start, length));
}
System.out.println("-------------------------------------------------");
}
/**
* JDOM方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void JDOM() {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
org.jdom.Document doc = builder.build(new File("F:/xmltest.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for (int i = 0; i < allChildren.size(); i++) {
System.out.println("|| Name: |"
+ ((Element) allChildren.get(i)).getChild("name")
.getText());
System.out.println("||Space: |"
+ ((Element) allChildren.get(i)).getChild("space")
.getText());
System.out.println("-------------------------------------------------"); }
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("JDOM RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
/**
* DOM4J方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void DOM4J() {
long lasting = System.currentTimeMillis();
try {
File f = new File("F:/xmltest.xml");
SAXReader reader = new SAXReader();
org.dom4j.Document doc = reader.read(f);
org.dom4j.Element root = doc.getRootElement();
org.dom4j.Element foo;
for (Iterator i = root.elementIterator("node"); i.hasNext();) {
foo = (org.dom4j.Element) i.next();
System.out.println("|| Name: |" + foo.elementText("name"));
System.out.println("||Space: |" + foo.elementText("space"));
System.out.println("-------------------------------------------------");
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("DOM4J RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
public static void main(String arge[]) {
MyXMLReader myXML = new MyXMLReader();
System.out.println("=====================DOM=========================");
myXML.DOM();
System.out.println("=====================SAX=========================");
myXML.SAX();
System.out.println("=====================JDOM========================");
myXML.JDOM();
System.out.println("=====================DOM4J=======================");
myXML.DOM4J();
System.out.println("=================================================");
}
}

import java.io.File;
import java.util.Iterator;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.dom4j.io.SAXReader;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
/**
* DOM方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void DOM() {
long lasting = System.currentTimeMillis();
try {
File f = new File("F:/xmltest.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("node");
for (int i = 0; i < nl.getLength(); i++) {
System.out.println("|| Name:  |"
+ doc.getElementsByTagName("name").item(i)
.getFirstChild().getNodeValue());
System.out.println("||Space:  |"
+ doc.getElementsByTagName("space").item(i)
.getFirstChild().getNodeValue());
System.out.println("-------------------------------------------------");			}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("DOM RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
/**
* SAX方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void SAX() {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("F:/xmltest.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("SAX RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
public void startElement(String uri, String localName, String qName,
Attributes attrs) {
tags.push(qName);
}
public void characters(char ch[], int start, int length)
throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("name")) {
System.out.println("|| Name:  |" + new String(ch, start, length));
}
if (tag.equals("space")) {
System.out.println("||Space:  |" + new String(ch, start, length));
}
System.out.println("-------------------------------------------------");
}
/**
* JDOM方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void JDOM() {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
org.jdom.Document doc = builder.build(new File("F:/xmltest.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for (int i = 0; i < allChildren.size(); i++) {
System.out.println("|| Name:  |"
+ ((Element) allChildren.get(i)).getChild("name")
.getText());
System.out.println("||Space:  |"
+ ((Element) allChildren.get(i)).getChild("space")
.getText());
System.out.println("-------------------------------------------------");			}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("JDOM RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
/**
* DOM4J方式
* @since V2.0
* @author David.Wei
* @date 2008-4-11
* @return void
*/
public void DOM4J() {
long lasting = System.currentTimeMillis();
try {
File f = new File("F:/xmltest.xml");
SAXReader reader = new SAXReader();
org.dom4j.Document doc = reader.read(f);
org.dom4j.Element root = doc.getRootElement();
org.dom4j.Element foo;
for (Iterator i = root.elementIterator("node"); i.hasNext();) {
foo = (org.dom4j.Element) i.next();
System.out.println("|| Name:  |" + foo.elementText("name"));
System.out.println("||Space:  |" + foo.elementText("space"));
System.out.println("-------------------------------------------------");
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("DOM4J RUNTIME："
+ (System.currentTimeMillis() - lasting) + " MS");
}
public static void main(String arge[]) {
MyXMLReader myXML = new MyXMLReader();
System.out.println("=====================DOM=========================");
myXML.DOM();
System.out.println("=====================SAX=========================");
myXML.SAX();
System.out.println("=====================JDOM========================");
myXML.JDOM();
System.out.println("=====================DOM4J=======================");
myXML.DOM4J();
System.out.println("=================================================");
}
}

运行结果:

Html代码

=====================DOM=========================
|| Name: |weidewei
||Space: |http://wishlife.javaeye.com
-------------------------------------------------
|| Name: |flying
||Space: |http://user.qzone.qq.com/94611981
-------------------------------------------------
DOM RUNTIME：62 MS
=====================SAX=========================
|| Name: |weidewei
-------------------------------------------------
||Space: |http://wishlife.javaeye.com
-------------------------------------------------
|| Name: |flying
-------------------------------------------------
||Space: |http://user.qzone.qq.com/94611981
-------------------------------------------------
SAX RUNTIME：16 MS
=====================JDOM========================
|| Name: |weidewei
||Space: |http://wishlife.javaeye.com
-------------------------------------------------
|| Name: |flying
||Space: |http://user.qzone.qq.com/94611981
-------------------------------------------------
JDOM RUNTIME：78 MS
=====================DOM4J=======================
|| Name: |weidewei
||Space: |http://wishlife.javaeye.com
-------------------------------------------------
|| Name: |flying
||Space: |http://user.qzone.qq.com/94611981
-------------------------------------------------
DOM4J RUNTIME：78 MS
=================================================

lanxin1020 2009-05-08 10:52 发表评论

instanceof(转)

lanxin1020 — Thu, 07 May 2009 05:14:00 GMT

Java中的instanceof关键字收藏

instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

　　String s = "I AM an Object!";
　　boolean isObject = s instanceof Object;

　　我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
　　instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

　　public class Bill {//省略细节}
　　public class PhoneBill extends Bill {//省略细节}
　　public class GasBill extends Bill {//省略细节}

　　在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

　　public double calculate(Bill bill) {
　　if (bill instanceof PhoneBill) {
　　//计算电话账单
　　}
　　if (bill instanceof GasBill) {
　　//计算燃气账单
　　}
　　...
　　}
　　这样就可以用一个方法处理两种子类。

　　然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

　　public double calculate(PhoneBill bill) {
　　//计算电话账单
　　}

　　public double calculate(GasBill bill) {
　　//计算燃气账单
　　}

　　所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。

lanxin1020 2009-05-07 13:14 发表评论

java.io.File

lanxin1020 — Thu, 07 May 2009 03:16:00 GMT

package cn.edu.tongji.cims.wade.system;
import java.io.*;
public class FileOperate {
public FileOperate() {
}
/**
* 新建目录
* @param folderPath String 如 c:/fqf
* @return boolean
*/
public void newFolder(String folderPath) {
try {
String filePath = folderPath;
filePath = filePath.toString();
java.io.File myFilePath = new java.io.File(filePath);
if (!myFilePath.exists()) {
myFilePath.mkdir();
}
}
catch (Exception e) {
System.out.println("新建目录操作出错");
e.printStackTrace();
}
}
/**
* 新建文件
* @param filePathAndName String 文件路径及名称如c:/fqf.txt
* @param fileContent String 文件内容
* @return boolean
*/
public void newFile(String filePathAndName, String fileContent) {
try {
String filePath = filePathAndName;
filePath = filePath.toString();
File myFilePath = new File(filePath);
if (!myFilePath.exists()) {
myFilePath.createNewFile();
}
FileWriter resultFile = new FileWriter(myFilePath);
PrintWriter myFile = new PrintWriter(resultFile);
String strContent = fileContent;
myFile.println(strContent);
resultFile.close();
}
catch (Exception e) {
System.out.println("新建目录操作出错");
e.printStackTrace();
}
}
/**
* 删除文件
* @param filePathAndName String 文件路径及名称如c:/fqf.txt
* @param fileContent String
* @return boolean
*/
public void delFile(String filePathAndName) {
try {
String filePath = filePathAndName;
filePath = filePath.toString();
java.io.File myDelFile = new java.io.File(filePath);
myDelFile.delete();
}
catch (Exception e) {
System.out.println("删除文件操作出错");
e.printStackTrace();
}
}
/**
* 删除文件夹
* @param filePathAndName String 文件夹路径及名称如c:/fqf
* @param fileContent String
* @return boolean
*/
public void delFolder(String folderPath) {
try {
delAllFile(folderPath); //删除完里面所有内容
String filePath = folderPath;
filePath = filePath.toString();
java.io.File myFilePath = new java.io.File(filePath);
myFilePath.delete(); //删除空文件夹
}
catch (Exception e) {
System.out.println("删除文件夹操作出错");
e.printStackTrace();
}
}
/**
* 删除文件夹里面的所有文件
* @param path String 文件夹路径如 c:/fqf
*/
public void delAllFile(String path) {
File file = new File(path);
if (!file.exists()) {
return;
}
if (!file.isDirectory()) {
return;
}
String[] tempList = file.list();
File temp = null;
for (int i = 0; i < tempList.length; i++) {
if (path.endsWith(File.separator)) {
temp = new File(path + tempList[i]);
}
else {
temp = new File(path + File.separator + tempList[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
delFolder(path+"/"+ tempList[i]);//再删除空文件夹
}
}
}
/**
* 复制单个文件
* @param oldPath String 原文件路径如：c:/fqf.txt
* @param newPath String 复制后路径如：f:/fqf.txt
* @return boolean
*/
public void copyFile(String oldPath, String newPath) {
try {
int bytesum = 0;
int byteread = 0;
File oldfile = new File(oldPath);
if (oldfile.exists()) { //文件存在时
InputStream inStream = new FileInputStream(oldPath); //读入原文件
FileOutputStream fs = new FileOutputStream(newPath);
byte[] buffer = new byte[1444];
int length;
while ( (byteread = inStream.read(buffer)) != -1) {
bytesum += byteread; //字节数文件大小
System.out.println(bytesum);
fs.write(buffer, 0, byteread);
}
inStream.close();
}
}
catch (Exception e) {
System.out.println("复制单个文件操作出错");
e.printStackTrace();
}
}
/**
* 复制整个文件夹内容
* @param oldPath String 原文件路径如：c:/fqf
* @param newPath String 复制后路径如：f:/fqf/ff
* @return boolean
*/
public void copyFolder(String oldPath, String newPath) {
try {
(new File(newPath)).mkdirs(); //如果文件夹不存在则建立新文件夹
File a=new File(oldPath);
String[] file=a.list();
File temp=null;
for (int i = 0; i < file.length; i++) {
if(oldPath.endsWith(File.separator)){
temp=new File(oldPath+file[i]);
}
else{
temp=new File(oldPath+File.separator+file[i]);
}
if(temp.isFile()){
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath + "/" +
(temp.getName()).toString());
byte[] b = new byte[1024 * 5];
int len;
while ( (len = input.read(b)) != -1) {
output.write(b, 0, len);
}
output.flush();
output.close();
input.close();
}
if(temp.isDirectory()){//如果是子文件夹
copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
}
}
}
catch (Exception e) {
System.out.println("复制整个文件夹内容操作出错");
e.printStackTrace();
}
}
/**
* 移动文件到指定目录
* @param oldPath String 如：c:/fqf.txt
* @param newPath String 如：d:/fqf.txt
*/
public void moveFile(String oldPath, String newPath) {
copyFile(oldPath, newPath);
delFile(oldPath);
}
/**
* 移动文件到指定目录
* @param oldPath String 如：c:/fqf.txt
* @param newPath String 如：d:/fqf.txt
*/
public void moveFolder(String oldPath, String newPath) {
copyFolder(oldPath, newPath);
delFolder(oldPath);
}
}

lanxin1020 2009-05-07 11:16 发表评论

Java Native Access （转）

lanxin1020 — Thu, 07 May 2009 03:08:00 GMT

        如果在Java程序中你使用Java Native Interface(JNI) 来调用某个特定平台下的本地库文件，你就会发现这个过程很单调、乏味。Jeff Friesen一直在介绍一个知名度很低的Java开源项目：Java Native Access---它能够避免因使用JNI导致的错误和乏味，同时它还能让你通过编程的方式调用C语言库。

        在Java语言没有提供必要的APIs的情况下，Java程序使用Java Native Interface (JNI)来调用特定平台下的本地库是必要的。例如：在Windows XP平台中，我使用过JNI来调用通用串行总线和基于TWAIN的扫描仪器的库；在更古老的Windows NT平台中，调用过智能卡的库。

        我按照一个基本的、乏味的流程来解决这些问题：首先，我创建一个Java类用来载入JNI-friendly库（这个库能过访问其他的库）并且声明这个类的本地方法。然后，在使用JDK中的javah工具为JNI-friendly库中的函数---函数和这个类中的本地方法一一对应---创建一个代理。最后，我使用C语言写了一个库并用C编译器编译了这些代码。

        尽管完成这些流程并不是很困难，但是写C代码是一个很缓慢的过程---例如： C语言中的字符串处理是通过指针来实现的，这会很复杂的。而且，使用JNI很容易出现错误，导致内存泄漏、很难找到程序崩溃的原因。

        在Java开源系列的第二篇文章中，我要介绍一个更简单、更安全的解决方法：Todd Fast and Timothy Wall的Java Native Access (JNA) 项目。JNA能够让你在Java程序中调用本地方法时避免使用C和Java Native Interface。在这篇文章中，让我以简要的介绍        JNA和运行示例必需的软件来开始下面的内容。然后，向你展示如何使用JNA将3个Windows本地库中的有用代码移植到Java程序中。

Get started with JNA（JNA入门）

Java Native Access 项目在Java.net上，你可以到这个网站上现在这个项目的代码和在线帮助文档。虽然在下载有5个相关的jar文件，在本文中你仅仅需要下载其中的jna.jar和example.jar。

Jna.jar提供基本的、运行这些示例文件必需的jna运行环境。这个jna.jar文件除了有Unix、Linux、Windows和Mac OS X平台相关的JNT-friendly本地库外，还包含其他几个类包。每一个本地库都是用来访问相对应平台下的本地方法的。

        example.jar包含了不同的示例来表明JNA的用途。其中的一个例子是使用JNA来实现一个在不同平台下的透明视窗技术的API。在文章最后的示例中将要展示如何使用这个API修复上个月的文章关于VerifyAge2应用中辨认透明效果的问题。

获取本地时间（Get local time）

如果你在Java Native Access 首页看过“JNA如何入门”，你就会知道一个很简单的关于调用Windows 平台下的API函数：GetSystemTime（）的JNA示例。这个不完整的例子只是展示了JNA的基本特点。（在例子的基础上，我做了一个更完整的基于Windows的例子来介绍JNA）我在Windows平台下完善了这个例子来介绍JNA。

第一例子基于Windows GetLocalTime() API函数返回本地当前的时间和日期。和GetSystemTime()不同的是，返回的时间/日期是协调通用时间(UTC)格式的，GetLocalTime()返回的时间/日期信息的格式是根据当前时区来表示。

在一个Java程序中使用JNA调用GetLocalTime，你需要知道这个函数所在的Windows平台下的动态链接库（DLL）的名称（和可能所在的地理区域）。我们发现GetLocalTime()和GetSystemTime在同一个DLL文件中：kernel32.dll。你还需要知道GetLocalTime()在C语言环境中的申明。申明如下Listing 1：

Listing 1. GetLocalTime在C语言中的申明

typedef struct

{

   WORD wYear;

   WORD wMonth;

   WORD wDayOfWeek;

   WORD wDay;

   WORD wHour;

   WORD wMinute;

   WORD wSecond;

   WORD wMilliseconds;

}

SYSTEMTIME, *LPSYSTEMTIME;



VOID GetLocalTime(LPSYSTEMTIME lpst);

这个基于C语言的申明表明传到这个函数的参数数目和类型。在这个例子中，只有一个参数---一个指向Windows SYSTEMTIME结构体的指针。而且，每个结构体成员的类型是16bit长度的无符号整型。根据这些信息，你能够创建一个完全描述GetLocalTime()函数的接口，如Listing 2中所示：

Listing 2. Kernel32.java

// Kernel32.java



import com.sun.jna.*;

import com.sun.jna.win32.*;



public interface Kernel32 extends StdCallLibrary

{

   public static class SYSTEMTIME extends Structure

   {

      public short wYear;

      public short wMonth;

      public short wDayOfWeek;

      public short wDay;

      public short wHour;

      public short wMinute;

      public short wSecond;

      public short wMilliseconds;

   }



   void GetLocalTime (SYSTEMTIME result);

}

Kernel32 接口（The Kernel32 interface）

因为JNA使用通过一个接口来访问某个库中的函数，Listing 2表示了一个描述GetLocalTime()的接口。根据约定，我把接口命名为Kernel32是因为GetLocalTime()在Windows的kernel32.dll库。

这个接口必须继承com.sun..jna.Library接口。因为Windows API函数遵循stdcall调用协议（stdcall calling convention），为Windows API申明的接口也必须继承com.sun.jna.win32. StdCallLibrary接口。因此这个接口共继承了Library 和 com.sun.jna.win32.StdCall两个接口。

在前面，你已经知道了GetLocalTime() 需要一个指向SYSTEMTIME结构体的指针作为它唯一的参数。因为Java不支持指针，JNA是通过申明一个com.sun.jna.Structure的子类来代替的。根据java文档中抽象类的概念，在参数环境中，Structure相当于C语言的struct*。

在SYSTEMTIME类中的字段和C结构体中的相对应的属性字段的顺序是一一对应的。保证字段顺序的一致性是非常重要的。例如，我发现交换wYear和wMonth会导致wYear和wMonth值互换。

每个字段在java中是short integer类型的。按照JNA首页上 “默认类型映射”章节给出的提示，这个short integer分配类型是正确。然而，我们应该知道一个重要的区别：Windows平台下的WORD类型等同于C语言环境中的16-bit的无符号的short integer，而java中short integer是16-bit有符号的short integer。

一个类型映射的问题

通过比较一个API 函数返回的整型值，你会发现Windows/C 语言的无符号整型和Java语言的有符号整型的JNA类型映射是有问题的。在比较的过程中，如果你不细心，那么错误的执行过程可能导致决定性情况。导致这种后果是因为忘记任何数值的符号位的确定是根据：在无符号整型的情况下会被解释为正号，而在有符号整型的进制中被理解为负号的。

通过Kernel32获取本地时间（Access the local time with Kernel32）

JNA首页上的GetSystemTime()示例已经表明必须使用预先申明的接口为本地库分配一个实例对象。你可以通过com.sun.jna.Native类中静态公用方法loadLibrary(String name, Class interfaceClass)来完成上述的目标。Listing 3 所示：

Listing 3. LocalTime.java

// LocalTime.java



import com.sun.jna.*;



public class LocalTime

{

   public static void main (String [] args)

   {

      Kernel32 lib = (Kernel32) Native.loadLibrary ("kernel32",

                                                    Kernel32.class);

      Kernel32.SYSTEMTIME time = new Kernel32.SYSTEMTIME ();

      lib.GetLocalTime (time);

      System.out.println ("Year is "+time.wYear);

      System.out.println ("Month is "+time.wMonth);

      System.out.println ("Day of Week is "+time.wDayOfWeek);

      System.out.println ("Day is "+time.wDay);

      System.out.println ("Hour is "+time.wHour);

      System.out.println ("Minute is "+time.wMinute);

      System.out.println ("Second is "+time.wSecond);

      System.out.println ("Milliseconds are "+time.wMilliseconds);

   }

}

Listing 3 执行Kernel32 lib = (Kernel32) Native.loadLibrary ("kernel32", Kernel32.class);来分配一个Kernel32实例对象并且装载kernel32.dll。因为kernel32.dll是Windows平台下标准的dll文件，所以不要指定访问这个库的路径。然而，如果找不到这个dll文件，loadLibrary()会抛出一个UnsatisfiedLinkError异常。

Kernel32.SYSTEMTIME time = new Kernel32.SYSTEMTIME ();创建了一个SYSTEMTIME结构体的示例。初始化后下面是lib.GetLocalTime (time);，这句话使用本地的时间/日期来给这个实例赋值。几个System.out.println()语句是输出这些值。

编译和运行这个应用（Compile and run the application）

这部分很容易。假设jna.jar、Kernel32.java和LocalTime.java是放在当前文件夹中，调用java –cp jna.jar;. LocalTime.java来编译这个应用的源代码。如果在Windows平台下，调用invoke java –cp jna.jar;. LocalTime 来运行这个应用。你可以得到类似与Listing 4的输出结果：

Listing 4. 从LocalTime.java生成的输出

Year is 2007

Month is 12

Day of Week is 3

Day is 19

Hour is 12

Minute is 35

Second is 13

Milliseconds are 156

获取操纵杆信息（Accessing joystick device info）

上面的例子已经介绍了JNA，但是这个获取本地时间和日期的例子并没有很好的利用这个技术，甚至也没有体现JNI的价值。Java语言中的System.currentTimeMillis()函数已经以毫秒的格式返回了这些信息。因为Java语言没有为游戏控制器提供API，所以获取操纵杆的信息更适合JNA的使用。

例如，你要构建一个平台无关的Java库，而且这些库使用JNA调用Linux, Mac OS X, Windwos和Unix平台中本地的操纵杆API。为了简洁和方便起见，这个例子仅仅是调用Windows平台下的操纵杆API。而且我将重点介绍这个API很小的一部分。

类似GetLocalTime()，第一步是辨别出操作杆API的DLL，这个DLL是winmm.dll，和kernel32.dll在同一个文件夹中，它包含了操作杆的API和其他的多媒体APIs。还需知道要被使用的操作杆函数基于C语言的声明。这些函数声明已经在Listing 5中列出来了。

Listing 5. C-based declarations for some Joystick API functions

#define MAXPNAMELEN 32



typedef struct

{

   WORD  wMid;                  // manufacturer identifier

   WORD  wPid;                  // product identifier

   TCHAR szPname  MAXPNAMELEN ; // product name

   UINT  wXmin;                 // minimum x position

   UINT  wXmax;                 // maximum x position

   UINT  wYmin;                 // minimum y position

   UINT  wYmax;                 // maximum y position

   UINT  wZmin;                 // minimum z position

   UINT  wZmax;                 // maximum z position

   UINT  wNumButtons;           // number of buttons

   UINT  wPeriodMin;            // smallest supported polling interval when captured

   UINT  wPeriodMax;            // largest supported polling interval when captured

}

JOYCAPS, *LPJOYCAPS;



MMRESULT joyGetDevCaps(UINT IDDevice, LPJOYCAPS lpjc, UINT cbjc);



UINT joyGetNumDevs(VOID);

操作杆API的函数（Functions of the Joystick API）

在Windows平台下是通过以joy作为函数名开始的函数以及被各种函数调用的结构体来实现操作杆API的。例如，joyGetNumDevs()返回的是这个平台下支持的操作杆设备最多的数目；joyGetDevCaps()返回的是每个连接上的操纵杆的质量。

joyGetDevCaps()函数需要3个参数：
* 处在0到joyGetNumDevs()-1之间的操作杆ID
* 保存返回的质量信息的JOYCAPS结构体的地址
* JOYCAPS结构体的字节大小
虽然它的结果不同，这个函数返回的是一个32位的无符号整型结果，而且0表示一个已经连接的操纵杆。

JOYCAPS结构体有3种类型。Windows平台下的WORD（16位无符号短整型）类型对应的是Java语言中16位有符号短整型。除此之外，Windows下的UINT（32位无符号整型）类型是和Java语言中32位有符号整型相对应的。而Windows平台上的text character就是TCHAR类型。

微软通过TCHAR类型使开发人员能够从ASCII类型的函数参数平滑的转移到Unicode字符类型的函数参数上。而且，拥有text类型参数的函数的实现是通过宏转变为对应的ASCII或者wide-character的函数。例如，joyGetDevCaps()是一个对应joyGetDevCapsA() 和 joyGetDevCapsW()的宏。

使用TCHAR（Working with TCHAR）

使用TCHAR和将TCHAR转变的宏会导致基于C语言的申明向基于JNA接口的转换
变得有点复杂—你在使用ASCII或者wide-character版本的操纵杆函数吗？两种版本都在如下的接口中展示了：

Listing 6. WinMM.java

// WinMM.java



import com.sun.jna.*;

import com.sun.jna.win32.*;



public interface WinMM extends StdCallLibrary

{

   final static int JOYCAPSA_SIZE = 72;



   public static class JOYCAPSA extends Structure

   {

      public short wMid;

      public short wPid;

      public byte szPname [] = new byte [32];

      public int wXmin;

      public int wXmax;

      public int wYmin;

      public int wYmax;

      public int wZmin;

      public int wZmax;

      public int wNumButtons;

      public int wPeriodMin;

      public int wPeriodMax;

   }



   int joyGetDevCapsA (int id, JOYCAPSA caps, int size);



   final static int JOYCAPSW_SIZE = 104;



   public static class JOYCAPSW extends Structure

   {

      public short wMid;

      public short wPid;

      public char szPname [] = new char [32];

      public int wXmin;

      public int wXmax;

      public int wYmin;

      public int wYmax;

      public int wZmin;

      public int wZmax;

      public int wNumButtons;

      public int wPeriodMin;

      public int wPeriodMax;

   }



   int joyGetDevCapsW (int id, JOYCAPSW caps, int size);



   int joyGetNumDevs ();

}

Listing 6没有介绍JNA的新特性。实际上，JNA强调了对本地库的接口命名规则。同时，还展示了如何将TCHAR映射到Java语言中的byte和char数组。最后，它揭示了以常量方式声明的结构体的大小。Listing 7展示了当调用joyGetDevCapsA() 和 joyGetDevCapsW()时如何使用这些常量。

Listing 7. JoystickInfo.java

// JoystickInfo.java



import com.sun.jna.*;



public class JoystickInfo

{

   public static void main (String [] args)

   {

      WinMM lib = (WinMM) Native.loadLibrary ("winmm", WinMM.class);

      int numDev = lib.joyGetNumDevs ();



      System.out.println ("joyGetDevCapsA() Demo");

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



      WinMM.JOYCAPSA caps1 = new WinMM.JOYCAPSA ();

      for (int i = 0; i < numDev; i++)

           if (lib.joyGetDevCapsA (i, caps1, WinMM.JOYCAPSA_SIZE) == 0)

           {

               String pname = new String (caps1.szPname);

               pname = pname.substring (0, pname.indexOf ('\0'));

               System.out.println ("Device #"+i);

               System.out.println ("  wMid = "+caps1.wMid);

               System.out.println ("  wPid = "+caps1.wPid);

               System.out.println ("  szPname = "+pname);

               System.out.println ("  wXmin = "+caps1.wXmin);

               System.out.println ("  wXmax = "+caps1.wXmax);

               System.out.println ("  wYmin = "+caps1.wYmin);

               System.out.println ("  wYmax = "+caps1.wYmax);

               System.out.println ("  wZmin = "+caps1.wZmin);

               System.out.println ("  wZmax = "+caps1.wZmax);

               System.out.println ("  wNumButtons = "+caps1.wNumButtons);

               System.out.println ("  wPeriodMin = "+caps1.wPeriodMin);

               System.out.println ("  wPeriodMax = "+caps1.wPeriodMax);

               System.out.println ();

           }



      System.out.println ("joyGetDevCapsW() Demo");

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



      WinMM.JOYCAPSW caps2 = new WinMM.JOYCAPSW ();

      for (int i = 0; i < numDev; i++)

           if (lib.joyGetDevCapsW (i, caps2, WinMM.JOYCAPSW_SIZE) == 0)

           {

               String pname = new String (caps2.szPname);

               pname = pname.substring (0, pname.indexOf ('\0'));

               System.out.println ("Device #"+i);

               System.out.println ("  wMid = "+caps2.wMid);

               System.out.println ("  wPid = "+caps2.wPid);

               System.out.println ("  szPname = "+pname);

               System.out.println ("  wXmin = "+caps2.wXmin);

               System.out.println ("  wXmax = "+caps2.wXmax);

               System.out.println ("  wYmin = "+caps2.wYmin);

               System.out.println ("  wYmax = "+caps2.wYmax);

               System.out.println ("  wZmin = "+caps2.wZmin);

               System.out.println ("  wZmax = "+caps2.wZmax);

               System.out.println ("  wNumButtons = "+caps2.wNumButtons);

               System.out.println ("  wPeriodMin = "+caps2.wPeriodMin);

               System.out.println ("  wPeriodMax = "+caps2.wPeriodMax);

               System.out.println ();

           }

   }

}

尽管和LocalTime这个示例类似，JoystickInfo执行WinMM lib = (WinMM) Native.loadLibrary ("winmm", WinMM.class);这句话来获取一个WinMM的实例，并且载入winmm.dll。它还执行WinMM.JOYCAPSA caps1 = new WinMM.JOYCAPSA (); 和 WinMM.JOYCAPSW caps2 = new WinMM.JOYCAPSW ();初始化必需的结构体实例。

编译和运行这个程序（Compile and run the application）

假如jna.jar，WinMM.java和JoystickInfo.java在同一个文件夹中，调用 javac -cp jna.jar;. JoystickInfo.java 来编译这个应用的源代码。
在windows平台下，调用java -cp jna.jar;. JoystickInfo就可以运行这个应用程序了。如果没有操纵杆设备，你应该得到Listing 8中的输出。

将C语言中的string类型转换为Java语言的String类型

pname = pname.substring (0, pname.indexOf ('\0')); 这段代码将一个C string 转换成了Java string. 如果不使用这个转换，C语言的string结束符’\0’和string后面的无用字符都会成为Java语言中String实例对象的内容。

Listing 8. 输出操纵杆信息（Output of JoystickInfo）

joyGetDevCapsA() Demo

---------------------



joyGetDevCapsW() Demo

---------------------

上面的输出是因为每次调用joyGetDevCap()返回的是一个非空值，这表示没有操纵杆/游戏控制器设备或者是出现错误。为了获取更多有意思的输出，将一个设备连接到你的平台上并且再次运行JoystickInfo。如下，将一个微软SideWinder即插即用游戏触摸板设备联上之后我获取了如下的输出：

Listing 9. 操纵杆连接上之后的运行结果（Output after running JoystickInfo with a joystick attached）

joyGetDevCapsA() Demo

---------------------



Device #0

  wMid = 1118

  wPid = 39

  szPname = Microsoft PC-joystick driver

  wXmin = 0

  wXmax = 65535

  wYmin = 0

  wYmax = 65535

  wZmin = 0

  wZmax = 65535

  wNumButtons = 6

  wPeriodMin = 10

  wPeriodMax = 1000



joyGetDevCapsW() Demo

---------------------



Device #0

  wMid = 1118

  wPid = 39

  szPname = Microsoft PC-joystick driver

  wXmin = 0

  wXmax = 65535

  wYmin = 0

  wYmax = 65535

  wZmin = 0

  wZmax = 65535

  wNumButtons = 6

  wPeriodMin = 10

  wPeriodMax = 1000

窗口透明度（Transparent windows）

在这系列文章中上篇文章是关于Bernhard Pauler's 气泡提示（balloontip）工程的。我构建了一个叫做VerifyAge的、包含有一个气泡提示的GUI应用。Figure 1中显示了这个GUI应用的一个小问题：这个气泡提示的没有经过修饰的对话框部分遮住了应用窗口的一部分边框,导致了无法点击这个边框的最小化和最大化按钮，并且使整个GUI很难看.

尽管未修饰部分的对话框不能显示气泡提示的透明度，java语言不支持窗口透明度。幸运的是，我们可以通过使用com.sun.jna.examples.WindowUtils类调用JNA的examples.jar文件来解决这个问题。
WindowUtils提供在Unix，Linux，Mac OS X和Windows平台上使用JNA’s来实现窗口透明的工具方法。例如， public static void setWindowMask(final Window w, Icon mask) 让你根据像素而不是通过预定的掩罩（mask）参数来选取某部分的窗口。这个功能将在Listing 10中展示：

Listing 10. Using JNA to render a window transparent



// Create a mask for this dialog. This mask has the same shape as the

// dialog's rounded balloon tip and ensures that only the balloon tip

// part of the dialog will be visible. All other dialog pixels will

// disappear because they correspond to transparent mask pixels.



// Note: The drawing code is based on the drawing code in

// RoundedBalloonBorder.



Rectangle bounds = getBounds ();

BufferedImage bi = new BufferedImage (bounds.width, bounds.height,

                                      BufferedImage.TYPE_INT_ARGB);

Graphics g = bi.createGraphics ();

g.fillRoundRect (0, 0, bounds.width, bounds.height-VERT_OFFSET,

                 ARC_WIDTH*2, ARC_HEIGHT*2);

g.drawRoundRect (0, 0, bounds.width-1, bounds.height-VERT_OFFSET-1,

                 ARC_WIDTH*2, ARC_HEIGHT*2);

int [] xPoints = { HORZ_OFFSET, HORZ_OFFSET+VERT_OFFSET, HORZ_OFFSET };

int [] yPoints = { bounds.height-VERT_OFFSET-1, bounds.height-VERT_OFFSET

                   -1, bounds.height-1 };

g.fillPolygon (xPoints, yPoints, 3);

g.drawLine (xPoints [0], yPoints [0], xPoints [2], yPoints [2]);

g.drawLine (xPoints [1], yPoints [1], xPoints [2], yPoints [2]);

g.dispose ();

WindowUtils.setWindowMask (this, new ImageIcon (bi));

在Listing 10中的代码段是从本文代码文档（code archive）里的加强版的VerifyAge2 应用中的TipFrame的构造函数结尾部分摘录的。这个构造函数定义了围绕提示气泡的掩罩（mask）的形状，在这个形状范围里描绘不透明的像素。
假如你当前文件夹中有examples.jar, jna.jar, 和 VerifyAge2.java,调用 javac -cp examples.jar;balloontip.jar VerifyAge2.java 来编译源文件.然后调用java -Dsun.java2d.noddraw=true -cp examples.jar;balloontip.jar;. VerifyAge2运行这个应用. Figure 2 展示了透明示例.

总结（In conclusion）

JNA项目有很长的历史了（追溯到1999年），但是它第一次发布是在2006年11月。从此以后它慢慢的被需要将本地C代码整合到Java工程中的开发者注意到了。因为JNA能够用来解决JuRuby中常见一个问题：缺乏对POSIX调用的支持（lack of support for POSIX calls），它也在JRuby程序员中掀起些波浪。JNA也同样被作为实现用低级C代码继承Ruby的一种解决方案（extending Ruby with low-level C code）。
我喜欢使用JNA来工作，相信你也会发现它比使用JNI来访问本地代码更简单、更安全。无需多言，JNA还有更多的特性在本文中没有体现出来。查阅它的资源部分：获取这个开源java项目更多的信息（learn more about this open source Java project）。用它做demo，而且在论坛（discussion forum ）上共享你的经验。下一个月我会带着另一个开源项目回来的，这个开源项目会给你每天的java开发带来益处。

附录：WindowUtils.setWindowMask()的替代品

在刚刚写完这篇文章后，我发现java语言支持在6u10版本中支持窗口的透明和形状定制。读完Kirill Grouchnikov的博客后，我用WindowUtils.setWindowMask()的替代品修改了VerifyAge2，如下：

// Create and install a balloon tip shape to ensure that only this part

// of the dialog will be visible.



Rectangle bounds = getBounds ();

GeneralPath gp;

gp = new GeneralPath (new RoundRectangle2D.Double (bounds.x, bounds.y,

                                                   bounds.width,

                                                   bounds.height-

                                                   VERT_OFFSET,

                                                   ARC_WIDTH*2-1,

                                                   ARC_HEIGHT*2-1));

gp.moveTo (HORZ_OFFSET, bounds.height-VERT_OFFSET);

gp.lineTo (HORZ_OFFSET, bounds.height);

gp.lineTo (HORZ_OFFSET+VERT_OFFSET+1, bounds.height-VERT_OFFSET);

AWTUtilities.setWindowShape (this, gp);

这段代码使用新类AWTUtilities（在com.sun.awt包中），而且public void setWindowShape(Window w, Shape s)函数将TipFrame和JDialog窗口设置气泡形状。

lanxin1020 2009-05-07 11:08 发表评论

jnidemo(转)

lanxin1020 — Thu, 07 May 2009 03:04:00 GMT

Java代码

简单介绍及应用如下：
　　一、JAVA中所需要做的工作
　　在JAVA程序中，首先需要在类中声明所调用的库名称，如下：
static {
System.loadLibrary(“goodluck”);
}
　　在这里，库的扩展名字可以不用写出来，究竟是DLL还是SO，由系统自己判断。
　　还需对将要调用的方法做本地声明，关键字为native。且只需要声明，而不需要具体实现。如下：
public native static void set(int i);
public native static int get();
　　然后编译该JAVA程序文件，生成CLASS，再用JAVAH命令，JNI就会生成C/C++的头文件。
　　例如程序testdll.java，内容为：
public class testdll
{
static
{
System.loadLibrary("goodluck");
}
public native static int get();
public native static void set(int i);
public static void main(String[] args)
{
testdll test = new testdll();
test.set(10);
System.out.println(test.get());
}
}
　　用javac testdll.java编译它，会生成testdll.class。
　　再用javah testdll，则会在当前目录下生成testdll.h文件，这个文件需要被C/C++程序调用来生成所需的库文件。
　　二、C/C++中所需要做的工作
　　对于已生成的.h头文件，C/C++所需要做的，就是把它的各个方法具体的实现。然后编译连接成库文件即可。再把库文件拷贝到JAVA程序的路径下面，就可以用JAVA调用C/C++所实现的功能了。
　　接上例子。我们先看一下testdll.h文件的内容：
/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class testdll */
#ifndef _Included_testdll
#define _Included_testdll
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: testdll
* Method: get
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass);
/*
* Class: testdll
* Method: set
* Signature: (I)V
*/
JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint);
#ifdef __cplusplus
}
#endif
#endif
　　在具体实现的时候，我们只关心两个函数原型
　　JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass); 和
　　JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint);
　　这里JNIEXPORT和JNICALL都是JNI的关键字，表示此函数是要被JNI调用的。而jint是以JNI为中介使JAVA的int类型与本地的int沟通的一种类型，我们可以视而不见，就当做int使用。函数的名称是JAVA_再加上java程序的package路径再加函数名组成的。参数中，我们也只需要关心在JAVA程序中存在的参数，至于JNIEnv*和jclass我们一般没有必要去碰它。
　　好，下面我们用testdll.cpp文件具体实现这两个函数：
#include "testdll.h"
int i = 0;
JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass)
{
return i;
}
JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint j)
{
i = j;
}
　　编译连接成库文件，本例是在WINDOWS下做的，生成的是DLL文件。并且名称要与JAVA中需要调用的一致，这里就是goodluck.dll 。把goodluck.dll拷贝到testdll.class的目录下，java testdll运行它，就可以观察到结果了。
　　我的项目比较复杂，需要调用动态链接库，这样在JNI传送参数到C程序时，需要对参数进行处理转换。才可以被C程序识别。
　　大体程序如下：
public class SendSMS {
static
{
System.out.println(System.getProperty("java.library.path"));
System.loadLibrary("sms");
}
public native static int SmsInit();
public native static int SmsSend(byte[] mobileNo, byte[] smContent);
}
　　在这里要注意的是，path里一定要包含类库的路径，否则在程序运行时会抛出异常：
　　java.lang.UnsatisfiedLinkError: no sms in java.library.path
　　at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1491)
　　at java.lang.Runtime.loadLibrary0(Runtime.java:788)
　　at java.lang.System.loadLibrary(System.java:834)
　　at com.mobilesoft.sms.mobilesoftinfo.SendSMS.(SendSMS.java:14)
　　at com.mobilesoft.sms.mobilesoftinfo.test.main(test.java:18)
　　Exception in thread "main"
　　指引的路径应该到.dll文件的上一级，如果指到.dll，则会报：
　　java.lang.UnsatisfiedLinkError: C:\sms.dll: Can't find dependent libraries
　　at java.lang.ClassLoader$NativeLibrary.load(Native Method)
　　at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1560)
　　at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1485)
　　at java.lang.Runtime.loadLibrary0(Runtime.java:788)
　　at java.lang.System.loadLibrary(System.java:834)
　　at com.mobilesoft.sms.mobilesoftinfo.test.main(test.java:18)
　　Exception in thread "main"
　　通过编译，生成com_mobilesoft_sms_mobilesoftinfo_SendSMS.h头文件。（建议使用Jbuilder进行编译，操作比较简单！）这个头文件就是Java和C之间的纽带。要特别注意的是方法中传递的参数jbyteArray，这在接下来的过程中会重点介绍。
/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/* Header for class com_mobilesoft_sms_mobilesoftinfo_SendSMS */
#ifndef _Included_com_mobilesoft_sms_mobilesoftinfo_SendSMS
#define _Included_com_mobilesoft_sms_mobilesoftinfo_SendSMS
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class: com_mobilesoft_sms_mobilesoftinfo_SendSMS
* Method: SmsInit
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_mobilesoft_sms_mobilesoftinfo_SendSMS_SmsInit
(JNIEnv *, jclass);
/*
* Class: com_mobilesoft_sms_mobilesoftinfo_SendSMS
* Method: SmsSend
* Signature: ([B[B)I
*/
JNIEXPORT jint JNICALL Java_com_mobilesoft_sms_mobilesoftinfo_SendSMS_SmsSend
(JNIEnv *, jclass, jbyteArray, jbyteArray);
#ifdef __cplusplus
}
#endif
#endif
　　对于我要调用的C程序的动态链接库，C程序也要提供一个头文件，sms.h。这个文件将要调用的方法罗列了出来。
/*
* SMS API
* Author: yippit
* Date: 2004.6.8
*/
#ifndef MCS_SMS_H
#define MCS_SMS_H
#define DLLEXPORT __declspec(dllexport)
/*sms storage*/
#define SMS_SIM 0
#define SMS_MT 1
/*sms states*/
#define SMS_UNREAD 0
#define SMS_READ 1
/*sms type*/
#define SMS_NOPARSE -1
#define SMS_NORMAL 0
#define SMS_FLASH 1
#define SMS_MMSNOTI 2
typedef struct tagSmsEntry {
int index; /*index, start from 1*/
int status; /*read, unread*/
int type; /*-1-can't parser 0-normal, 1-flash, 2-mms*/
int storage; /*SMS_SIM, SMS_MT*/
char date[24];
char number[32];
char text[144];
} SmsEntry;
DLLEXPORT int SmsInit(void);
DLLEXPORT int SmsSend(char *phonenum, char *content);
DLLEXPORT int SmsSetSCA(char *sca);
DLLEXPORT int SmsGetSCA(char *sca);
DLLEXPORT int SmsSetInd(int ind);
DLLEXPORT int SmsGetInd(void);
DLLEXPORT int SmsGetInfo(int storage, int *max, int *used);
DLLEXPORT int SmsSaveFlash(int flag);
DLLEXPORT int SmsRead(SmsEntry *entry, int storage, int index);
DLLEXPORT int SmsDelete(int storage, int index);
DLLEXPORT int SmsModifyStatus(int storage, int index); /*unread -> read*/
#endif
　　在有了这两个头文件之后，就可以进行C程序的编写了。也就是实现对JNI调用的两个方法。在网上的资料中，由于调用的方法实现的都比较简单，（大多是打印字符串等）所以避开了JNI中最麻烦的部分，也是最关键的部分，参数的传递。
由于Java和C的编码是不同的，所以传递的参数是要进行再处理，否则C程序是会对参数在编译过程中提出警告，例如；warning C4024: 'SmsSend' : different types for formal and actual parameter 2等。
　　Sms.c的程序如下：
#include "sms.h"
#include "com_mobilesoft_sms_mobilesoftinfo_SendSMS.h"
JNIEXPORT jint JNICALL Java_com_mobilesoft_sms_mobilesoftinfo_SendSMS_SmsInit(JNIEnv * env, jclass jobject)
{
return SmsInit();
}
JNIEXPORT jint JNICALL Java_com_mobilesoft_sms_mobilesoftinfo_SendSMS_SmsSend(JNIEnv * env, jclass jobject, jbyteArray mobileno, jbyteArray smscontent)
{
char * pSmscontent ;
//jsize theArrayLengthJ = (*env)->GetArrayLength(env,mobileno);
jbyte * arrayBody = (*env)->GetByteArrayElements(env,mobileno,0);
char * pMobileNo = (char *)arrayBody;
printf("[%s]\n ", pMobileNo);
//jsize size = (*env)->GetArrayLength(env,smscontent);
arrayBody = (*env)->GetByteArrayElements(env,smscontent,0);
pSmscontent = (char *)arrayBody;
printf("<%s>\n", pSmscontent);
return SmsSend(pMobileNo,pSmscontent);
}
　　对于C或C++，在程序上是会有稍微的不同，这可以由读者对其进行适当的修改。这里要注意的是GetArrayLength，GetByteArrayElements等这些JNI中已经包含的方法，这些方法是专门对转换参数类型而提供的。具体的方法有很多，在下一篇中会做专门的介绍。
　　在完成了上述的文件后，可以对sms.c进行编译，生成.dll文件（建议在release中编译，这样动态链接库的容积会比较小！）
　　完成.dll文件的编译后，就可以在Java中调用C程序中的方法了。例如文件test.java
public class test {
public test() {
}
public static void main(String[] args) {
byte[] mobileno = {
0x31, 0x33, 0x36, 0x36, 0x31, 0x36, 0x33, 0x30, 0x36, 0x36, 0x37, 0x00};
String smscontentemp = "早上好";
byte[] temp = {0};
try {
byte[] smscontentdb = smscontentemp.getBytes("gbk");
byte[] smscontent = new byte[smscontentdb.length + temp.length];
System.arraycopy(smscontentdb, 0, smscontent, 0, smscontentdb.length);
System.arraycopy(temp, 0, smscontent, smscontentdb.length, temp.length);
SendSMS sendSMS = new SendSMS();
sendSMS.SmsInit();
if (sendSMS.SmsSend(mobileno, smscontent) >= 0) {
System.out.println("chenggong !");
}
else {
System.out.println("shibai !");
}
}catch (Exception ex) {}
}
}
　　在这个文件中要注意的有一点，就是在传递字节数组到C程序中时，最后的结尾一定要以0结束。这是一个偷懒的做法，不过是个有效的做法。因为大多数情况下，接口是由第三方提供的。所以我们一般是不知道在C的方法里，具体是怎么处理参数的。而C又是要求数组是有长度。所以，在Java中，如果你不想写程序传数组的长度，那么在数组中以0结尾就是最方便的方法了。当然，如果有更好的方法也希望大家提出。
　　到这里，一个完整的Java通过JNI调用动态链接库的程序就完成了。实际上也不是很复杂。只要多注意一下细节，是很容易得出来的。

lanxin1020 2009-05-07 11:04 发表评论

java.util.properties(转)

lanxin1020 — Wed, 06 May 2009 14:52:00 GMT

Properties 基本知识
如果不熟悉 java.util.Properties 类，那么现在告诉您它是用来在一个文件中存储键-值对的，其中键和值是用等号分隔的，如清单 1 所示。

清单 1. 一组属性示例
foo=bar
fu=baz

将清单 1 装载到 Properties 对象中后，您就可以找到两个键（ foo 和 fu ）和两个值（ foo 的 bar 和 fu 的 baz ）了。这个类支持带 \u 的嵌入 Unicode 字符串，但是这里重要的是每一项内容都当作 String 。

清单 2 显示了如何装载属性文件并列出它当前的一组键和值。只需传递这个文件的 InputStream 给 load() 方法，就会将每一个键-值对添加到 Properties 实例中。然后用 list() 列出所有属性或者用 getProperty() 获取单独的属性。
清单 2. 装载属性

Java代码

import java.util.*;
import java.io.*;
public class LoadSample {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
FileInputStream fis =
new FileInputStream("sample.properties");
prop.load(fis);
prop.list(System.out);
System.out.println("\nThe foo property: " +
prop.getProperty("foo"));
}
}

import java.util.*;
import java.io.*;
public class LoadSample {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
FileInputStream fis =
new FileInputStream("sample.properties");
prop.load(fis);
prop.list(System.out);
System.out.println("\nThe foo property: " +
prop.getProperty("foo"));
}
}

运行 LoadSample 程序生成如清单 3 所示的输出。注意 list() 方法的输出中键-值对的顺序与它们在输入文件中的顺序不一样。 Properties 类在一个散列表（hashtable，事实上是一个 Hashtable 子类）中储存一组键-值对，所以不能保证顺序。

清单 3. LoadSample 的输出

-- listing properties --
fu=baz
foo=bar

The foo property: bar

XML 属性文件
这里没有什么新内容。 Properties 类总是这样工作的。不过，新的地方是从一个 XML 文件中装载一组属性。它的 DTD 如清单 4 所示。

清单 4. 属性 DTD

dtd 写道

Java代码

"1.0" encoding="UTF-8"?>
"1.0">

如果不想细读 XML DTD，那么可以告诉您它其实就是说在外围标签中包装的是一个标签，后面是任意数量的标签。对每一个标签，有一个键属性，输入的内容就是它的值。清单 5 显示了清单 1中的属性文件的 XML 版本是什么样子的。

清单 5. XML 版本的属性文件

Java代码

"1.0" encoding="UTF-8"?>
"http://java.sun.com/dtd/properties.dtd">
Hi
"foo">bar
"fu">baz


java.sun.com/dtd/properties.dtd">

Hi
bar
baz

如果清单 6 所示，读取 XML 版本的 Properties 文件与读取老格式的文件没什么不同。
清单 6. 读取 XML Properties 文件

Java代码

import java.util.*;
import java.io.*;
public class LoadSampleXML {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
FileInputStream fis =
new FileInputStream("sampleprops.xml");
prop.loadFromXML(fis);
prop.list(System.out);
System.out.println("\nThe foo property: " +
prop.getProperty("foo"));
}
}

import java.util.*;
import java.io.*;
public class LoadSampleXML {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
FileInputStream fis =
new FileInputStream("sampleprops.xml");
prop.loadFromXML(fis);
prop.list(System.out);
System.out.println("\nThe foo property: " +
prop.getProperty("foo"));
}
}

关于资源绑定的说明
虽然 java.util.Properties 类现在除了支持键-值对，还支持属性文件作为 XML 文件，不幸的是，没有内置的选项可以将 ResourceBundle 作为一个 XML 文件处理。是的， PropertyResourceBundle 不使用 Properties 对象来装载绑定，不过装载方法的使用是硬编码到类中的，而不使用较新的 loadFromXML() 方法。

运行清单 6 中的程序产生与原来的程序相同的输出，如清单 2所示。

保存 XML 属性
新的 Properties 还有一个功能是将属性存储到 XML 格式的文件中。虽然 store() 方法仍然会创建一个类似清单 1 所示的文件，但是现在可以用新的 storeToXML() 方法创建如清单 5 所示的文件。只要传递一个 OutputStream 和一个用于注释的 String 就可以了。清单 7 展示了新的 storeToXML() 方法。

清单 7. 将 Properties 存储为 XML 文件

Java代码

import java.util.*;
import java.io.*;
public class StoreXML {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
prop.setProperty("one-two", "buckle my shoe");
prop.setProperty("three-four", "shut the door");
prop.setProperty("five-six", "pick up sticks");
prop.setProperty("seven-eight", "lay them straight");
prop.setProperty("nine-ten", "a big, fat hen");
FileOutputStream fos =
new FileOutputStream("rhyme.xml");
prop.storeToXML(fos, "Rhyme");
fos.close();
}
}

import java.util.*;
import java.io.*;
public class StoreXML {
public static void main(String args[]) throws Exception {
Properties prop = new Properties();
prop.setProperty("one-two", "buckle my shoe");
prop.setProperty("three-four", "shut the door");
prop.setProperty("five-six", "pick up sticks");
prop.setProperty("seven-eight", "lay them straight");
prop.setProperty("nine-ten", "a big, fat hen");
FileOutputStream fos =
new FileOutputStream("rhyme.xml");
prop.storeToXML(fos, "Rhyme");
fos.close();
}
}

运行清单 7 中的程序产生的输出如清单 8 所示。

清单 8. 存储的 XML 文件

Java代码

"1.0" encoding="UTF-8"?>
"http://java.sun.com/dtd/properties.dtd">
Rhyme
"seven-eight">lay them straight
"five-six">pick up sticks
"nine-ten">a big, fat hen
"three-four">shut the door
"one-two">buckle my shoe


java.sun.com/dtd/properties.dtd">

Rhyme
lay them straight
pick up sticks
a big, fat hen
shut the door
buckle my shoe

结束语
使用 XML 文件还是使用老式的 a=b 类型的文件完全取决于您自己。老式文件从内存的角度看肯定是轻量级的。不过，由于 XML 的普遍使用，人们会期望 XML 格式流行起来，因为它已经被广泛使用了，只不过没有用到 Properties 对象。选择完全在您。分析软件包 private XMLUtils 类的源代码以获得关于所使用的 XML 解析的更多信息。

Java代码

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 实现properties文件的读取
* @author bbflyerwww
* @date 2006-08-02
*/
public class PTest {
public static void main(String[] args) {
try {
long start = System.currentTimeMillis();
InputStream is = new FileInputStream("conf.properties");
Properties p = new Properties();
p.load(is);
is.close();
System.out.println("SIZE : " + p.size());
System.out.println("homepage : " + p.getProperty("homepage"));
System.out.println("author : " + p.getProperty("author"));
System.out.println("school : " + p.getProperty("school"));
System.out.println("date : " + p.getProperty("date"));
long end = System.currentTimeMillis();
System.out.println("Cost : " + (end - start));
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 实现properties文件的读取
* @author bbflyerwww
* @date 2006-08-02
*/
public class PTest {
public static void main(String[] args) {
try {
long start = System.currentTimeMillis();
InputStream is = new FileInputStream("conf.properties");
Properties p = new Properties();
p.load(is);
is.close();
System.out.println("SIZE : " + p.size());
System.out.println("homepage : " + p.getProperty("homepage"));
System.out.println("author : " + p.getProperty("author"));
System.out.println("school : " + p.getProperty("school"));
System.out.println("date : " + p.getProperty("date"));
long end = System.currentTimeMillis();
System.out.println("Cost : " + (end - start));
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}

conf.properties

Java代码

# Configuration fileauthor = bbflyerwww
school = WuHan University
date = 2006-08-02

# Configuration fileauthor = bbflyerwww
school = WuHan University
date = 2006-08-02

Result

SIZE:4
author : bbflyerwww
school : WuHan University
date : 2006-08-02
Cost : 0

lanxin1020 2009-05-06 22:52 发表评论

HashMap 与 TreeMap的区别

lanxin1020 — Sat, 18 Apr 2009 01:42:00 GMT

HashMap 与 TreeMap的区别

HashMap通过hashcode对其内容进行快速查找，而TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

集合框架”提供两种常规的Map实现：HashMap和TreeMap (TreeMap实现SortedMap接口)。在Map 中插入、删除和定位元素，HashMap 是最好的选择。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。使用HashMap要求添加的键类明确定义了hashCode()和equals()的实现。　　这个TreeMap没有调优选项，因为该树总处于平衡状态。

2、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?hash code是什么意思

hashcode是给一系列hash算法用的，比如hashtable。不同的对象应该有不同的hashcode，同一个对象应该有同样的hashcode

更正，不是同一个对象，而是相等的对象，应该有相同的hashcode

hash算法是什么啊，作用？ hash算法基本就是为了将一个对象和一个整数对应起来，不同的对象对应不同的整数。
(x.equals(y) == true)那这个的话就是去比较它们所对应的整数？
不是。有一个equals()函数，和一个hashcode()函数

3、String a="abc";String b=new String("abc");String c="abc";

System.out.println(a==b);f
System.out.println(a==c);t
System.out.println(b==c);f
System.out.println(a.equals(b));
输出结果是什么？
为什么？

4、a=0;b=0;
if((a=3)>0|(b=3)>0){}
if((a=3)>0||(b=3)>0){}分别说出a,b的值

lanxin1020 2009-04-18 09:42 发表评论

TREEMAP的排序机制 (转)

lanxin1020 — Sat, 18 Apr 2009 01:36:00 GMT

摘要: TREEMAP的排序机制 1package com.sf; 2 3import java.text.CollationKey; 4import java.text.Collator; 5import java.util.Comparator; 6import ... 阅读全文

lanxin1020 2009-04-18 09:36 发表评论

内部类(转)

lanxin1020 — Thu, 16 Apr 2009 06:06:00 GMT

内部类：定义在其他类里面的类。
使用内部类的理由：
1.内部类方法能够访问外部类的任何数据成员包括私有成员。
2.对同一个包的其他类，内部类是不可见的。
3.匿名内部类能够方便的定义回调而不用写太多方法。

非静态内部类没有默认的构造函数，非静态内部类的构造函数都有一个外围类对象的引用。
内部类的特殊语法规则：
1.相对内部类，引用其外部类隐式对象的形式：OuterClass.this
2.调用内部类的构造函数：outerObject.new InnerClass(construction parameters);
3.外部类外面引用内部类：OuterClass.InnerClass

内部类是一种编译器现象与虚拟机无关。编译器将内部类翻译为用$分隔外部类名和内部类名的常规类文件，虚拟机对此并无所知。
使用javap -private OuterClass$InnerClass。javap这个工具确实挺不错的，对分析字节码和源码都有很大的帮助。
可以看出详细的内部类源码清单，其中包括了编译器自动添加的部分：
public class Outer
{
public class Inner
{
}
}
当内部类是非静态内部类时相应的内部类的详细源码如下：
Compiled from "Outer.java"
public class Outer$Inner extends java.lang.Object{
final Outer this$0; //编译器自动在内部类里面添加了指向外部类对象的引用
public Outer$Inner(Outer); //内部类的构造函数默认有一个外部类对象作为参数。
}

当内部类是静态内部类时：
Compiled from "Outer.java"
public class Outer$Inner extends java.lang.Object{
public Outer$Inner(); //没有了对外部类对象的引用
}

如下代码模拟了上面内部类的情形唯一不同的是这里的Inner没有访问Outer私有数据的权限：
class Outer{
Inner in = new Inner(this);
}

class Inner{
   public Inner(Outer outer){
      this.outer = outer;
   }

   private Outer outer;
}

//那么权限是如何控制的呢？当内部类中的方法访问到外部类的私有数据时(注意如果内部类没有方法去访问外部类的私有数据不会生成该静态方法static int access$000(Outer);)
public class Outer
{
private int i;
public void methodOne()
{
}

class Inner
{
  public void print(){
   System.out.println(Outer.this.i);
  }
}
}

相应的外部类详细源码如下：
public class Outer
{
public Outer();

   public void methodOne();
   static int access$000(Outer); //由编译器合成的用于内部类对外部类进行特殊访问权限的控制：这也是
                                //为什么内部类能够访问外部类中的私有数据的原因。
   private int i;
}

内部类访问外部类的private数据的这种方式很可能导致危险，虽然access$000不是一个合法的Java方法名，但是熟悉class文件结构的黑客可以使用十六进制编辑器轻松创建一个用虚拟机指令调用那个方法的类文件。由于隐秘的访问方法需要拥有包可见性，所以攻击代码需要与被攻击类放在同一个包中。总之，如果内部类访问了外部类的私有数据域，就有可能通过附加在外部类所在包中的其他类访问私有数据。

局部内部类：定义在方法之中，因此局部类没有public和private修饰符。对外界是完全隐藏的。
局部类不仅能够访问外部类，还能访问方法中的局部变量(或方法的参数)。不过那些局部变量要声明为final的。

匿名内部类：用外部类+$+数字的形式表示。一个外部类中有多个匿名内部类时，其生成的class文件对应有Outer$(1、2、3)的形式表示。注意到该匿名内部类是final的。
final class Outer$1
{
Outer$1(Outer);

public void method();

final Outer this$0;
}

嵌套类：当内部类不需要访问外部类的数据成员时应该使用嵌套类。注意只有内部类可以声明为static的其他不行。
在接口中声明的内部类自动转换为public static的，在接口中定义的成员自动都是public static的。

内部类构造函数的可见性与其类的可见性相同。

lanxin1020 2009-04-16 14:06 发表评论

单例模式(转)

lanxin1020 — Mon, 06 Apr 2009 10:35:00 GMT

摘要: 单例模式是最简单的设计模式之一，但是对于Java的开发者来说，它却有很多缺陷。在本月的专栏中，David Geary探讨了单例模式以及在面对多线程（multithreading)、类装载器（classloaders）和序列化(serialization)时如何处理这些缺陷。单例模式适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统，它们都是原型的例子。典型的情况是，那些... 阅读全文

lanxin1020 2009-04-06 18:35 发表评论

设计模式-抽象工厂模式

lanxin1020 — Mon, 06 Apr 2009 02:02:00 GMT

工厂模式是最重要的模式，因为大多数模式都需要用到工厂模式。如果不能正确的运用工厂模式，那么可以说无法成为合格的架构师。
多数设计模式的内容讲解的都是如何设计接口。
接口如何产生呢？如果在客户代码（类库的使用者称之为客户）中直接使用具体类，那么就失去了接口的意义。因为接口的使用目的，就是要降低客户对具体类的依赖程度。如果在客户代码中直接使用接口，那么就造成了客户对具体类名称的依赖。（客户最终需要以某种方式指明所需要的具体类，如配置文件或代码，但是只需要指出一次，所以说降低对具体类的依赖程度）。要使客户代码不依赖具体类，唯一的方法，就是让客户代码不依赖具体类的部分不知道具体类的名称。知道具体类名称的部分，仅仅是配置部分。（配置文件或者配置代码）。
依赖不可能完全消除，除非二者毫无联系。但是可以将这种依赖的程度降到最低。
既然不能直接创建具体类，那么就需要通过一个创建者类来创建接口的实现类。这样就产生了工厂类。
那么现在已经知道工厂类存在的理由，抽象创建接口的过程。
这样，就可以使用简单工厂。
简单工厂，一般是两级结构。工厂类创建接口。
随着接口创建复杂性的增强，可能在接口创建的过程中，一个创建者类，无法承担创建所有的接口类的职责。
可能会有这样的情况，我们定义了一个接口，有6个实现类分别是123456号。但是，这六个实现类不可能用一个工厂创建出来，因为123号是 windows下的实现，而456号是linux上的实现。（假设我们使用的语言不是广大人民群众热爱的java语言），那么这个时候，我还需要客户方用相同的方式来创建这个借口，而不是在代码中到处写

代码

     if (操作系统 == " windows " ){

    }
      else {

    }

那样就太麻烦了。设计模式就是为了减少麻烦，而不是什么别的废话，比如什么太极八卦、天人合一、面向xx之类的。因为怕麻烦，所以搞出设计模式这个咚咚减少麻烦。如果你发现用了设计模式更麻烦了，那么肯定是你用错了。
这个时候为了省事，我就把工厂也抽象成一个接口（因为我有两个相似的工厂，如果只有一个，我还废话什么呢），这样就成了工厂方法。
当然，既然工厂方法成了一个接口，那么当然也需要用一个工厂来创建它。这个时候，创建是三级结构，简单工厂（此时是工厂的工厂）创建工厂接口（本来是个类，现在因为进一步的抽象，成为接口了），工厂接口创建产品。
过了一段时间，随着我们的工厂业务不断发展，我们有了很多产品。
比如，我们有锤子和钉子两种产品。这两种产品都有windows品牌和linux品牌的。我们给锤子和钉子各自定义了一个创建的接口。

代码

    interface 锤子工厂{
    造锤子（）；
    }
    interface 钉子工厂{
    造钉子();
    }

可是，我们发现某些用户，用windows的锤子去敲linux的钉子，从而把程序敲出了bug。这当然是我们的错误，因为我们违反了一条金科玉律：
要想使你的程序稳定运行，你假设用户是猪。
所以，我们把锤子和钉子的工厂合并，让一个工厂只能造出配套的锤子和钉子，这样猪就没有犯错误的机会了。
于是我们搞出一个抽象工厂：

interface 铁匠铺{
造锤子（）；
造钉子();
}

当然，这个铁匠铺是个接口，所以同样需要用一个工厂来创建它。所以，这个时候，工厂还是三级结构。
我们的工厂，业务很多，而且产品一般都是配套使用的（这样可以多骗点钱），所以，我们大多数情况下，都是使用抽象工厂和简单工厂。简单工厂用来创建工厂，抽象工厂创建产品。
工厂的作用，就是创建接口。
其实我们不知道什么是设计模式，我们只是怕麻烦。什么是麻烦呢？
我们觉得把同样的代码写两遍就非常麻烦。所以，我们宁可多写几句，也要解决麻烦。猪不怕麻烦，可以日复一日的重复相同的事情，可是我们不是猪。

例子:
public interface Plant { }//标志接口

//具体产品PlantA，PlantB

public class PlantA implements Plant {

　public PlantA () {

　　System.out.println("create PlantA !");

　}

　public void doSomething() {

　　System.out.println(" PlantA do something ...");

　}

public class PlantB implements Plant {

　public PlantB () {

　　System.out.println("create PlantB !");

　}

　public void doSomething() {

　　System.out.println(" PlantB do something ...");

　}

// 产品 Fruit接口

public interface Fruit { }

//具体产品FruitA，FruitB

public class FruitA implements Fruit {

　public FruitA() {

　　System.out.println("create FruitA !");

　}

　public void doSomething() {

　　System.out.println(" FruitA do something ...");

　}

public class FruitB implements Fruit {

　public FruitB() {

　　System.out.println("create FruitB !");

　}

　public void doSomething() {

　　System.out.println(" FruitB do something ...");

　}

// 抽象工厂方法

public interface AbstractFactory {

　public Plant createPlant();

　public Fruit createFruit();

}

//具体工厂方法

public class FactoryA implements AbstractFactory {

　public Plant createPlant() {

　　return new PlantA();

　}

　public Fruit createFruit() {

　　return new FruitA();

　}

public class FactoryB implements AbstractFactory {

　public Plant createPlant() {

　　return new PlantB();

　}

　public Fruit createFruit() {

　　return new FruitB();

　}

public Client {

public method1() {

AbstractFactory instance = new FactoryA();

instance.createPlant();

}

lanxin1020 2009-04-06 10:02 发表评论

事件监听机制(转)

lanxin1020 — Sun, 05 Apr 2009 00:39:00 GMT

一个事件监听机制（Event Listener）的例程

事件监听机制在java编程中有很重要的应用，一般我们在处理GUI编程时，只是重写一下监听接口的perform函数即可。但事件监听在底层是如何运行的？通过下面的例子我们可以有个清楚地了解。
1．首先写一个事件类
public class NewEvent {
private int eventType=-1;
public NewEvent(int type){
eventType=type;
}
public int getEventType(){
return eventType;
}

}
2．写一个事件监听器

public interface INewEventListener {
public void doProcessEvent(NewEvent event);

}
3．写一个测试程序
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Source {
private List listeners = new ArrayList();

public void addNewEventListener(INewEventListener listener){//增加一个监听器
if(!listeners.contains(listener)){
listeners.add(listener);
}
}

public void fireEvent(NewEvent event){//触发事件
for (Iterator i=listeners.iterator(); i.hasNext();) {
INewEventListener listener = (INewEventListener)i.next();
listener.doProcessEvent(event);
}
}

public void GenerateEvent(int eventType){//生成一个指定类型的事件
fireEvent(new NewEvent(eventType));
}

//for test
public static void main (String [] args){
Source source = new Source ();
source.addNewEventListener(new INewEventListener(){//增加一个监听器，并实现这个监听器接口的方法
public void doProcessEvent(NewEvent event){
int eventType = event.getEventType();
System.out.println("EventType "+eventType+ " was triggered");
}
});
source.GenerateEvent(3);//生成一个eventType为3的事件

}

}

lanxin1020 2009-04-05 08:39 发表评论

getOutputStream() has already been called for this response(转)

lanxin1020 — Thu, 26 Mar 2009 01:15:00 GMT

tomcat5下jsp出现getOutputStream() has already been called for this response异常的原因和解决方法

在tomcat5下jsp中出现此错误一般都是在jsp中使用了输出流（如输出图片验证码，文件下载等），
没有妥善处理好的原因。
具体的原因就是
在tomcat中jsp编译成servlet之后在函数_jspService(HttpServletRequest request, HttpServletResponse response)的最后
有一段这样的代码
finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);
}
这里是在释放在jsp中使用的对象，会调用response.getWriter(),因为这个方法是和
response.getOutputStream()相冲突的！所以会出现以上这个异常。

然后当然是要提出解决的办法，其实挺简单的（并不是和某些朋友说的那样--
将jsp内的所有空格和回车符号所有都删除掉），

在使用完输出流以后调用以下两行代码即可：
out.clear();
out = pageContext.pushBody();

最后这里是一个输出彩色验证码例子（这样的例子几乎随处可见）
imag.jsp

<%@ page import="java.awt.*,java.awt.image.*,java.util.*,javax.imageio.*" %>
<%@ page import="java.io.OutputStream" %>
<%!
Color getRandColor(int fc,int bc){
Random random = new Random();
if(fc>255) fc=255;
if(bc>255) bc=255;
int r=fc+random.nextInt(bc-fc);
int g=fc+random.nextInt(bc-fc);
int b=fc+random.nextInt(bc-fc);
return new Color(r,g,b);
}
%>
<%
try{
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
int width=60, height=20;
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
OutputStream os=response.getOutputStream();
Graphics g = image.getGraphics();
Random random = new Random();
g.setColor(getRandColor(200,250));
g.fillRect(0, 0, width, height);

g.setFont(new Font("Times New Roman",Font.PLAIN,18));
g.setColor(getRandColor(160,200));
for (int i=0;i<155;i++)
{
int x = random.nextInt(width);
int y = random.nextInt(height);
int xl = random.nextInt(12);
int yl = random.nextInt(12);
g.drawLine(x,y,x+xl,y+yl);
}
String sRand="";
for (int i=0;i<4;i++){
String rand=String.valueOf(random.nextInt(10));
sRand+=rand;
g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
g.drawString(rand,13*i+6,16);
}
session.setAttribute("rand",sRand);
g.dispose();

ImageIO.write(image, "JPEG",os);
os.flush();
os.close();
os=null;
response.flushBuffer();
out.clear();
out = pageContext.pushBody();
}
catch(IllegalStateException e)
{
System.out.println(e.getMessage());
e.printStackTrace();
}%>

lanxin1020 2009-03-26 09:15 发表评论

解决在命令行下编译和执行带包java文件的问题(修改)

lanxin1020 — Sat, 31 Jan 2009 02:59:00 GMT

1 如果用到j2ee包则现将servlet-api包拷贝到javaHome/jre\lib\ext下
2 在命令行方式下定位到要编译的文件所在的目录
3 javac -d . 文件名

lanxin1020 2009-01-31 10:59 发表评论

JAVA通过接口来实现CALLBACK

lanxin1020 — Tue, 20 Jan 2009 00:51:00 GMT

所谓回调，就是客户程序C调用服务程序S中的某个函数A，然后S又在某个时候反过来调用C中的某个函数B，对于C来说，这个B便叫做回调函数。

例：
1.class   A,class   B
2.class   A实现接口operate
3.class   B拥有一个参数为operate接口类型的函数test(operate   o)
4.class   A运行时调用class   B中test函数,以自身传入参数
5.class   B已取得A，就可以随时回调A所实现的operate接口中的方法

举个例子来说:

public interface InterestingEvent
{

// This is just a regular method so it can return something or

// take arguments if you like.

public void interestingEvent ();

}

public class EventNotifier
{

private InterestingEvent ie;

private boolean somethingHappened;

public EventNotifier (InterestingEvent event)
{

// Save the event object for later use.

ie = event;

// Nothing to report yet.

somethingHappened = false;

}

public void doWork ()
{

// Check the predicate, which is set elsewhere.

if (somethingHappened)
{

// Signal the even by invoking the interface's method.

ie.interestingEvent ();

}

//
}

}

public class CallMe implements InterestingEvent
{

private EventNotifier en;

public CallMe ()
{

// Create the event notifier and pass ourself to it.

en = new EventNotifier (this);

}

// Define the actual handler for the event.

public void interestingEvent ()
{

// Wow! Something really interesting must have occurred!

// Do something

}

lanxin1020 2009-01-20 08:51 发表评论

图像显示笔记

lanxin1020 — Sun, 10 Aug 2008 13:37:00 GMT

图像显示

1 使用Graphics.drawImage(Image img, int x, int y, ImageObserver observer)
方法显示图像。

2 使用Component.getToolkit.getImage(String path)语句获得Image实例对象。

例：
package drawimage;

import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class DrawImage extends Frame
{
    private static final long serialVersionUID = 1L;

    public DrawImage()
{
   this.addWindowListener(new WindowAdapter()
      {
       public void windowClosing(WindowEvent e)
       {
        dispose();
        System.exit(0);
       }

       });
}
public static void main(String[] args)
{
  System.out.println("Starting DrawImage.");
  DrawImage mainFrame = new DrawImage();
  Image img = mainFrame.getToolkit().getImage("love.jpg");

  mainFrame.setSize(400,400);
  mainFrame.setTitle("DrawImage");
  mainFrame.setVisible(true);
  Graphics g = mainFrame.getGraphics();
  while(!g.drawImage(img,150,150,mainFrame));

}

图像重画

package drawimage;

import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class DrawImage extends Frame
{
Image img = getToolkit().getImage("love.jpg");
    private static final long serialVersionUID = 1L;
public void paint(Graphics g)
{
  g.drawImage(img,0,0,this);
}
    public DrawImage()
{
   this.addWindowListener(new WindowAdapter()
      {
       public void windowClosing(WindowEvent e)
       {
        dispose();
        System.exit(0);
       }

       });
}
public static void main(String[] args)
{
  System.out.println("Starting DrawImage.");
  DrawImage mainFrame = new DrawImage();

  mainFrame.setSize(400,400);
  mainFrame.setTitle("DrawImage");
  mainFrame.setVisible(true);
  /*Graphics g = mainFrame.getGraphics();
  while(!g.drawImage(img,150,150,mainFrame));
  */

}

双缓冲技术：

1 Component.createImage方法创建内存Image对象
2 在Image对象上进行绘制的结果就成了一幅图像
3 在Image对象上执行与组件表面同样的绘制，Image
对象中的图像就是组件表面内容的复制，当组件重画时，只需要将内存中的Image对象在组件上画出；

package drawline;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
//import java.util.Enumeration;
import java.util.Vector;

public class DrawLine1 extends Frame
{
int orgX;
int orgY;
int endX;
int endY;
Image oimg = null;
Graphics og = null;
Vector vLines = new Vector();

public void paint(Graphics g)
{
  if(oimg != null)
  {
    g.drawImage(oimg,0,0,this);
  }
  /*g.setColor(Color.RED);
  g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
  Enumeration e = vLines.elements();
  while(e.hasMoreElements())
  {
   MyLine line = (MyLine)e.nextElement();
      line.drawMe(g);
  }*/
  //g.drawLine(orgX, orgY, endX, endY);
}
private static final long serialVersionUID = 9004940250333651314L;

public DrawLine1()
{
  setSize(400,400);
  setTitle("Drawline");
  setVisible(true);

  Dimension d = getSize();
  oimg = createImage(d.width,d.height);
  og = oimg.getGraphics();

     addWindowListener(new WindowAdapter()
     {
      public void windowClosing(WindowEvent e) {
       dispose();
       System.exit(0);
      }

     });

  this.addMouseListener(new MouseAdapter()
  {


      public void mousePressed(MouseEvent e)
      {
       orgX = e.getX();
       orgY = e.getY();

      }
      public void mouseReleased(MouseEvent e)
      {
       endX = e.getX();
       endY = e.getY();
       Graphics g = getGraphics();
       g.setColor(Color.RED);
       g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       g.drawString(orgX + "," + orgY,orgX,orgY);
       g.drawString(e.getX() + "," + e.getY(), e.getX(),e.getY());
       g.drawLine(orgX, orgY, e.getX(),e.getY());

       og.setColor(Color.RED);
       og.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       og.drawString(orgX + "," + orgY,orgX,orgY);
       og.drawString(e.getX() + "," + e.getY(), e.getX(),e.getY());
       og.drawLine(orgX, orgY, e.getX(),e.getY());
       /*vLines.add(new MyLine(orgX,orgY,endX,endY));
       repaint();*/
      }//为什么用getGraphics().setColor(Color.RED)是不用导java.awt.Graphics包
      //Enumeration???????????????????????????


     });
}

public static void main( String[] args) {
  System.out.println("String DrawLine");
   new DrawLine1();



}
}

//构建主框架对象时是先调用paint（）还是构造函数

lanxin1020 2008-08-10 21:37 发表评论

Graphics类与图形绘制笔记

lanxin1020 — Sat, 09 Aug 2008 23:51:00 GMT

Graphics类与图形绘制
Componentp.getGraphics方法与Grahpics类

Graphics.drawLine(int x1,int y1,int x2, int y2)方法；
Graphics.drawStringString str，int x，int y）方法；
Graphics.drawSting方法的坐标参数是以坐下方为参考点的；

例：

package drawline;

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class DrawLine extends Frame {

private static final long serialVersionUID = 9004940250333651314L;

public DrawLine()
{
  this.addWindowListener(new WindowAdapter()
     {
      public void windowClosing(WindowEvent e) {
       dispose();
       System.exit(0);
      }

     });

  this.addMouseListener(new MouseAdapter()
     {

      int orgX;
      int orgY;
      public void mousePressed(MouseEvent e)
      {
       orgX = e.getX();
       orgY = e.getY();

      }
      public void mouseReleased(MouseEvent e)
      {
       Graphics g = getGraphics();
       g.setColor(Color.RED);
       g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       g.drawString(orgX + "," + orgY,orgX,orgY);
       g.drawString(e.getX() + "," + e.getY(), e.getX(),e.getY());
       g.drawLine(orgX, orgY, e.getX(),e.getY());

      }//为什么用getGraphics().setColor(Color.RED)是不用导java.awt.Graphics包


     });
}

public static void main( String[] args) {
  System.out.println("String DrawLine");
  DrawLine mainFrame = new DrawLine();
  mainFrame.setSize(400,400);
  mainFrame.setTitle("Drawline");
  mainFrame.setVisible(true);


}
}

组件重建的处理：

1 组件重绘的原理曝光
2 paint(Graphics g)的作用

AWT组件重绘路线：
AWT Thread ->paint() ->AWT Thread
repaint()+AWT Thread ->update(清除组件表面内容调用paint()方法）->paint();

例：
package drawline;

public class DrawLine extends Frame
{
int orgX;
int orgY;
int endX;
int endY;
Vector vLines = new Vector();

public void paint(Graphics g)
{
  g.setColor(Color.RED);
  g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
  Enumeration e = vLines.elements();
  while(e.hasMoreElements())
  {
   MyLine line = (MyLine)e.nextElement();
  line.drawMe(g);
  }
  //g.drawLine(orgX, orgY, endX, endY);
}
private static final long serialVersionUID = 9004940250333651314L;

public DrawLine()
{

  this.addWindowListener(new WindowAdapter()
     {
      public void windowClosing(WindowEvent e) {
       dispose();
       System.exit(0);
      }

     });

  this.addMouseListener(new MouseAdapter()
     {


      public void mousePressed(MouseEvent e)
      {
       orgX = e.getX();
       orgY = e.getY();

      }
      public void mouseReleased(MouseEvent e)
      {
       endX = e.getX();
       endY = e.getY();
       /*Graphics g = getGraphics();
       g.setColor(Color.RED);
       g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       g.drawString(orgX + "," + orgY,orgX,orgY);
       g.drawString(e.getX() + "," + e.getY(), e.getX(),e.getY());
       g.drawLine(orgX, orgY, e.getX(),e.getY());
       */
       vLines.add(new MyLine(orgX,orgY,endX,endY));
       repaint();
      }//为什么用getGraphics().setColor(Color.RED)是不用导java.awt.Graphics包
      //Enumeration???????????????????????????


     });
}

package drawline;

import java.awt.Graphics;

public class MyLine
{
private int orgX;
private int orgY;
private int endX;
private int endY;
public MyLine(int orgX, int orgY, int endX, int endY)
{
  this.orgX = orgX;
  this.orgY = orgY;
  this.endX = endX;
  this.endY = endY;
}

public void drawMe(Graphics g)
{
  System.out.println(orgX + "," + orgY + " "+endX + "," + endY);
  g.drawString(orgX + "," + orgY,orgX,orgY);
  g.drawString(endX + "," + endY,endX,endY);
  g.drawLine(orgX, orgY, endX, endY);
}

}

lanxin1020 2008-08-10 07:51 发表评论

初学警示

lanxin1020 — Thu, 07 Aug 2008 07:53:00 GMT

初学警示：

面向对象编程思想：
编程人员脑海里面想的问题应该是：程序运行时的各个时刻的各个对象的内存布局和变化状态，以及每行代码执行后对这些对象产生的影响。而非顶住程序中静止不变的代码，孤立的琢磨每条语句的语法是否正确。

lanxin1020 2008-08-07 15:53 发表评论