BlogJava-无为-随笔分类-java

Java heap dump触发和分析

草儿 — Tue, 04 Oct 2011 14:31:00 GMT

为了分析java应用的内存泄漏，使用thread dump往往解决不了问题。使用jstat【eg：jstat -gcutil pid 1000 5】工具查看运行的java应用的heap size,perm size ,survivor ratio等，当时你无法知道是什么对象把堆填满了。

什么是 Java heap dump

首先需要搞懂什么是java heap，java heap是分配给实例类和数组对象运行数据区，所有java线程在运行期间共享heap中的数据。Java heap dump相当于java应用在运行的时候在某个时间点上打了个快照（snapshot）。

如果你不懂啥是snapshot，点击这里

触发 Java heap dump

有以下方法出发heap dump

使用$JAVA_HOME/bin/jmap -dump来触发，eg：jmap -dump:format=b,file=/home/longhao/heamdump.out
使用$JAVA_HOME/bin/jcosole中的MBean，到MBean>com.sun.management>HotSpotDiagnostic>操作>dumpHeap中，点击 dumpHeap按钮。生成的dump文件在java应用的根目录下面。
在应用启动时配置相关的参数 -XX:+HeapDumpOnOutOfMemoryError，当应用抛出OutOfMemoryError时生成dump文件。
使用hprof。启动虚拟机加入-Xrunhprof:head=site，会生成java.hprof.txt文件。该配置会导致jvm运行非常的慢，不适合生产环境。

分析 Java heap dump

1：使用IBM HeapAnalyzer

IBM HeapAnalyzer是一款免费的JVM内存堆的图形分析工具，它可以有效的列举堆的内存使用状况，帮助分析Java内存泄漏的原因。

下载解压后有一个ha413.jar，执行: java -Xmx512m -jar ha413.jar /home/longhao/heapdump.out

执行结果如图所示：

2：jhat

jhat（Java Head Analyse Tool ）是用来分析java堆的命令，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言OQL，分析相关的应用后，可以通过http://localhost:7000来访问分析结果。

示例: $JAVA_HOME/bin/jhat -J-Xmx512m /home/longhao/dump.out

3：Eclipse MemoryAnalyzer

Eclipse Memory Analyzer是一个快速并且功能强大的Java heap分析器，能够帮助你查找内存泄漏和减少内存消耗。在File>Acquire Heap Dump>configure>HPROF jmap dump provider设置一下分析应用的JDK，点击相关应用列表来生成heap dump并分析。

在socket，nio中的有些API中，申请的内存是直接向OS要的，在堆中分析内存是查看不到的，可以通过-XX:MaxDirectMemorySize=来设置应用向OS直接申请的最大内存数。

草儿 2011-10-04 22:31 发表评论

java中Class.getResource用法

草儿 — Tue, 29 Sep 2009 11:43:00 GMT

摘要: 用JAVA获取文件，听似简单，但对于很多像我这样的新人来说，还是掌握颇浅，用起来感觉颇深，大常最经常用的，就是用JAVA的File类，如要取得 c:/test.txt文件，就会这样用File file = new File("c:/test.txt");这样用有什么问题，相信大家都知道，就是路径硬编码，对于JAVA精神来说，应用应该一次成型，到处可用，并且从现实应用来讲，最终生成的应用也会部署到W... 阅读全文

草儿 2009-09-29 19:43 发表评论

OOME错误抛出原因

草儿 — Sat, 20 Sep 2008 03:20:00 GMT

OOME错误抛出原因（排列以发生的可能性为据）：

1. Java Heap中无法申请到足够的内存用于创建新的object，JVM会抛出OOME错误

根据异常发生的日志分析，有可能是因为POP3受信时，发生死锁，导致旧对象无法释

放，Java heap 内存超过最大分配内存，OOME抛出。

2. Native memory JVM正常运行和 JNI调用第三方库时分配内存。Native内存会在JVM进程所

需要的内存向系统申请，如果JNI调用不能申请到内存就会抛出OOME错误。

3. Process memory size 不够。这种可能性比较小。

草儿 2008-09-20 11:20 发表评论

Java学习笔记 - 基础篇

草儿 — Sun, 16 Dec 2007 13:04:00 GMT

一、面向对象的编程概念

观察现实对象两个性质：状态、行为。

面向对象的好处：模块化、隐藏信息。

继承：子类从父类（超类）继承状态和行为；子类可以改变父类的状态和行为。

接口：是无关对象用来进行彼此交互的设备；一个对象可以实现多个接口。

二、语言基础

变量

对象将它的状态存储在变量中；变量是一个由标识符命名的数据项。

声明变量的形式：<类型> <名称>

JAVA语言两大数据类型

原始类型数据(基本数据类型)、引用类型。

原始类型数据是不能再分解的数据类型(8种：byte、short、int、long、float、double、char、boolean)，数据在作为函数参数是以“传值”方式工作的；

整数 byte：1字节长的整数；8位有符号的二进制补码整数

short：短整数；16位有符号的二进制补码整数

int：整数；32位有符号的二进制补码整数

long：长整数；64位有符号的二进制补码整数

实数 flat：单精度浮点数；32位IEEE 754浮点数

double：双精度浮点数；64位IEEE 754浮点数

其他类型 char：单一Unicode字符；16位Unicode字符

boolean：布尔值(true或false)；8位/1位(8位空间，1位数据)

引用类型包括类(class)、接口(interface)、数组(array)。引用类型有时也称复合类型，它是可以分解为基本类型的数据类型，其数据在作为函数参数时是以“传址”的方式工作的。与原始类型相对，引用类型变量的值是对由此变量代表的一个值或一组值的引用(也就是地址)。

如：

原始类型 int a = 3; //“a”表示变量名称，“3”表示变量值；如果写成“final int a = 3;”，“final”表示不可改变值，所以这里的3(变量值)不可变

引用类型 Staing b = "Hello Java"; //“b”表示引用名称，“Hello Java”表示字浮串数组

流程控制语句

循环 while、do - while、for

判断 if - else、switch - case

异常处理 try – catch – finally、throw

分支 break、continue、label :、return

循环：

while和do – while语句：While语句用于在条件保持为true时反复执行一个代码块；

do – while语句的代码块中的语句至少被执行一次。

for语句：

for语句提供一种迭代某个范围内的值的紧湊方式。

判断：

if – else 语句：if语句使程序能够根据某些条件有选择地执行其他语句；

switch语句用于根据一个整数表达式有条件的执行语句；

注意：必须要有明确的break语句，否则，流程控制将一个接一个的经过后面的case语句

比较if语句和switch语句(if语句可以用于根据某范围的值或条件进行判断;switch语句只用于根据单个整数值进行判断)。

异常处理语句：

当程序发生错误时，程序会抛出一个异常，程序的正常流程被中断；

分支语句：break、continue语句可以和标签语句一起使用，也可以没有标签；

标签是放在一个语句前的标识符，标识符后跟一个冒号；

continue 语句：continue语句用于跳过for、while、do – while循环的当前迭代；

return 语句：返回一个值；不返回值。

三、对象基础和简单数据结构

创建对象：声明一个变量来引用变量；对对象进行实例化(构造器)；

用new操作符和构造器从类创建对象。

两种方式使用一个对象：引用一个对象的变量；调用对象的方法。

字符和字符串

JAVA平台包含三个用于处理字符数据的类：

Character：包含单个字符值；定义了一些可用于操作和检查单字符数据的方法(Character类的对象实例包含单个字符值，可用Character对象替代基本类型char)。

String：这个类用于处理由多个字符组成的不可改变的数据。

StringBuffer：存储和操作由多个字符组成的可改变的数据。

字符串和字符串缓冲区

String：不能改变自身的值。

StringBuffer：用于将被修改的字符串。

得到字符串或字符串缓冲区的长度

length方法：返回字符串或字符串缓冲区中包含的字符数。

capacity方法：StringBuffer特有；返回分配给字符串缓冲区的空间量，而不是被使用的空间量。

String类没有capacity方法，因为字符串不能改变。

通过索引从字符串或字符串缓冲区得到字符

charAt(int)方法：得到字符串或字符串缓冲区某索引位置上的字符。

注意：第一个字符串的索引为0；最后一个字符的索引为length – 1；

subString(int), subString(int,int)：从字符串或字符串缓冲区中得到多个字符。

在字符串中搜索字符或子字符串

String类提供了两个访问器方法：indexOf 方法从字符串的开头向前搜索；lastIndexOf 方法从字符串的末尾向后搜索；

StringBuffer类不支持indexOf和lastIndexOf方法。

操作字符串

String类有几个方法看起来可以修改字符串。当然，字符串是不能被修改的，所以，这些方法实际上是创建并返回包含结果的另一个字符串。

修改字符串缓冲

字符串缓冲是可以修改的，StingBuffer提供了几个用于修改字符串缓冲区的数据的方法；

如果修改字符串缓冲区的操作造成字符串缓冲区的大小超出它的当前容量，那么字符串缓冲区会自动分配更多的内存。

字符串和编译器

编译器在很多地方自动的使用String和StringBuffer类来处理字符串直接值和字符串连接；

编译器为它遇到的每个字符串直接值自动创建一个新的String对象；

可以使用+操作符连接字符串。

四、类和继承

实现继承：extends关键字

为类提供构造器

构造器用于初始化类的新对象：构造器不是方法，没有返回类型；构造器的声明中可以使用以下访问说明符：

– private

– protected

– public

– 无说明符

将信息传递给方法或构造器

参数类型；

参数名称；

按值传递：参数是原始类型，方法不能改变其值；参数是引用类型，方法不能改变其引用，但可以改变引用对象的值。

从方法返回值

在方法声明中声明方法的返回类型；eturn语句返回值的数据类型必须匹配方法声明的返回类型；方法可以返回原始类型，也可以返回引用类型。

使用this关键字

在实例方法或构造器中，this引用当前对象，也就是被调用的方法或构造器所属的对象；在构造器中，还可以使用this关键字调用相同类中的另一个构造器。

控制对类成员的访问

访问说明符决定其他类是否可以使用某个成员或调用某个方法。Java编程语言支持四种用于成员变量和方法的访问级别：private、protected、public和(如果没有指定)package。

访问级别

Private：类

无说明符：类、包

Protected：类、包、子类

Public：类、包、子类、所有类

实例和类成员的初始化

可以在声明的同时进行初始化，但是有一些限制：

– 必须以一个赋值语句表达初始化方式

– 初始化表达式不能调用任何被声明为抛出非运行时异常的方法

– 如果初始化表达式调用一个抛出运行时异常的方法，那么它不能进行错误恢复

使用静态初始化块初始化类成员；

实例成员的初始化。

覆盖和隐藏方法

覆盖（override）（实例方法）：

– 子类中的个实例方法与超类中的实例方法具有相同的标记和返回类型

– 方法的标记：名称，参数数量、参数类型

– 覆盖方法可以具有不同的throws子句

– 覆盖方法的访问说明符允许访问限制只能比被覆盖方法的多

– 子类不能覆盖超类中声明为final的方法

– 子类必须覆盖超类中声明为abstract的方法，否则子类本身必须是抽象的

覆盖和重载（overload）；

覆盖和隐藏（类方法）。

隐藏成员变量

在类中，如果一个成员变量与超类中的成员变量同名（即使它们的类型不同），那么它隐藏超类成员变量；

在子类中，不能通过简单名称引用超类中的成员变量，而是必须通过super访问它；

代码可读性差，不建议隐藏成员变量。

使用super

使用super调用被覆盖的方法；使用super调用被隐藏的成员变量；使用super在构造器中调用超类的构造器。

使用Object的后代

每个类都是Object类的直接后代或间接后代；

Object类定义了所有类都必须有的基本状态和行为：

– clone

– equals和hashCode

– finalize

– toString

– getClass

– notify、notifyAll和wait

编写final类和方法

将类声明为final，即类不能被子类化：

– 通过防止系统被改版来提高系统的安全性

– 出于设计上的原因，某些类不需要子类

final方法：

– 在方法声明中使用final关键字表示这个方法不能被子类覆盖

编写抽象类和方法

抽象类：

– 表示一个抽象的概念，不应该被实例化

– abstract关键字

抽象方法：

– 没有实现的方法，允许子类提供这些方法的实现细节

– 如果抽象类只包含抽象方法，那么它应该被定义成接口

创建类的小结

类的定义有两个部分：

– 类声明

– 类体：成员变量、方法、构造器

访问说明符——控制对成员变量和方法的访问方式；

类变量、类方法，static方法关键字

实例成员、实例方法

五、接口和包

实现接口：implements关键字

类可以实现多个接口,implements关键字后面跟以逗号分隔的接口列表；

如果有extends关键字,implements子句应该在extends子句的后面；

类要么必需实现接口及其超接口中的所有方法,要么类必须被声明为抽象的；

类中的方法标记(名称和参数列表)必须匹配接口中的方法标记。

将接口作为类型使用

在定义了一个新接口是,就是在定义一个新的引用数据类型；

定义可一用接口,实例化是必须用类。

接口不能改变

从语法的角度看,接口可以被改变；

从设计的角度看,一个已经在系统中被广泛使用的接口,不能轻易被改变；

如果改变了接口,实现原接口的类都将无法工作；

应该尽可能的考虑接口所提供的方法；

如果要改变接口,用继承的方式定义新的接口。

接口小结

接口定义了一种功能描述,定义了对象之间进行通讯的协议；

接口定义由接口声明和接口体组成；

接口包含一组方法的声明,但没有方法的实现；

实现接口的类必须实现接口中声明的所有方法；

接口名称可以作为数据类型使用。

创建和使用包

创建包：

– 将package语句作为类或接口源代码文件中的第一条语句

– 类或接口的源代码和类文件的路径名与包的名称相对应

使用另一个包中的接口或类：

– 类或接口的限定名

– 导入类或接口

– 导入类或接口所在的整个包

六、使用异常处理错误

什么是异常：异常(exception)是在程序执行期间中断指令的正常流程的事件。

try块

try {

statements

}

statements是包含一个或多个可能抛出异常的语句。

catch块

每个catch块是一个异常处理器，它处理由其参数指定的异常类型

try{

......

} catch(ExceptionType name) {

……

} catch (ExceptionType name) {

……

}

finally块

finally块是可选的，它提供一种机制，其目的是无论try块中是否发生异常都确保进行清理工作；

无论是否发生异常，都会执行finally块中的代码。

throw语句

throw语句需要一个参数：一个可抛出的（Throwable）对象；可抛出对象是Throwable类的子类。

Throwable类及其子类

Throwable类有两个直接子类：

– Error

– Exception

Error：

– JAVA虚拟机的动态链接故障或其它“硬”故障，一般的程序不应该捕获Error，也不能抛出Error

Exception：

大多数程序抛出并捕获从Exception类派生的对象。Exception表示发生了一个问题，但并不是严重的系统问题。你写的多数程序将抛出并捕获Exception(而不是Error)。

– Exception表示发生了一个问题，但并不是严重的系统问题

– Exception的不同子类表示可能发生的各种异常

异常的优点：将错误代码与“常规”代码分离；将错误沿调用堆栈向上传递；对错误类型进行分组和区分。

异常的小结

程序可以使用异常表明发生了错误；

程序可以使用throw语句抛出异常；

异常是一个对象（Throwable的子类）；

程序可以使用try、catch语句finally来捕获异常：

– try语句标识出可能发生的异常

– catch语句标识出异常处理器

– finally代码块不论抛出异常与否都会被执行，适用于清理工作

七、线程：同时执行多个任务

只要用到线程就必须继承或接口：Thread。

只要用到线程就必须要用run方法。

什么是线程：

– 线程是程序内的一个单一的顺序控制流程

– 线程本身不是程序，不能单独运行，它在一个程序内运行

– 多个线程可以同时运行，在一个程序内执行不同的任务

定制线程的run方法

run方法执行线程的工作；

run方法实现了线程的运行行为；

run方法可以做任何可以用语句实现的事。

为线程提供run方法：

– 继承Thread类，并覆盖run方法

– 实现Runnable接口

对Thread类进行子类化和覆盖run

public class SimpleThread extends Thread {

public SimpleThread(String str) {

super(str);

}

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(i + " " + getName());

try {

sleep((long)(Math.random() * 1000));

} catch (InterruptedException e) {}

}

System.out.println("DONE! " + getName());

}

实现Runnable接口：如果一个类已经继承了另一个类，那么要想实现线程就必须实现Runnable接口。

在线程中结果是随机产生的，如果想锁定对象就要使用Synchronized关键字意思为锁定方法所有在的对象。在对象被解锁前，其他线程不能调用相同对象上的被同步的方法。意思为执行一个对象后激活另一个对象，自身暂时睡眠，等待另一个对象执行完毕，在执行下一步，反复如此。

八、IO：读和写

如何使用管道流：管道用于将一个线程的输出连接到另一个线程的输入

如何封装流：流经常被以下的这种形式封装起来，以便组合许多流的各种功能

对象的串行化：Java.io包中的两个流——ObjectInputStream和ObjectOutputStream是字节流，他们的工作与其他输入和输出流类似。但他们的特殊之处在于它们可以读写对象。

对对象进行串行化：如果将一个不能串行化的对象传递给writeObject方法，那么它抛出一个NotSerializable Exception。对象只能在它的类实现了Serializable接口的情况下被串行化。

为类提供对象串行化：只有在对象的类实现了Serializable接口情况下，对象才是可串行化的。所有，如果想要对你的类的实例进串行化，这个类必须实现Serializable接口。Serializable接口是一个空接口，也就是说，他不包含任何方法声明；它的作用只是表明这个类的对象可以被串行化。

I/O复制小程序(Copy.java)，如下：

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
//以上是此程序用到的IO类的包，也可以用“import java.io.*”

public class Copy {
public static void main(String[] args) throws IOException {
File inputFile = new File("D:\\temp\\HelloWorld.java"); //目标文件路径，JAVA中路径地址只能用“\\”或“/”不能使用“\”
File outputFile = new File("D:\\temp\\OutAgain.java"); //复制后新文件保存路径

           FileReader in = new FileReader(inputFile);
           FileWriter out = new FileWriter(outputFile);
           int c;

while ((c = in.read()) != -1) //一直循环到0表示已经复制完毕，所以这里使用不等于负1
out.write(c);

           in.close(); //关闭读文件对象
           out.close(); //关闭写文件对象
       }

草儿 2007-12-16 21:04 发表评论

Java 5|6 并发包介绍

草儿 — Wed, 24 Oct 2007 02:14:00 GMT

摘要: java.util.concurrent 包含许多线程安全、测试良好、高性能的并发构建块。不客气地说，创建 java.util.concurrent 的目的就是要实现 Collection 框架对数据结构所执行的并发操作。通过提供一组可靠的、高性能并发构建块，开发人员可以提高并发类的线程安全、可伸缩性、性能、可读性和可靠性。如果一些类名看起来相似，可能是因为 java.util.concurr... 阅读全文

草儿 2007-10-24 10:14 发表评论

1、堆排序的实现

草儿 — Fri, 28 Sep 2007 06:24:00 GMT

import java.io.IOException;

class MyNode {
  private int iData;

  public MyNode(int key) {
    iData = key;
  }

  public int getKey() {
    return iData;
  }

}

public class Heap {
  private MyNode[] heapArray;

  private int maxSize;

  private int currentSize; // number of items in array

  public Heap(int mx) {
    maxSize = mx;
    currentSize = 0;
    heapArray = new MyNode[maxSize];
  }

  public MyNode remove()
  {
    MyNode root = heapArray[0];
    heapArray[0] = heapArray[--currentSize];
    trickleDown(0);
    return root;
  }

  public void trickleDown(int index) {
    int largerChild;
    MyNode top = heapArray[index];
    while (index < currentSize / 2)
    {
      int leftChild = 2 * index + 1;
      int rightChild = leftChild + 1;
      // 找到最大的子节点
      if (rightChild < currentSize
          &&
          heapArray[leftChild].getKey() < heapArray[rightChild]
              .getKey())
        largerChild = rightChild;
      else
        largerChild = leftChild;

      if (top.getKey() >= heapArray[largerChild].getKey())
        break;

      heapArray[index] = heapArray[largerChild];
      index = largerChild;
    }
    heapArray[index] = top;
  }

  public void displayHeap() {
    int nBlanks = 32;
    int itemsPerRow = 1;
    int column = 0;
    int currentIndex = 0;
    while (currentSize > 0)
    {
      if (column == 0)
        for (int k = 0; k < nBlanks; k++)
          System.out.print(' ');
      System.out.print(heapArray[currentIndex].getKey());

      if (++currentIndex == currentSize) // 判断是否输出结束
        break;

      if (++column == itemsPerRow) // 是否到达行尾?
      {
        nBlanks /= 2;
        itemsPerRow *= 2;
        column = 0;
        System.out.println();
      } else
        for (int k = 0; k < nBlanks * 2 - 2; k++)
          System.out.print(' '); // 输入空白
    }
  }

  public void displayArray() {
    for (int j = 0; j < maxSize; j++)
      System.out.print(heapArray[j].getKey() + " ");
    System.out.println("");
  }

  public void insertAt(int index, MyNode newNode) {
    heapArray[index] = newNode;
  }

  public void incrementSize() {
    currentSize++;
  }

  public static void main(String[] args) throws IOException {
    int size, i;

    size = 100;
    Heap theHeap = new Heap(size);

    for (i = 0; i < size; i++) {
      int random = (int) (java.lang.Math.random() * 100);
      MyNode newNode = new MyNode(random);
      theHeap.insertAt(i, newNode);
      theHeap.incrementSize();
    }

    System.out.print("Random: ");
    theHeap.displayArray();
    for (i = size / 2 - 1; i >= 0; i--)
      theHeap.trickleDown(i);

    System.out.print("Heap:   ");
    theHeap.displayArray();
    theHeap.displayHeap();
    for (i = size - 1; i >= 0; i--) {
      MyNode biggestNode = theHeap.remove();
      theHeap.insertAt(i, biggestNode);
    }
    System.out.print("Sorted: ");
    theHeap.displayArray();
  }
}

草儿 2007-09-28 14:24 发表评论

DB连接池管理编程举例

草儿 — Fri, 28 Sep 2007 06:10:00 GMT



import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.Properties;



import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import javax.sql.ConnectionPoolDataSource;

import javax.sql.PooledConnection;



public class MainClass {

  public static void main(String[] args) {

    Connection connection = null;

    Statement statement = null;

    ResultSet resultSet = null;



    try {

      connection = getConnection();

      // 操作连接

      statement = connection.createStatement();

      String selectEmployeesSQL = "SELECT * FROM employees";

      resultSet = statement.executeQuery(selectEmployeesSQL);



      while (resultSet.next()) {

        printEmployee(resultSet);

      }

    } catch (Exception e) {

      e.printStackTrace();

    } finally {

      if (resultSet != null) {

        try {

          resultSet.close();

        } catch (SQLException e) {

        } // nothing we can do

      }

      if (statement != null) {

        try {

          statement.close();

        } catch (SQLException e) {

        } // nothing we can do

      }

      if (connection != null) {

        try {

          connection.close();

        } catch (SQLException e) {

        } // nothing we can do

      }

    }

  }



  private static Connection getConnection() throws NamingException, SQLException {

    InitialContext initCtx = createContext();

    String jndiName = "HrDS";

    ConnectionPoolDataSource dataSource = (ConnectionPoolDataSource) initCtx.lookup(jndiName);

    PooledConnection pooledConnection = dataSource.getPooledConnection();

    return pooledConnection.getConnection(); // 从池中得到连接

  }



  private static InitialContext createContext() throws NamingException {

    Properties env = new Properties();

    env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");

    env.put(Context.PROVIDER_URL, "rmi://localhost:1099");

    InitialContext context = new InitialContext(env);

    return context;

  }



  private static void printEmployee(ResultSet resultSet) throws SQLException {

    System.out.print(resultSet.getInt("employee_id")+", ");

    System.out.print(resultSet.getString("last_name")+", ");

    System.out.print(resultSet.getString("first_name")+", ");

    System.out.println(resultSet.getString("email"));

  }



}

草儿 2007-09-28 14:10 发表评论

Java中如何重设数组的大小？

草儿 — Wed, 19 Sep 2007 02:34:00 GMT

在Java中，数组不能动态重设大小。一个可替代方法是使用java.util.ArrayList (或者java.util.Vector)代替使用原始数组（array）。另一种解决方案是用一个不同大小的数组重设数组，将旧数组内容拷贝到新的数组。下面做了个演示程序实现第二种方案，编写了个通用函数rsizeArray (参数)来实现此功能：

/**

* 使用一个新大小重设数组，并拷贝旧数组的内容到新数组

* @param oldArray  旧数组被重设

* @param newSize   新数组大小

* @return          返回带同样内容的新数组

*/

private static Object resizeArray (Object oldArray, int newSize){

int oldSize = java.lang.reflect.Array.getLength(oldArray);

Class elementType = oldArray.getClass().getComponentType();

Object newArray = java.lang.reflect.Array.newInstance(

elementType,newSize);

int preserveLength = Math.min(oldSize,newSize);

if (preserveLength > 0)

System.arraycopy (oldArray,0,newArray,0,preserveLength);

return newArray; 

}

// resizeArray()测试用例

public static void main (String[] args) {

int[] a = {1,2,3};

a = (int[])resizeArray(a,5);

a[3] = 4;

a[4] = 5;

for (int i=0; i
System.out.println (a[i]); }

那二维数组如何重设大小呢？很简单，就是处理数组的数组呀！

要想重设二维数组，resizeArray方法必须处理外部数组和所有嵌套数组，如下例：

  int a[][] = new int[2][3];

//...

a = (int[][])resizeArray(a,20);

// 新数组是[20][3]

for (int i=0; i
if (a[i] == null)

a[i] = new int[30];

else a[i] = (int[])resizeArray(a[i],30); 

}

// 新数组是[20][30]

草儿 2007-09-19 10:34 发表评论

常去的几个外国技术门户

草儿 — Sat, 15 Sep 2007 09:56:00 GMT

http://www.infoq.com
http://www.theserverside.com
http://www.javablogs.com
http://www.java.net
http://www.javasoft.com
http://blogs.sun.com
   之（重要）
   http://blogs.sun.com/roumen/
   http://blogs.sun.com/geertjan/
   http://blogs.sun.com/theaquarium/
http://www.ibm.com/developerworks
http://www.onjava.com/
http://www.developer.com/java/
http://www.javaworld.com/
http://www.java.com/
http://www.netbeans.org/kb/index.html
http://www.eclipse.org
http://www.oracle.com/technology/tech/java/index.html
http://www.javaranch.com
http://www.javablackbelt.com
http://www.jugcologne.org
http://www.dzone.com

草儿 2007-09-15 17:56 发表评论

Java Annotation手册

草儿 — Thu, 06 Sep 2007 11:11:00 GMT

摘要:
Annotation 提供了一条与程序元素关联任何信息或者任何元数据（metadata）的途径。从某些方面看，annotation就像修饰符一样被使用，并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。这些信息被存储在annotation的“name=value”结构对中。 annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问。
阅读全文

草儿 2007-09-06 19:11 发表评论

什么是JMX?

草儿 — Mon, 03 Sep 2007 14:26:00 GMT

JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。

JMX的前身是JMAPI。

JMX致力于解决分布式系统管理的问题，因此，能够适合于各种不同的环境是非常重要的。为了能够利用功能强大的Java计算环境解决这一的问题，Sun公司扩充了Java基础类库，开发了专用的管理类库。

JMX是一种应用编程接口，可扩充对象和方法的集合体，可以用于跨越一系列不同的异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用它提供了用户界面指导、Java类和开发集成系统、网络及网络管理应用的规范。

管理对象是JMX应用程序的核心。JMX结构包括：支持Java的Web浏览器用户接口，管理运行模块ARM(Admin Runtime Module)和应用。这三个部件之间通过RMI（Remote Method Invocation）进行通信。这里需要说明的是，RMI是使得一个Java虚拟机（JVM）上运行的程序可以调用远程服务器上另一个JVM总的对象。

用户接口用来发布管理操作，这些操作可以间接的通过浏览器或通过单独的应用程序来激发。管理运行模块用来给应用提供实例化的管理对象。它包括Agent对象接口，通知接口和被管数据接口。应用指的是那些被管设备单元。

JMX是一个完整的网络管理应用程序开发环境，它同时提供了：厂商需要收集的完整的特性清单，可生成资源清单表格，图形化的用户接口；访问SNMP的网络API；主机间远程过程调用；数据库访问方法。

JMX这一轻型的管理基础结构，价值在于对被管理资源的服务实现了抽象，提供了低层的基本类集合，开发人员在保证大多数的公共管理类的完整性和一致性的前提下，进行扩展以满足特定网络管理应用的需要。

JMX注重于构造管理工具的软件框架，并尽量采用已成熟的技术。

JMX体系被分成三个层次

表现层
代理层
分布式服务层

表现层

表现层定义的是JMX可管理资源所在的层。

这些已管理的资源可以编写或封装为MBean。

MBean分为四种类型：标准、动态、开放、模型

代理层

定义的是MBean向应用程序施加管理的层。包括MBean服务器和代理服务的定义。还至少包括一个协议适配器或连接器。

代理的组成：。一个MBean服务器。要管理的MBean 。作为MBean实现的代理服务。至少一个协议适配器

MBean

在JMX中，最小的可管理单元是MBean。

MBean不是一个真正的接口和类，而是必须准循的设计模式以确保资源是一个兼容的MBean。

MBean的激活方法:

invoke()方法是管理应用程序用于激活MBean的方法的手段。 invoke()方法有三个参数，分别是方法的名称、表示属性的对象数组和描述方法签名的一个字符串数组。它与使用Java Reflection Api 激活方法的方式类似。

Notification(通知)模型：

MBean的通知模型类似与Java事件的监听器模型。 MBean或管理应用程序可以作为MBean事件的监听器注册。通知支持由两个基本的概念组成，即广播器和监听器。

MBean服务器

MBean服务器用于注册可管理的MBean。

所有对MBean的请求或查询都是通过MBean服务器实施的。

代理服务

代理服务是一些特殊的函数，代理把这些服务提供给MBean，这些代理服务独立于任何MBean。

一个代理可以提供四种主要的服务：

动态装载：允许代理通过下载这个Bean的类动态实例化MBean，这与装载applet的方式类似。

JMX使用m-let这个标记指定期望动态装载的MBean的位置。

监控：允许代理通知有关的监听器监控一个MBean的属性值的变化

JMX允许使用三种基本类型的监控程序 (1)CounterMonitor：该程序可以观察类型方面的变化，比如Byte类似或Integer类型 (2)GaugeMonitor：该程序可以观察类型方面的变化，比如Byte类似或Integer类型，还可以在到达上下阀值时进行报告。 (3)StringMonitor：该程序可以观察java.lang.String类型的变化。

计时器：允许预设的时间间隔发送通知，可以作为一个调度程序
关系：允许创建和维护MBean之间的关系

分布式服务层

包含协议适配器和连接器两种类型的组件，通过它们连接到外部的应用，如RMI管理应用、基于浏览器的管理控制等

协议适配器和连接器

协议适配器是代理与管理客户通信的手段，每个通信的协议都可能不同。

它们都是管理客户与MBean交互的方式。

JMX的好处

可减少对JAVA应用实施管理的投资
提供了一个可伸缩的管理框架
集成现有的管理方案：如：WBEM，SNMP，TMN
使用现有的标准JAVA技术
能使用未来的一些管理概念：如Jini连接技术、通用即插即用、服务定位协议(Service Location Protocol)
只定义了一些可以访问的接口

转侯捷谈Java反射机制

草儿 — Wed, 29 Aug 2007 03:24:00 GMT

摘要: 摘要 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运... 阅读全文

草儿 2007-08-29 11:24 发表评论

国外开源网站聚合

草儿 — Sat, 25 Aug 2007 15:16:00 GMT

sourceforge http://www.sourceforge.net
java.net http://www.java.net

www.eclipse.org

www.opensource.org

http://strutstestcase.sourceforge.net (StrutsTestCase是基于Junit的一个方便测试struts框架的测试框架)

Lomboz http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML编辑器)
XmlBuddy http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项目)
PDFBox http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF http://sourceforge.net/projects/cewolf/ (一套标签库实现Web报表,使用的是jFreeChart引擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目)
htmlparser http://sourceforge.net/projects/htmlparser/ (用于解析HTML信息的项目)
Mondrian http://sourceforge.net/projects/mondrian/(Open Source OLAP Database)
ProGuard http://sourceforge.net/projects/proguard/(Java的混淆器)
InfoGlue http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
http://java-source.net/

(5)几个常用JAVA开源项目的地址荟萃:
Lomboz http://www.objectlearn.com/index.jsp (J2EE plugin for Eclipse)
htmlArea http://sourceforge.net/projects/itools-htmlarea/ (所见即所得的在线HTML编辑器)
XmlBuddy http://www.xmlbuddy.com/ (XML Editor plugin for Eclipse)
JFreeChart http://www.jfree.org/ (用于生成图表的项目)
EclipseME http://eclipseme.sourceforge.net/ (J2ME Developmnt Plugin for Eclipse)
mvnForum http://sourceforge.net/projects/mvnforum/ (论坛)
jChatBox http://www.javazoom.net/index.shtml (用servlet实现的WEB聊天引擎)
POI http://jakarta.apache.org/poi/index.html (用于处理Excel,WORD等文档的项目)
FileUpload http://jakarta.apache.org/commons/fileupload/ (用于处理HTTP文件上传得项目)
PDFBox http://sourceforge.net/projects/pdfbox/ (处理PDF文档的项目)
Lucene http://jakarta.apache.org/lucene/index.html (搜索引擎)
Digester http://jakarta.apache.org/commons/digester/ (处理XML信息的项目)
DBCP http://jakarta.apache.org/commons/dbcp/ (数据库连接池)
AXIS http://ws.apache.org/axis/ (WebService 的实现框架)
Jetspeed http://portals.apache.org/jetspeed-1/ (Portal)
HSQLDB http://sourceforge.net/projects/hsqldb/ (Im memory Database Engine)
CEWOLF http://sourceforge.net/projects/cewolf/(一套标签库实现Web报表,使用的是jFreeChart擎)
Struts Menu http://sourceforge.net/projects/struts-menu/ (基于Struts的Web菜单项目)
htmlparser http://sourceforge.net/projects/htmlparser/ (用于解析HTML信息的项目)
Mondrian http://sourceforge.net/projects/mondrian/ (Open Source OLAPdatabase)
ProGuard http://sourceforge.net/projects/proguard/ (Java的混淆器)
InfoGlue http://sourceforge.net/projects/infoglue/ (J2EE 内容管理系统)
JPivot http://sourceforge.net/projects/jpivot/ (基于WEB的OLAP 展现)
HttpClient http://jakarta.apache.org/commons/httpclient/ 处理http客户端的接口

草儿 2007-08-25 23:16 发表评论

JavaFX编程语言基础

草儿 — Thu, 16 Aug 2007 16:39:00 GMT

摘要: JavaFX Script™ （下文中成为JavaFX）语言是一种声明式的静态类型编程语言。它具有第一级函数（first-class functions）、声明式的语法、列表推导（list-comprehensions）及基于依赖关系的增量式求值（incremental dependency-based evaluation）等特征。JavaFX 脚本式语言特别适用于Java2D ... 阅读全文

草儿 2007-08-17 00:39 发表评论

深入学习JavaFX脚本语言-參考

草儿 — Thu, 16 Aug 2007 16:36:00 GMT

摘要: Translated by Liu Dan (cleverpig) and Tian Le (Tin) 本文档将讨论在JavaFX语言中可用的各种GUI组件，并提供示例代码，讨论JavaFX组件与Swing GUI组件相比的差异。前提条件如果你从前没有阅读过JavaFX脚本语言起步教程，那么我们强烈推荐你在继续阅读本文档之前首先阅读JavaFX脚本语言起步教程。你应该具有熟... 阅读全文

草儿 2007-08-17 00:36 发表评论

访问内存中JDBC驱动信息的小程序

草儿 — Mon, 13 Aug 2007 03:43:00 GMT

在你同内存中多个JDBC驱动打交道的过程中，你可以访问更多的有关JDBC驱动的信息。下面是是访问这些内容的参考代码：

import java.sql.*;
import java.util.*;

public class drvinf{

public static void main(String[] args)
  {
  
  //绑定属性文件
  ResourceBundle bundle = ResourceBundle.getBundle("START");
  Connection conn=null;
  String drv=null;
  String url=null;

  //加载JDBC 驱动
 try{
     drv = bundle.getString("Driver");
     Class.forName(drv);
     }catch (ClassNotFoundException e)
       {System.out.println(e.getMessage());}

  //JDBC URL=jdbc:odbc:bank
  try{
     url = bundle.getString("jdbcURL");
     conn = DriverManager.getConnection(url);

     List drvs = Collections.list(DriverManager.getDrivers());
     for (int i=0; i       {
       System.out.println("----------------打印有关驱动的信息------------");
       Driver driver = (Driver)drvs.get(i); 
       String name = driver.getClass().getName(); 
       System.out.println(name);
       int maxV = driver.getMajorVersion();
       System.out.println(maxV); 
       int minV = driver.getMinorVersion();
       System.out.println(minV); 
       boolean comp = driver.jdbcCompliant();
       System.out.println(comp); 
       }    
    }catch (SQLException e)
    {System.out.println(e.getMessage());}
       try{
          if(conn!=null)conn.close();
          }catch(SQLException e)    
               {System.out.println(e.getMessage());} 
    }
}

START.properties 中的内容：


Driver=sun.jdbc.odbc.JdbcOdbcDriver
jdbcURL=jdbc:odbc:bank
login=admin
password=hashflush

草儿 2007-08-13 11:43 发表评论

如何在Java中使用Robot类

草儿 — Thu, 09 Aug 2007 06:59:00 GMT

Java.awt.Robot 类用于控制鼠标和键盘。一旦你得到这种控制，你能够通过你的Java代码做与
鼠标和键盘任何类型的操作.这个类通常用于自动化测试。先面的代码样例将向您展示Robot
类如何处理键盘事件。如果你运行此代码，并打开notepad，您将在notepad中看到HI CAOER。赶快试一试吧。
import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class RobotExp {

public static void main(String[] args) {

try {

Robot robot = new Robot();
//定义5秒的延迟以便你打开notepad 哈哈
// Robot 开始写
robot.delay(5000);
robot.keyPress(KeyEvent.VK_H);
robot.keyPress(KeyEvent.VK_I);
robot.keyPress(KeyEvent.VK_SPACE);
robot.keyPress(KeyEvent.VK_C);
robot.keyPress(KeyEvent.VK_A);
robot.keyPress(KeyEvent.VK_O);
robot.keyPress(KeyEvent.VK_E);
robot.keyPress(KeyEvent.VK_R);

} catch (AWTException e) {
e.printStackTrace();
}
}
}

草儿 2007-08-09 14:59 发表评论

JavaFX入门教程二

草儿 — Thu, 09 Aug 2007 05:36:00 GMT

摘要: 原作者： Anghel Leonard时间：08/01/2007翻译：Caoer2007年8月8日 JavaFX 代码同Java代码极容易集成. 这有一个使用JavaFX装载一个图片到窗体例子，它允许使用者选择一个矩形区域保存这个矩形区域。这个捕捉保存操作由Java代码完成。源码列表 15 import java.io.*; import javafx.ui.*; import jav... 阅读全文

草儿 2007-08-09 13:36 发表评论

JavaFX入门教程一

草儿 — Tue, 07 Aug 2007 03:49:00 GMT

原作者： Anghel Leonard
时间：08/01/2007
翻译：Caoer
2007年8月5日

什么是JavaFX？SUN（太阳公司）在2007年春天发布了一个叫JavaFX新框架。这是一个泛泛的名字，因为JavaFX主要包含Script and Mobile两个组件，在将来SUN将开发更多的组件。

JavaFX 的核心是 JavaFX 脚本，是一个声明式脚本语言。尽管同Java代码非常不同，但是同Java类具有很高的交互度。 JavaFX 中的很多类主要为了更容易实现Swing和Java2D而设计的。使用 JavaFX 脚本，您能很容易的为文本和图形开发GUI接口、动画和非常COOL的效果。并且，您能将Java和HTML代码包装到 JavaFX 脚本中。

第二个组件- JavaFX Mobile，是为移动设备开发Java应用的平台。它最终会成为开发 JavaFX 脚本的平台但是现在同这篇文章实用的技术还很不兼容。

JavaFX 应用的一些例子

在开始学习一门新的语言前，让我们先看一下JavaFX代码的一些例子。JavaFX 官方站点具有大量的JavaFX 实例。请点击JavaFX Script 2D Graphics Tutorial下载该实例. 下载完成以后，双击tutorial.jnlp 文件即可运行。几秒过后，你应该能够看到如图一的JavaFX实例运行场景（若没有出现该图片，你必须为.jnlp扩展名重新配置Java Web Start）。

图一、运行 tutorial.jnlp tutorial

花些时间看一看这些例子和源代码。仅仅使用有限的几行JavaFX代码就能得到很多有趣的效果。如果你对于JavaFX的应用还是感到摸不着头脑，看一看下面的两个demo。它们是StudioMoto 和 Tesla Motors 站点的部分重新实现。您可以从OpenJFX 项目站点下载OpenJFX 脚本Studiomoto Demo 和 Tesla Demo。它们需要Java Web Start 才能运行，但是也取决于你的机器配置它们可能自动运行，或者你必须找到和运行已经下载的.jnlp文件。

下载安装JavaFX

如果你对于学习开发JavaFX应用程序，您应该了解至少使用JavaFX三个方法。同时了解JavaFX应用程序不是基于浏览器的也很重要。最简单最快捷的方法是基于叫JavaFXPad轻量级的工具。使用该工具的主要优势是你总能立即看到你在编辑器里所作更改的效果。你能从JavaFX项目网站下载到该工具（ JavaFXPad ）。并且运行它需要Java Web Start （如图二）。

图二、运行JavaFXPad编辑器

使用JavaFX的另一种方式是使用JavaFX脚本NetBeans 5.5插件或者Eclipse 3.2插件（需要下载和安装NetBeans 5.5 或者 Eclipse 3.2.2以上集成开发工具 ）。若您已经使用 NetBeans 5.5开始你的JavaFX之旅,OpenJFX项目网站的对于NetBean开发JavaFX的说明将会给予你帮助。 相似的如果您使用基于Eclipse的JavaFX插件，您可以去JavaFX的Eclipse插件。注意这篇文章中的所有例子已经在NetBeans5.5的JavaFX插件中测试过，但是应该能够使用其他方法运行。

使用NetBeans 5.5下的JavaFX插件开发Hello World 程序

每当开始学习一门新的语言时，我们必定要写Hello World 小程序：

源码列表1

import javafx.ui.*;

import java.lang.System;

Frame {

centerOnScreen: true

visible: true

height: 50

width: 350

title: "HelloWorld application..."

background: yellow

onClose: operation() {System.exit(0);}

content: Label {

text: "Hello World"

}

在NetBeans5.5开发和运行这个小程序步骤如下:

1. 启动NetBeans 5.5.

2. 从主菜单选择File -> New Project.

3. 在新项目窗口,选择目录常规目录和 Java 应用项目(点击下一步).

4. 在新的Java应用程序窗口,在项目名文本框敲入 "FXExample".

5. 在相同窗口，用浏览按钮选择项目的目录.

6. 取消 "Set as main project" 和 "Create main class" 复选框 (点击完成).

7. 右击FXExample -> Source Packages 和选择 New -> File/Folder.

8. 在新的文件窗口，选择另一个目录和JavaFX文件类型（点击下一步）.

9. 在新的JavaFX文件窗口，敲入"HelloWorld" 作为文件名和"src"作为目录(点击完成).

10. 拷贝源码列表1到 HelloWorld.fx.

11. 右击FXExample 项目选择项目属性.

12. 在项目FXExample属性对话框 ,选择从目录面板运行节点.

13. 在参数文本框敲入 "Hello World" (点击完成).

14. 右击FXExample 项目选择运行项目选项.

如果一切良好,你应该看到一个窗体如图三：

图三、 在NetBeans 5.5中运行 Hello World 应用程序

现在你拥有了开发和运行任何JavaFX应用程序的IDE软件支持.

JavaFX 语法

在正式开始学习JavaFX，让我们浏览一遍该语言的语法要点。如果你非常熟悉Java语言，这些语法的大多数会让你感到非常熟悉，但是有一些会相当不一样。

JavaFX 原始类型

JavaFX 支持原始类型：String (对应于 java.lang.String), Boolean (对应于 java.lang.Boolean), Number (对应于 java.lang.Number) 和 Integer (对应于 byte,short,int,long,BigInteger).

JavaFX 变量

一个JavaFX变量使用var关键字声明。看下面的例子：

var x:Number = 0.9;

var name:String = "John";

var y:Integer = 0;

var flag:Boolean = true;

var numbers:Number = [1,2,3,4,5]；

JavaFX 操作符

众所周知的Java操作符&&, || 和 ! 在JavaFX中采用下面的形式：

· Java: &&
JavaFX: and

· Java: ||
JavaFX: or

· Java: !
JavaFX: not

JavaFX 方法

JavaFX 支持这些方法. 具有参数、变量声明和返回值的方法举例：

function taxes(x) { var t:Number = (19.0/100.0)*x; return t; }

JavaFX if 语句

在JavaFX中，你你能通过使用if语句使用条件判断。

if (条件) { //动作 } else if (条件) { //动作 } else { //动作 }

JavaFX while 语句

这个 while 语句同在Java中的while语句相似。 while (条件) { //动作}

JavaFX for 语句

for 语句用于循环和间隔（间隔使用方括号[]和 .. 符号表示).

//i 将取值： 0, 1, 2, 3, 4, 5象在 (i in [0..5]) { //伴随 i的动作 }代码块中

JavaFX 过程

JavaFX 过程以operation 关键字为标志。一个简单的例子：

operation startClock() {do{ while(true) {

if(seconds>=360) {seconds = 0; seconds = [0,6..360] dur 60000 linear;}

if(minutes>=360) {minutes = 0; minutes = [0,6..360] dur 3600000 linear;}

if(hours>=360) {hours = 0; hours = [0,6..360] dur 43200000 linear;} } }}

JavaFX 类

JavaFX 类使用class关键字. 一个 JavaFX 类能够使用extends 关键字继承多个类使用逗号分割
这些类的名字。在花括号中间你可以放属性、方法和过程，例如下面的例子：

class Order {

attribute order_nr: String;

attribute ordertype: Order inverse Order.products;

attribute products: Order* inverse Order.ordertype;

function getOrderNr(): String;

operation addOrder(order: Order);

}

注意属性使用attribute关键字声明，方法体和过程不在类体中，它们单元定义在类声明以后，在下文你很快就能看到。 inverse 子句是一个可选项 ，它表示一种同在类中另一个属性的双向关系。在这个案例中JavaFX将自动完成更新（插入、替代和删除）你能在Java.net上找到更完整的文档。

熟悉JavaFX

在本小节，您将会看到一系列的小例子，这些例子覆盖JavaFX的各种特性和功能。主要目的是让你熟悉JavaFX代码和JavaFX应用程序的逻辑。第二个目标是当你需要开发仅仅需要几行代码就会有非常酷的GUI，动画和好的效果时候使你确信JavaFX值得好好研究一下。所有列出的例子将介绍关于JavaFX的技巧。每一个例子只使用很少的描述处理，所以不要想找到大量的注释。所有这些可访问的例子你都是你自己就能运行的，所以让我们开始吧。当我们需要使用System.out.println 打印属性值时候，你可以把它的名字放进含有引用的字符串，象源码列表2中所示的那样。

源码列表2

//带有应用文本的表达式

import java.lang.System;
var mynumber:Number = 10;
System.out.println("数字是: {mynumber}");

结果: 数字是: 10
JavaFX 支持变量的计数这样一个有用的功能。这个功能利用下面的三个操作符实现：

· ?: 可选的(可能为 null)

· +: 1或多个

· *: 0或多个

源码列表3

//变量计数

import java.lang.System;
var mynumbers:Number* = [1,2,7];
System.out.println("数字是: {mynumbers}");

结果: 数字是: 1 2 7
在JavaFX中, 在声明部分不指定变量的类型是可能的。 这不会产生错误，因为JavaFX 将在该变量的使用中自动发现它的类型。

源码列表 4

//变量类型是可选的

import java.lang.System;
var days = ["Monday,","Friday,","Sunday"];
System.out.println("你必须工作: {days}");

结果: 你必须工作: Monday, Friday, Sunday
你可以使用sizeof 操作符得到一个数组的大小：

源码列表 5

//得到一个数组的大小

import java.lang.System;
var lotto = [21,30,11,40,5,6];
System.out.println("数组大小:{sizeof lotto}");

结果: 数组大小: 6

您能使用 [] 操作符得到满足指定条件的子数组。条件放在 [] 中作为布尔判断 。这个与XPath 谓词相似.

源码列表 6

//使用[] 操作符 -与 XPath相似

import java.lang.System;
var mynumbers = [1,2,7,3,30,15,14,6,4];
var numbers = mynumbers[n|n < 10];
System.out.println("小于10的数字为: {numbers}");

结果: 小于10的数字为: 1 2 7 3 6 4
你可以使用indexof 操作符得到指定序数位置的数组中一个元素：

源码列表 7

//返回指定序数位置的数组中的元素

import java.lang.System;

var mynumbers = [1,2,7,3,30,15,14,6,4];
var number_four = mynumbers[indexof . == 4];
System.out.println("数字4:{number_four}");

结果: 数字4: 30

当您想要向一个数组中插入一个元素时，你可以使用下列 insert 语句中的一个:

· as first: 在第一个位置插入

· as last:在最后一个位置(默认)插入

· before: 在前一个位置插入

· after:在下一个位置插入

你可以使用 delete 语句从一个数组中删除一个元素.

源码列表8

//插入和删除语句
import java.lang.System;
var mynumbers = [1,2,7];
System.out.println("Before inserting anything: {mynumbers}");
insert 10 into mynumbers;
System.out.println("After inserting at the end the \"10\" value:{mynumbers}");
insert [8,6,90] as first into mynumbers;
System.out.println("After inserting at the first positions the \"8,6,90\" values:{mynumbers}");
insert 122 as last into mynumbers;
System.out.println("After inserting at the end the \"122\" value:{mynumbers}");
insert 78 before mynumbers[3];
insert 11 after mynumbers[3];
System.out.println("After inserting the \"78\" and \"11\" values before/after the 3rd element:{mynumbers}");
delete mynumbers[. == 122];
System.out.println("After deleting:{mynumbers}");

结果:
Before inserting anything: 1 2 7
After inserting the 10 value at the end: 1 2 7 10
After inserting the 8, 6, and 90 values at the first positions: 8 6 90 1 2 7 10
After inserting the 122 value at the end: 8 6 90 1 2 7 10 122
After inserting the 78 and 11 values before/after the 3rd element: 8 6 90 78 11 1 2 7 10 122
After deleting: 8 6 90 78 11 1 2 7 10

JavaFX中的一个非常好的功能是list。这个功能使用 select 和 foreach 操作符实现。这有两个例子（一个使用 select 和使用 foreach) 得到指定间隔的奇数。

源码列表9

//JavaFX中的 select 和 foreach 操作符

import java.lang.System;
function odd(p:Number)
{ return select i from i in [1.0 ..p]
where (i%2 == 0.0);
}

var result = odd(10.0);
System.out.println("Odd numbers:{result}");

结果: Odd numbers: 2.0 4.0 6.0 8.0 10.0

源码列表10 (同 源码列表 9相同, 但是有 foreach)

//JavaFX中的select 和 foreach 操作符

import java.lang.System;
function odd(p:Number) {
       return foreach (i in [1.0 ..p]
     where (i%2 == 0.0)) i;
     }
var result = odd(10.0);
System.out.println("Odd numbers:{result}");

这个例子显示了 foreach 对于创建好的效果非常有用。

源码列表11

//JavaFX中的 select 和 foreach 操作符

import java.lang.*;
import javafx.ui.*;
import javafx.ui.canvas.*;
Frame {
centerOnScreen: true
visible: true
height: 500
width: 500
title: "Foreach demo..."
onClose: operation() {
System.exit(0);
}
content: ScrollPane {
background: white
view: Canvas {
content: bind
foreach (i in [1..8], j in [1..8])
Rect { x: i*30 y: j*30 width:30 height:30 fill: Color {red: (100+i) green: (100+j) blue: (100+(i*j))
}
stroke:white
strokeWidth:1 } }

}

图四. 运行源码列表 11

使用双箭头括号引用为JavaFX关键字的变量名或者属性名，如下所示。

源码列表 12

//标志符引用

import java.lang.System;

for (<> in [0..3]) {

System.out.println("for = {<>}");

}

结果: for = 0 for = 1 for = 2 for = 3

当你需要开发Swing接口时，JavaFX 是一个伟大的工具，因为 JavaFX 考虑了非常多用来降低代码量和同javax.swing.*包并存友好。在上一节（使用NetBeans5.5中的JavaFX插件测试Hello World应用程序），你看到了创建一个窗体是如何容易。这有两个更好的例子：创建按钮和文本框。

源码列表 13

import javafx.ui.*;

import java.lang.System;

Frame{

content: Button { text: "Exit" action: operation() { System.exit(0); } }

visible: true

}

图五. 运行源码 13

源码列表14

import javafx.ui.*;

Frame {

content: GroupPanel { var myRow = Row { alignment: BASELINE }

var label_col = Column { alignment: TRAILING }

var field_col = Column { alignment: LEADING }

rows: [myRow] columns: [label_col, field_col]

content: [SimpleLabel { row: myRow column: label_col text: "Type your text here:" }, TextField { row: myRow column: field_col columns: 50 }] }

visible: true

};

图六. 运行源码 14

Java.net 也有使用JavaFx创建 Swing接口的教程。

草儿 2007-08-07 11:49 发表评论

基于Struts1.2.9框架的登录页面的处理过程

草儿 — Fri, 03 Aug 2007 03:36:00 GMT

Struts Web框架是现在构建Web应用必须的开发框架之一。以下是我们学习Struts框架时通常都会看到的登录页面程序的处理流程分析，希望和广大博友交流：

基于Struts框架登录程序应用的UML顺序图

处理步骤：

1、客户从浏览器客户端向Web服务器发出请求，服务器将请求转发到Web容器，比如：Tomcat；根据请求路径URL找到ActionServlet，Web容器调用Servlet的servic()方法，根据请求参数的不同调用doGet()或者doPost()方法。

2、而ActionServlet的doGet()或者doPost()方法调用process()方法处理请求和响应，生成RequestProcess对象处理配置文件struts-config.xml中的配置信息，依次调用processMapping()-查找处理此次请求的Action信息并返回ActionMapping对象；processActionForm()--创建此次请求的ActionForm对象；processActionCreate()--创建处理此次请求的Action实例（LoginAction对象）；processActionPerform()--执行Action实例的execute()方法。

3、通过调用execute()方法获取LoginForm存储的用户和密码等数据信息，其中将ActionForm Bean、ActionMapping、request、response对象传递给LoginAction对象（Action实例）；执行完必要的逻辑处理比如查询数据库后，返回一个ActionForward对象，由该对象调用RequestProcess对象中的processForwardConfig()方法解析配置文件中跳转参数，转发到相应的View页面success.jsp或者failure.jsp。

草儿 2007-08-03 11:36 发表评论

JSP在TOMCAT中的处理生命周期

草儿 — Sat, 14 Jul 2007 06:43:00 GMT

1、将WEB应用部署到TOMCAT容器，容器启动读取应用的部署文件web.xml,但不对.jsp文件做任何处理请求。

2、客户点击连接请求某个.jsp文件，容器开始将.jsp文件转换为一个servrlet类的.java源代码。查看指令，得到转换的可能需要的信息。创建一个HttpServlet子类，对于Tomcat5所生成的servlet会扩展org.apache.jasper.runtime.HttpJspBase类。若有一个page指令有import属性，生成的类文件的最上面会写入import语句。例如在Tomcat5中加入包语句：package org.apache.jsp；若有声明容器将这些声明写道类文件，通常放在服务方法的下面。Tomca5声明了自己的一个静态方法和一个实例方法。然后建立服务方法，方法名为_jspService()。所生成的servlet会覆盖servlet超类的service()方法。_jspService()直接由service()调用，要接收HttpServletRequest和HttpServletResponse参数。在建立这个方法的时候，容器会声明并初始化所有的隐式对象。将普通的HTML（模板文件）、scrptlet和表达式放到服务方法里，进行格式化，并写至PrintWrite响应输出。

3、容器尝试将这个servlet.java源文件编译为.class文件。

4、容器家在新生成的servlet类。

5、容器实例化servlet，并导致servlet的jspInit()方法运行。对象现在已成为一个完整的servlet准备就绪，接受客户的请求。

6、容器创建一个新线程来处理客户请求，servlet的service()方法运行。以后的处理同普通的servlet处理过程。最终servlet向客户返回一个响应。

需要注意的是：在JSP生命周期中，JSP的转换和编译过程只发生一次。一旦第一次编译完成，以后的调用同普通的servlet一样。大多数容器开发商提供预转化和编译的办法，是这些工作提前完成。

草儿 2007-07-14 14:43 发表评论

一个Servlet生命周期（Tomcat处理请求中）

草儿 — Sat, 07 Jul 2007 08:04:00 GMT

从Tomcat处理用户请求，我们可以清晰的看到容器Servlet的生命周期管理过程：
1、客户发出请求—>Web 服务器转发到Web容器Tomcat；
2、Tomcat主线程对转发来用户的请求做出响应创建两个对象：HttpServletRequest和HttpServletResponse；
3、从请求中的URL中找到正确Servlet，Tomcat为其创建或者分配一个线程，同时把2创建的两个对象传递给该线程；
4、Tomcat调用Servlet的servic()方法，根据请求参数的不同调用doGet()或者doPost()方法；
5、假设是HTTP GET请求，doGet()方法生成静态页面，并组合到响应对象里；
6、Servlet线程结束，Tomcat将响应对象转换为HTTP响应发回给客户，同时删除请求和响应对象。
从该过程中，我们可以理解Servlet的生命周期：Servlet类加载（对应3步）；Servlet实例化（对应3步）；调用init方法（对应3步）；调用service()方法（对应4、5步）；；调用destroy()方法（对应6步）。

草儿 2007-07-07 16:04 发表评论

Adobe Flex2

草儿 — Fri, 06 Jul 2007 02:59:00 GMT

Flex2应用程序在无所不在的轻量级虚拟机Flash播放器9跨平台运行。该平台包括以下技术：
1、一种基于XML的MXML语言，它支持面对设计者的GUI组件声明式编程；
2、标准的OOP语言，基于最新的ECMASript规范的AS3；
3、使用FDS（Flex Data Services）方式进行服务端集成，是客户端程序能够对J2EE世界透明访问；
4、图表组件；
5、基于Eclipse功能强大的IDE，拥有自动化部署，调试，代码跟踪能力。
Flex2平台易于扩展也对服务端技术例如JAVA，ColdFusion，PHP，Ruby，ASP等等实现集成。即将发布的Adobe Apollo版允许基于Flash Player，Flex，PDF和HTML桌面程序的构建。
SWF文件格式是开放的，有第三方开源产品象Laszlo系统的OpenLaszlo为构建RIA程序提供工具，程序使用Flash Player发布。
与上一个版本相反，Flex2提供一种不会招致授权协议纠纷而构建RIA的方式。以下都免费得到：
1、MXML：基于XML声明式用来构建GUI的编程语言；
2、ActionScript3.0：与JAVA相似的OOP语言；
3、Flash Player9：运行在WEB浏览器占有很少内存的虚拟机，运行你编译的二进制代码（.SWF）;
4、命令行编译器和调试器；
5、Flex 框架：包含设计良好的GUI组件库：按钮，tab目录，数据网格，树控制，动画效果等等很多。
6、Flex数据服务预览版：部署在J2EE服务器WEB程序与运行在Flash Player上的ActionScript客户端程序通信模板。FDS预览版只能运行在单CPU上并且不支持在（24*7）高可访问性配置模式下使用。

构建一个基本的Flex2程序步骤有：
1、通过增加XML组件例如下面按钮来构建这个程序：

若使用收费的开发工具Flex Builder IDE，你就可以使用拖拉技术了。当然，你也可以手写MXML文本。
2、写按照业务逻辑ActionScript代码，例如：
private function processOrder (event:Event):void{
//业务逻辑代码
}
3、编译代码。Flex编译器自动的把MXML转换为ActionScript代码并以SWF格式字节码输出在Flash Player 9或者更高版本运行，如果你用Flex Builder IDE，你将得到更爽的自动化编译过程。
4、在你选择的WEB服务器中部署SWF文件和封装好的HTML页面。如果你用收钱的那个工具，这些过程完全透明。
有一个在线Flex编译器网站，你可以试着写一些Flex代码而不用在你自己的电脑上安装任何东西。同时该网站提供了一些示例代码供您修改和运行。还等什么，GO：http://try.flex.org/

草儿 2007-07-06 10:59 发表评论

JDOM简介

草儿 — Mon, 25 Jun 2007 10:33:00 GMT

JDOM是一种使用 XML 的独特 Java 工具包，用于快速开发 XML 应用程序。它的设计包含 Java 语言的语法乃至语义。

JDOM是两位著名的 Java 开发人员兼作者，Brett Mclaughlin 和 Jason Hunter 的创作成果， 2000 年初在类似于 Apache 协议的许可下，JDOM 作为一个开放源代码项目正式开始研发，JDOM 作为一个开放源代码项目正式开始了。它已成长为包含来自广泛的 Java 开发人员的投稿、集中反馈及错误修复的系统，并致力于建立一个完整的基于 Java 平台的解决方案，通过 Java 代码来访问、操作并输出 XML 数据。

虽然许多Java 开发人员每天都在使用 XML，Sun 却在将 XML 整合进 Java 平台方面落后了。因为在 XML 成为从商家对商家集成到 Web 站点内容流水化等方面的关键技术之前，Java 2 平台就已经非常流行了。Sun 已经使用 JSR 过程使之成为现存 XML API 的鼻祖，这一点已被广泛接受。目前最显著的是加入了 JAXP （用于 XML 语法分析的 Java API），其中包含了三个软件包：

      ·org.w3c.dom ，W3C 推荐的用于 XML 标准规划文档对象模型的 Java 工具
      ·org.xml.sax ，用于对 XML 进行语法分析的事件驱动的简单 API
      ·javax.xml.parsers ，工厂化工具，允许应用程序开发人员获得并配置特殊的语法分析器工具 JDOM 能够替换 org.w3c.dom 软件包来有计划地操作 XML 文档

JDOM是一个开源项目，它基于树型结构，利用纯JAVA的技术对XML文档实现解析、生成、序列化以及多种操作。

JDOM 直接为JAVA编程服务。它利用更为强有力的JAVA语言的诸多特性（方法重载、集合概念以及映射），把SAX和DOM的功能有效地结合起来。

Jdom是用Java语言读、写、操作XML的新API函数。Jason Hunter 和 Brett McLaughlin公开发布了它的1.0版本。在直觉、简单和高效的前提下，这些API函数被最大限度的优化。在接下来的篇幅里将介绍怎么用Jdom去读写一个已经存在的XML文档。

在使用设计上尽可能地隐藏原来使用XML过程中的复杂性。利用JDOM处理XML文档将是一件轻松、简单的事。

JDOM 在2000年的春天被Brett McLaughlin和Jason Hunter开发出来，以弥补DOM及SAX在实际应用当中的不足之处。

这些不足之处主要在于SAX没有文档修改、随机访问以及输出的功能，而对于DOM来说，JAVA程序员在使用时来用起来总觉得不太方便。

DOM的缺点主要是来自于由于Dom是一个接口定义语言（IDL）,它的任务是在不同语言实现中的一个最低的通用标准，并不是为JAVA特别设计的。JDOM的最新版本为JDOM Beta 9。最近JDOM被收录到JSR-102内，这标志着JDOM成为了JAVA平台组成的一部分。

在 JDOM 中，XML 元素就是 Element 的实例，XML 属性就是 Attribute 的实例，XML 文档本身就是 Document 的实例。

因为 JDOM 对象就是像 Document、Element 和 Attribute 这些类的直接实例，因此创建一个新 JDOM 对象就如在 Java 语言中使用 new 操作符一样容易。JDOM 的使用是直截了当的。

JDOM 使用标准的 Java 编码模式。只要有可能，它使用 Java new 操作符而不故弄玄虚使用复杂的工厂化模式，使对象操作即便对于初学用户也很方便。

一、JDOM包概览

JDOM是由以下几个包组成的

org.jdom包含了所有的xml文档要素的java类
org.jdom.adapters包含了与dom适配的java类
org.jdom.filter包含了xml文档的过滤器类
org.jdom.input包含了读取xml文档的类
org.jdom.output包含了写入xml文档的类
org.jdom.transform包含了将jdomxml文档接口转换为其他xml文档接口
org.jdom.xpath包含了对xml文档xpath操作的类

二、JDOM类说明

1、org.JDOM这个包里的类是你J解析xml文件后所要用到的所有数据类型。

Attribute
CDATA
Coment
DocType
Document
Element
EntityRef
Namespace
ProscessingInstruction
Text

2、org.JDOM.transform在涉及xslt格式转换时应使用下面的2个类

JDOMSource
JDOMResult
org.JDOM.input

3、输入类，一般用于文档的创建工作

SAXBuilder
DOMBuilder
ResultSetBuilder

4、org.JDOM.output输出类，用于文档转换输出

XMLOutputter
SAXOutputter
DomOutputter
JTreeOutputter

使用前注意事项：

1.JDOM对于JAXP以及TRax的支持

JDOM支持JAXP1.1：你可以在程序中使用任何的parser工具类,默认情况下是JAXP的parser。
制定特别的parser可用如下形式
SAXBuilderparser
=newSAXBuilder("org.apache.crimson.parser.XMLReaderImpl");
Documentdoc=parser.build("http://www.cafeconleche.org/");
//workwiththedocument...
JDOM也支持TRaX：XSLT可通过JDOMSource以及JDOMResult类来转换（参见以后章节）

2.注意在JDOM里文档（Document）类由org.JDOM.Document来表示。这要与org.w3c.dom中的Document区别开，这2种格式如何转换在后面会说明。
以下如无特指均指JDOM里的Document。

三、JDOM主要使用方法

1.Ducument类

(1)Document的操作方法：

Elementroot=newElement("GREETING");
Documentdoc=newDocument(root);
root.setText("HelloJDOM!");
或者简单的使用Documentdoc=newDocument(newElement("GREETING").setText("HelloJDOM!t"));
这点和DOM不同。Dom则需要更为复杂的代码，如下：
DocumentBuilderFactoryfactory=DocumentBuilderFactory.newInstance();
DocumentBuilderbuilder=factory.newDocumentBuilder();
Documentdoc=builder.newDocument();
Elementroot=doc.createElement("root");
Texttext=doc.createText("Thisistheroot");
root.appendChild(text);
doc.appendChild(root);
注意事项：JDOM不允许同一个节点同时被2个或多个文档相关联，要在第2个文档中使用原来老文档中的节点的话。首先需要使用detach()把这个节点分开来。

(2)从文件、流、系统ID、URL得到Document对象：

DOMBuilderbuilder=newDOMBuilder();
Documentdoc=builder.build(newFile("jdom_test.xml"));
SAXBuilderbuilder=newSAXBuilder();
Documentdoc=builder.build(url);
在新版本中DOMBuilder已经Deprecated掉DOMBuilder.builder(url)，用SAX效率会比较快。
这里举一个小例子，为了简单起见，使用String对象直接作为xml数据源：
PublicjdomTest(){
StringtextXml=null;
textXml="";
textXml=textXml+
"aaabbbcccddd";
textXml=textXml+"";
SAXBuilderbuilder=newSAXBuilder();
Documentdoc=null;
Readerin=newStringReader(textXml);
try{
doc=builder.build(in);
Elementroot=doc.getRootElement();
Listls=root.getChildren();//注意此处取出的是root节点下面的一层的Element集合
for(Iteratoriter=ls.iterator();iter.hasNext();){
Elementel=(Element)iter.next();
if(el.getName().equals("to")){
System.out.println(el.getText());
}
}
}
catch(IOExceptionex){
ex.printStackTrace();
}
catch(JDOMExceptionex){
ex.printStackTrace();
}
}
(3)DOM的document和JDOM的Document之间的相互转换使用方法，简单！
DOMBuilderbuilder=newDOMBuilder();
org.jdom.DocumentjdomDocument=builder.build(domDocument);
DOMOutputterconverter=newDOMOutputter();//workwiththeJDOMdocument…
org.w3c.dom.DocumentdomDocument=converter.output(jdomDocument);
//workwiththeDOMdocument…

2.XML文档输出

XMLOutPutter类：
JDOM的输出非常灵活,支持很多种io格式以及风格的输出
Documentdoc=newDocument(...);
XMLOutputteroutp=newXMLOutputter();
outp.output(doc,fileOutputStream);//Rawoutput
outp.setTextTrim(true);//Compressedoutput
outp.output(doc,socket.getOutputStream());
outp.setIndent("");//Prettyoutput
outp.setNewlines(true);
outp.output(doc,System.out);
详细请参阅最新的JDOMAPI手册

3.Element类：

(1)浏览Element树
Elementroot=doc.getRootElement();//获得根元素element
ListallChildren=root.getChildren();//获得所有子元素的一个list
ListnamedChildren=root.getChildren("name");//获得指定名称子元素的list
Elementchild=root.getChild("name");//获得指定名称的第一个子元素
JDOM给了我们很多很灵活的使用方法来管理子元素（这里的List是java.util.List）
ListallChildren=root.getChildren();
allChildren.remove(3);//删除第四个子元素
allChildren.removeAll(root.getChildren("jack"));//删除叫“jack”的子元素
root.removeChildren("jack");//便捷写法
allChildren.add(newElement("jane"));//加入
root.addContent(newElement("jane"));//便捷写法
allChildren.add(0,newElement("first"));

(2)移动Elements:
在JDOM里很简单
Elementmovable=newElement("movable");
parent1.addContent(movable);//place
parent1.removeContent(movable);//remove
parent2.addContent(movable);//add
在Dom里
Elementmovable=doc1.createElement("movable");
parent1.appendChild(movable);//place
parent1.removeChild(movable);//remove
parent2.appendChild(movable);//出错!
补充：纠错性
JDOM的Element构造函数（以及它的其他函数）会检查element是否合法。
而它的add/remove方法会检查树结构，检查内容如下：
1.在任何树中是否有回环节点
2.是否只有一个根节点
3.是否有一致的命名空间（Namespaces）

(3)Element的text内容读取

Acooldemo

//Thetextisdirectlyavailable
//Returns"\nAcooldemo\n"
Stringdesc=element.getText();
//There'saconvenientshortcut
//Returns"Acooldemo"
Stringdesc=element.getTextTrim();
(4)Elment内容修改
element.setText("Anewdescription");
3.可正确解释特殊字符
element.setText("

四、JDOM的应用

（一）、XML文档创建

我们由零开始利用JDOM生成一个XML文档。最后的结果(样本文档)看起来象这样：

kingwong

87654321

1.以 MyInfo 为根元素创建文档

Element rootElement = new Element("MyInfo");//所有的XML元素都是 Element 的实例。根元素也不例外：）
Document myDocument = new Document(rootElement);//以根元素作为参数创建Document对象。一个Document只有一个根，即root元素。

2.给根元素添加属性

Attribute rootAttri = new Attribute("comment","introduce myself");//创建名为 commnet,值为 introduce myself 的属性。
rootElement.setAttribute(rootAttri);//将刚创建的属性添加到根元素。
这两行代码你也可以合成一行来写，象这样：
rootElement.setAttribute(new Attribute("comment","introduce myself"));
或者
rootElement.setAttribute("comment","introduce myself");

3.添加元素和子元素

JDOM里子元素是作为 content（内容）添加到父元素里面去的,所谓content就是类似上面样本文档中之间的东东，即kingwong。罗嗦了点是吧：）
Element nameElement = new Element("name");//创建 name 元素
nameElement.addContent("kingwong");//将kingwong作为content添加到name元素
rootElement.addContent(nameElement);//将name元素作为content添加到根元素

这三行你也可以合为一句，象这样：
rootElement.addContent((Content)(new Element("name").addContent("kingwong")));//因为addContent(Content child)方法返回的是一个Parent接口，而Element类同时继承了Content类和实现了Parent接口，所以我们把它造型成Content。

我们用同样的方法添加带属性的子元素
rootElement.addContent(new Element("sex").setAttribute("value","male"));//注意这里不需要转型，因为addAttribute(String name,String value)返回值就是一个 Element。

同样的，我们添加元素到根元素下，用法上一样，只是稍微复杂了一些：
rootElement.addContent((Content)(new Element("contact").addContent((Content)(new Element("telephone").addContent("87654321")))));
如果你对这种简写形式还不太习惯，你完全可以分步来做，就象本节刚开始的时候一样。事实上如果层次比较多，写成分步的形式更清晰些，也不容易出错。

4.删除子元素

这个操作比较简单：
rootElement.removeChild("sex");//该方法返回一个布尔值

到目前为止，我们学习了一下JDOM文档生成操作。上面建立了一个样本文档，可是我们怎么知道对不对呢？因此需要输出来看一下。我们将JDOM生成的文档输出到控制台，使用 JDOM 的 XMLOutputter 类。

5. 将 JDOM 转化为 XML 文本

XMLOutputter xmlOut = new XMLOutputter(" ",true);
try {
xmlOut.output(myDocument,System.out);
} catch (IOException e) {
e.printStackTrace();
}
XMLOutputter 有几个格式选项。这里我们已指定希望子元素从父元素缩进两个空格，并且希望元素间有空行。
new XMLOutputter(java.lang.String indent, boolean newlines)这个方法在最新版本中已经不建议使用。JDOM有一个专门的用来定义格式化输出的类：org.jdom.output.Format，如果你没有特殊的要求，有时候使用里面的几个静态方法（应该可以说是预定义格式）如 getPrettyFormat()就可以了。我们把上面的输出格式稍微改一下，就象这样：
XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat());

6.将JDOM文档转化为其他形式

XMLOutputter 还可输出到 Writer 或 OutputStream。为了输出JDOM文档到一个文本文件，我们可以这样做：
FileWriter writer = new FileWriter("/some/directory/myFile.xml");
outputter.output(myDocument, writer);
writer.close();

XMLOutputter 还可输出到字符串,以便程序后面进行再处理:
Strng outString = xmlOut.outputString(myDocument);

当然，在输出的时候你不一定要输出所有的整个文档，你可以选择元素进行输出：
xmlOut.output(rootElement.getChild("name"),System.out);
一句话，JDOM非常灵活方便！如果你想进一步研究JDOM，请到官方网站去看一看：http://www.jdom.org

本节示例源码：
package com.cyberobject.study;

import java.io.IOException;

import org.jdom.Attribute;
import org.jdom.Content;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
* @author kingwong
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class TestJDOM {

public static void main(String[] args)
{
Element rootElement = new Element("MyInfo");
Document myDocument = new Document(rootElement);

// Attribute rootAttri = new Attribute("comment","introduce myself");
// rootElement.setAttribute(rootAttri);

rootElement.setAttribute("comment","introduce myself");
//rootElement.setAttribute(new Attribute("comment","introduce myself"));
// Element sexElement = new Element("sex");
// rootElement.addContent(sexElement);

// Element nameElement = new Element("name");
// nameElement.addContent("kingwong");
// rootElement.addContent(nameElement);

rootElement.addContent((Content)(new Element("name").addContent("kingwong")));
rootElement.addContent(new Element("sex").setAttribute("value","male"));
rootElement.addContent((Content)(new Element("contract").addContent((Content)(new Element("telephone").addContent("87654321")))));

rootElement.removeChild("sex");

XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat());
try {
xmlOut.output(myDocument,System.out);
//xmlOut.output(rootElement.getChild("name"),System.out);
//String outString = xmlOut.outputString(myDocument);
} catch (IOException e) {
e.printStackTrace();
}
}
}

（二）、XML文档解析

JDOM 不光可以很方便的建立XML文档，它的另一个用处是它能够读取并操作现有的 XML 数据。
JDOM的解析器在org.jdom.input.*这个包里，其中的DOMBuilder的功能是将DOM模型的Document解析成JDOM模型的Document；SAXBuilder的功能是从文件或流中解析出符合JDOM模型的XML树。由于我们经常要从一个文件里读取数据，因此我们应该采用后者作为解析工具。
解析一个xml文档，基本可以看成以下几个步骤：

1.实例化一个合适的解析器对象

本例中我们使用SAXBuilder:
SAXBuilder sb = new SAXBuilder();

2.以包含XML数据的文件为参数，构建一个文档对象myDocument

Document myDocument = sb.build(/some/directory/myFile.xml);

3.获到根元素

Element rootElement = myDocument.getRootElement();

一旦你获取了根元素，你就可以很方便地对它下面的子元素进行操作了，下面对Element对象的一些常用方法作一下简单说明：
getChild("childname") 返回指定名字的子节点,如果同一级有多个同名子节点，则只返回第一个；如果没有返回null值。
getChildren("childname") 返回指定名字的子节点List集合。这样你就可以遍历所有的同一级同名子节点。
getAttributeValue("name") 返回指定属性名字的值。如果没有该属性则返回null,有该属性但是值为空，则返回空字符串。
getChildText("childname") 返回指定子节点的内容文本值。
getText() 返回该元素的内容文本值。

还有其他没有罗列出来的方法，如果需要的话，可以随时查阅JDOM的在线文档：http://www.jdom.org/docs/apidocs/index.html。当然你可以在你需要的地方添加、删除元素操作，还记得上面的创建XML的方法吗？呵呵~~~

学习新东东还是从实例学起最为快捷，下面简单举个例子，就以上面的XML样本代码来学习JDOM的XML解析。本例中读取了样本XML文件里一些属性和content，最后我们还在contact元素里插入了一个新元素wanghua@cyberobject.com" />。尽管我们实现了对于XML的基本操作，细心的朋友可能会
有疑问：如果XML文档的层次稍微复杂一些，如果嵌套多达几十上百层的话（开个玩笑），如果靠这样从根元素一级一级地通过getChild("childname")来访问子元素的话，将会非常痛苦！是的，的确是这样，但是我们有另一个有力的工具XPath，为什么不用呢？这是后话！先卖个关子（手敲累啦，下回吧，呵呵）。

/*
* Created on 2004-8-21
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package com.cyberobject.study;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
* @author kingwong
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class TestJDOM2 {
public static void main(String[] args){
SAXBuilder sb = new SAXBuilder();
try
{
Document doc = sb.build("myFile.xml");
Element root = doc.getRootElement();

String str1 = root.getAttributeValue("comment");
System.out.println("Root Element's comment attribute is : " + str1);
String str2 = root.getChild("sex").getAttributeValue("value");
System.out.println("sex Element's value attribute is : " + str2);
String str3 = root.getChildText("name");
System.out.println("name Element's content is :" + str3);
String str4 = root.getChild("contact").getChildText("telephone");
System.out.println("contact Element's telephone subelement content is : " + str4 + "\n");
Element inputElement = root.getChild("contact");
inputElement.addContent(new Element("email").setAttribute("value","wanghua@cyberobject.com"));

XMLOutputter xmlOut = new XMLOutputter(Format.getPrettyFormat());
String outStr = xmlOut.outputString(root);
System.out.println(outStr);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

草儿 2007-06-25 18:33 发表评论

Groovy（一个属于JAVA平台的动态开发语言）与JAVA 的异同

草儿 — Wed, 06 Jun 2007 13:31:00 GMT

Groovy tries to be as natural as possible for Java developers. We've tried to follow the principle of least surprise when designing Groovy, particularly for developers learning Groovy who've come from a Java background.

Here we list all the major differences between Java and Groovy.

Default imports

All these packages and classes are imported by default, i.e. you do not have to use an explicit import statement to use them:

java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*

Common gotchas

Here we list the common things you might trip over if you're a Java developer starting to use Groovy.

== means equals on all types. In Java there's a wierd part of the syntax where == means equality for primitive types and == means identity for objects. Since we're using autoboxing this would be very confusing for Java developers (since x == 5 would be mostly false if x was 5 . So for simplicity == means equals() in Groovy. If you really need the identity, you can use the method "is" like foo.is(bar). This does not work on null, but you can still use == here: foo==null.
in is a keyword. So don't use it as a variable name.
When declaring array you can't write
```
int[] a = {1,2,3};
```
you need to write
```
int[] a = [1,2,3]
```
If you were used to write a for loop which looked like
```
for (int i =0; i < len; i++)
```
in groovy you need to write
```
for (i in 0..len-1)
```
or
```
for (i in 0..
    
```

Things to be aware of

semicolon is optional. Use them if you like (though you must use them to put several statements on one line).
the return keyword is optional.
you can use the this keyword inside static methods (which refers to this class).
methods and classes are public by default.
protected in Groovy is the equivalent of both package-protected and protected in Java. i.e. you can have friends in the same package - or derived classes can also see protected members.
inner classes are not supported at the moment. In most cases you can use closures instead.
the throws clause in method heads is not checked by the Groovy compiler, because there is no difference between checked and unchecked exceptions.

Uncommon Gotchas

Java programmers are used to semicolons terminating statements and not having closures. Also there are instance initializers in class definitions. So you might see something like:

class Trial {
private final Thing thing = new Thing ( ) ;
{ thing.doSomething ( ) ; }
}

Many Groovy programmers eschew the use of semicolons as distracting and redundant (though others use them all the time - it's a matter of coding style). A situation that leads to difficulties is writing the above in Groovy as:

class Trial {
private final thing = new Thing ( )
{ thing.doSomething ( ) }
}

This will probably be a compile error!

The issue here is that in this situation the newline is not a statement terminator so the following block is treated as a closuresthat is a parameter to the Thing constructor. Bizarre to many, but true. If you want to use instance initializers in this sort of way, it is effectively mandatory to have a semicolon:

class Trial {
private final thing = new Thing ( ) ; {
thing.doSomething ( )
}

This way the block following the initialized definition is clearly an instance initializer.

New features added to Groovy not available in Java

closures
native syntax for lists and maps

GroovyMarkup and GPath support
native support for regular expressions
polymorphic iteration and powerful switch statement

dynamic and static typing is supported - so you can omit the type declarations on methods, fields and variables
you can embed expressions inside strings
lots of new helper methods added to the JDK
simpler syntax for writing beans for both properties and adding event listeners

safe navigationusing the ?. operator, e.g. "variable?.field" and "variable?.method()" - no more nested ifs to check for null clogging up your code

草儿 2007-06-06 21:31 发表评论

生成一个java编制的可执行文件[1]

草儿 — Tue, 01 May 2007 09:04:00 GMT

将java编织成.class后，如果只是用java 命令来执行总觉得不是太过瘾，找个办法生成像exe文件一样用鼠标双击便可执行的文件，应该是很有趣的啊。本文主要介绍了一种生成java可执行程序的方法。

这里我用了一个名字叫做exe4j的免费小软件，感觉不错。下面我将我把java的.class文件生成可执行文件的流程讲一下。

首先：将你要选择好你即将发布的.class文件就不用细说了，下面是创建jar文件，这里我用一个名字叫做test.class的文件来举例，另外注意还要编写一个确定main_class的文件manifest.mf，在这里mainfest.mf和test.class是在同一个目录下，然后使用如下命令

jar cvfm test.jar manifest.mf test

这样，一个test.jar文件就生成了，这里我就不细说jar的具体功能了。但为了确保成功，我们可以再用下面的指令执行一下刚刚生成的test.jar：

java -jar test.jar

怎么样，是不是可以很顺利的进行？如果是，那我们就可以开始进行可执行文件的创建了。

下面打开exe4j，它的开始一个界面是这样的：

http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-291439280.jpg
单击NEXT键，选择”JAR in EXE”mod按钮，单击NEXT；

http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-291439282.jpg
出现下面画面，填写短名和文件输出的路径然后点击NEXT继续
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-291439284.jpg
你又会看到下面的画面，在这里你可以选择你要生成的可执行文件的类型，以及生成的可执行文件名称、可执行文件的图标等，我们在这里就选择GUI application，名字就根据自己的需要取一个，图标你可以自己在你的图标库里选一个你喜欢的，然后再NEXT再继续；

http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-291439286.jpg
下一个画面如下，在这里填写Main class的名字，单击下面的绿色+选择所需的.jar文件,如果没有特殊要求我们就可以再继续了；

http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-291439288.jpg
接下来是选择版本的画面，填写好自己的最大最小版本然后再继续
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392810.jpg
下面这个画面可以帮助你设一下你的文件执行的片头，增加其美观效果，选择自己喜欢的图片，写自己想写的文字，并可以根据需要调整文字的位置，再继续

http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392812.jpg
下面是一个选择语言版本的界面选好后再继续
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392814.jpg
下面是一个短暂的等待
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392816.jpg
然后就大功告成了，一个java写成的可执行文件就这样生成了
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392818.jpg
击一下看看效果，迎面而来的是自己设置的开头效果，感觉怎么样
http://dev.csdn.net/Develop/ArticleImages/21/21845/CSDN_Dev_Image_2003-10-2914392820.png

草儿 2007-05-01 17:04 发表评论

java 面试题

草儿 — Fri, 09 Mar 2007 04:56:00 GMT

摘要: 一、Java基础知识1.Java有那些基本数据类型，String是不是基本数据类型，他们有何区别。2.字符串的操作：写一个方法，实现字符串的反转，如：输入abc，输出cba 写一个方法，实现字符串的替换，如：输入bbbwlirbbb，输出bbbhhtccc。3.数据类型之间的转换如何将数值型字符转换为数字（Integer，Double）如何将数字转换为字符如何取小数点前两位，并四... 阅读全文

草儿 2007-03-09 12:56 发表评论

Eclipse 快捷键指南

草儿 — Fri, 09 Mar 2007 04:46:00 GMT

摘要: 编辑作用域 ... 阅读全文

草儿 2007-03-09 12:46 发表评论

Set up an SQL realm with DB2 Express-C, Eclipse WTP, and WebSphere Application Server Community Edition V1.1（2）

草儿 — Fri, 12 Jan 2007 07:33:00 GMT

Conclusion

This tutorial showed you how to create an SQL realm and deploy a Web application that uses the realm. In this example, you used DB2 Express-C as the database and the Eclipse Web Tools Platform for the development environment to create an application and deploy it to WebSphere Application Server Community Edition for hosting the application.

Acknowledgements

The author would like to thank Manu T. George (WebSphere Application Server Community Edition L3 Support) and Anitha Krishnasamy (WebSphere Application Server Community Edition Business Development) for reviewing this tutorial and providing their valuable comments.

Download

Description	Name	Size	Download method
Sample code for this tutorial	sample-db2-realm.zip	28KB	HTTP

Resources

Learn

Get products and technologies

Download WebSphere Application Server Community Edition V1.1
Download DB2 Express-C

Download Eclipse

About the author


		Krishnakumar Balachandar is a senior staff software engineer at IBM Software labs in Bangalore, India. He is part of the support team for Geronimo and WebSphere Community Edition.

草儿 2007-01-12 15:33 发表评论

Set up an SQL realm with DB2 Express-C, Eclipse WTP, and WebSphere Application Server Community Edition V1.1（一）

草儿 — Fri, 12 Jan 2007 05:37:00 GMT

Krishnakumar Balachandar (krishnakumarb@in.ibm.com), Software Engineer, WebSphere Application Server Community Edition Support Team, IBM

20 Sep 2006

This tutorial shows you how to set up an SQL realm to implement database security for a Web application using the no-charge Java kick-start package.

Before you start

When implementing security in a Web application, a JAAS module is required to specifically handle user authentication and authorization. WebSphere Application Server Community Edition provides a SQL realm that can connect to a database for obtaining user credentials. In this tutorial, you will see how to set up tables for creating an SQL realm in DB2 Express-C, how to set up a development environment using the Eclipse Web Tooling Platform to create a Web application, and how to deploy the Web application to WebSphere Application Server Community Edition from Eclipse.

All Web applications should employ some level of security for user authentication and authorization to verify a user’s identity and enable access to application functions that are applicable to the user's role.

Web applications can use LDAP, database, file system, Kerberos, or other such systems to provide authentication and authorization. To access security data from the selected method or system, an SQL realm is set up by creating tables in a database and configuring a Java Authentication and Authorization Service (JAAS) module to access these tables from an application server.

Figure 1 shows different components in WebSphere Application Server Community Edition (hereafter referred to as Community Edition) used to provide an SQL realm. The Web application uses an SQL realm that connects to the database using a pool or driver. The user credentials are stored in tables in the database and are fetched when calls are made using the JAAS SQL realm.

Figure 1. Components of an SQL realm

Java Authentication and Authorization Service (JAAS) is a set of APIs that enables Java applications to access authentication and access control services without being tied to the service it is using. Using JAAS, the Java application can plug into security mechanisms like LDAP, Kerberos, databases, and so on, providing a layer between our application and the security mechanism being used.

Setting up a database realm

Setting up a database realm involves performing these general steps:

Create tables for users and groups in DB2 Express-C.
Deploy a database pool in Community Edition, if the realm is going to use a pool to connect to the database.
Deploy the SQL realm plan in Community Edition.
Configure and deploy the Web application that uses the SQL realm.

The remainder of this tutorial explains these tasks in detail.

Setting up a database

In this section, you will see how to set up the database and database tables required for the SQL realm. You can create database and tables either by using the Control Center or by running an SQL script.

Using the Control Center

Create the database

In DB2 Express-C, open the Control Center.
Right-click All Databases, then select Create Database => Standard.
For Database name, enter WASCE.
Click Finish.

You just created a new database called WASCE and should see it listed under All Databases (Figure 2).

Figure 2. New database created

Back to top

Create tables

Now, create the tables for users (USERS) and groups (GROUPS) in the new WASCE database:

Under WASCE in the directory listing, right-click Tables, then select Create.
For Table name, enter USERS, then click Next.
Add a column:
1. Select Add to add a column to the new table.
2. For Column name, enter USERNAME.
3. For Data type, select VARCHAR.
4. For Nullable or not, select No.
5. Click Apply.
Repeat step 3 to add an EMAIL column and a PASSWORD column to the USERS table, with the values shown in Figure 3. When finished, click OK.
Repeat steps 1 through 4 to create a new GROUPS table with two columns: GROUPNAME and USERNAME.
Click Next => Next => Next to get to the Define keys on new table panel.
Select Add Primary. From the available columns, select which column is to be the primary key for each table:
1. For the USERS table, select USERNAME, and for the GROUPS table, select USERNAME/GROUPNAME as the primary key.
2. For the GROUPS table, select Add foreign => USERNAME. Click the > button to move it to foreign key. Select USERNAME as the primary key in the Parent table (Schema/Name - ADMINISTRATOR/USERS).
Click Finish and the table is created.

Use the steps above and the schema definitions shown in Figures 3 and 4 to create the USERS and GROUPS tables. For the USERS table, USERNAME is the primary key. For the GROUPS table, GROUPNAME and USERNAME are primary keys, and USERNAME is a foreign key (referring to USERNAME in the USERS table).

Figure 3. USERS schema

Figure 4. GROUPS schema

In the steps shown above, the USERS and GROUPS tables are created under the ADMINISTRATOR schema. Had you logged in as db2admin, the tables would be created under the DB2ADMIN schema.

Populate tables with values

Select WASCE => Tables => USERS.
Right-click on the USERS table, then select Open => Add row.
Enter test values for each field in the database record, then select Commit.
Repeat steps 2 and 3 for each test record you wish to create, then Close.
Repeat steps 1 through 4 for the GROUPS table (Figure 5).

Figure 5. Create test data records

Using scripts

As an alternative to using the DB2 Control Center, you can create the database, tables, and test data using an SQL script. The download file included with this tutorial contains a sanmple script file, db2_realm.sql. Execute this script from DB2 command line to create the database and tables:

Open a Windows command window or run the DB2 batch file /bin/db2cw.bat.
Execute the sample script file with this command: db2 -tvfdb2-realm.sql.

If there are no errors, success messages will be generated for the SQL (Figure 6).

Figure 6. Create database, tables, and test data using script

Creating the Web application

In this section, you will use the Eclipse Web Tools Platform (WTP) to create a simple Web application. Before you begin with the application, though, you will need to define a new server in Eclipse (to which the new application will be deployed) and create a Java Runtime Environment (JRE). After that, you can use Eclipse WTP to create the application components (like the WAR and EAR files). The download file included with this tutorial contains a source EAR file of a sample application that you can import into Eclipse WTP.

Define a new server

To deploy an application, you need to define a server in Eclipse:

In Eclipse, right-click the Server tab, and select New Server to open the New Server wizard (Figure 7).

Figure 7. Define new server
Select WebSphere Application Server Community v1.1 Server, then press Next.
Enter values for all fields, as shown in Figure 8, then Finish.

Figure 8. New server parameters

Create a JRE

To build application for supported Java Runtime Environment (JRE), in this case the IBM JRE, you need to configure the JRE in Eclipse WTP:

In Eclipse, select Window => Preferences.
Select Java => Installed JREs.
Click Add. . .
On the Add JRE dialog, enter values for all fields, as shown in Figure 9.

Figure 9. Add JRE
Be sure this JRE is selected as the default JRE.
Next, you need to make sure that the IBM JRE will run the new server that you created earlier. Right-click on the new server, then select Open (Figure 10).

Figure 10. Open new server
Next to Runtime, select Edit.
For JRE, select IBM (Figure 11), then Finish.

Figure 11. Select IBM JRE

Develop an application

The Web application will contain pages for the application (in a WAR file) and will be added to an enterprise application (in an EAR file). For the purposes of this tutorial, you can either use an application you develop from scratch, or you can use the sample application included in the download file.

Create a new application in Eclipse WTP

Run Eclipse WTP either by double-clicking eclipse.exe from the location where you extracted the WTP platform, or by executing eclipse.exe from a command line.
Select File => New => Project => Web =>Dynamic Web Project.
On the Dynamic Web Project dialog, enter or select the following values:
- Project name: SQLRealmWeb
- Target runtime: WebSphere Community Edition v1.1
- EAR membership: SQLRealmApp
If you need to create a WebSphere Application Server Community Edition V1.1 runtime option (Figure 12):
1. Click the New button next to Target Runtime.
2. Select WebSphere Application Server Community Edition v1.1, then Next.
3. Select IBM for JRE, and browse to the appropriate Application Server Install Directory, then click Finish.
  
  Figure 12. Create Community Edition runtime
Click Next on the next two panels.
For Context Root, enter /SQLRealmWeb, then Next.
Configure the Geronimo deployment plan by entering these values:
- Group ID: wasce
- Artifact ID: sqlrealm
- Version: 1.0
- Artifact Type: WAR
Click Finish (Figure13).

Figure 13. Server setup complete

Import sample application into Eclipse WTP

If you choose to import the sample project, the download file included with this tutorial contains an EAR file you can import into the Eclipse WTP workspace:

In Eclipse, select File => Import => J2EE.
For Source File, enter SQLRealmAppSrc.ear, then click Next.
Enter or select the following values:
- EAR Project: SQLRealmApp
- Web Project: SQLRealmWeb
- Target Runtime: WebSphere Community Edition v1.1
If you need to create a WebSphere Application Server Community Edition V1.1 runtime option (Figure 12):
1. Click the New button next to Target Runtime.
2. Select WebSphere Application Server Community Edition v1.1, then Next.
3. Select IBM for JRE, and browse to the appropriate Application Server Install Directory, then click Finish.
Click Finish.

Deploying the application

With the application created, you can deploy it to the Community Edition runtime environment. However, for the application to run, you need a database pool and realm plan:

Deploy the database pool

To connect to DB2, you need a database pool, which you can create by deploying a database pool plan with the wizard that is available from the Community Edition administrative console:

Logon to the Community Edition administrative console by starting the server. To start the server, right-click on the new server you created above, and select Start. Once the server is started, the status changes to green and shows "Started". You can now launch the console by right-clicking on the started server and selecting Launch Community Edition Console. Enter your username and password as system and manager.
Under Services, select Database Pools => Using Geronimo PoolsWizard.
For Database Pools, enter Db2Realm, then Next.
On the Select Driver, JAR, Parameters panel, enter or select the values shown for all fields in Figure 14. When finished, click Next.

Figure 14. Enter database pool parameters
Test the connection for errors by selecting Test connection. If there are no errors, you will see the message: Test Result: Connected to DB2/NT SQL09000 in the console.
Once you deploy the pool, it is started and running (Figure 15).

Figure 15. Database pool deployed

Deploy the realm plan

Community Edition connects to SQL databases using JAAS, by default, to provide an SQL realm to applications deployed in the server. You can make this connection by using a JDBC driver that connects directly to the database, or by using a database pool that gets a connection from a pool to connect to the database.

The realm plan (see Listings 1 and 2) is used to deploy an SQL realm that connects to the database. The realm plan contains Geronimo GBeans required to create an SQL realm. The GBean "sql-login" has attributes that you use to specify the realm type, loginModuleClass = org.apache.geronimo.security.realm.providers.SQLLoginModule, and options where you specify the JDBC properties required to connect to the database. You can use this plan to connect to any JDBC database. For this exercise, you can specify either the JDBC driver or the DataSource name to connect to the database.

Using the JDBC driver

Listing 1 shows an SQL realm plan that uses the JDBC driver to connect to database. The plan is contained in the download file as sqlplan.xml. In the statements that are bold in Listing 1, replace ADMINISTRATORS with the schema name in which the tables have been created.

Listing 1. SQL realm plan using JDBC driver

                    

  
    
      db2
      realm
      1.0
      car
    
    
      
        geronimo
        j2ee-security
        1.1
        car
      
      
        console.dbpool
        DB2Realm
        1.0
        rar
      
    
    
    
  
  
    org.apache.geronimo.
        security.realm.providers.SQLLoginModule
    true
    jdbcUser=db2admin
      jdbcPassword=db2admin
      jdbcURL=jdbc:db2:WASCE
      jdbcDriver=com.ibm.db2.jcc.DB2Driver
      userSelect=select username, password from ADMINISTRATOR.USERS
      groupSelect=select groupname, username from ADMINISTRATOR.GROUPS
    sql-realm
  
  
    sql-realm
    
      sql-login
    
    
      ServerInfo
    

    
    
      JaasLoginService
    
  
  
    REQUIRED
    
      sql-login
    
  
  
    sqltest
    sql-realm
    
      JaasLoginService

Using database pool

Listing 2 shows an SQL realm plan that uses a database pool (DB2Realm) that was deployed using the console wizard. The plan is contained in the download file as sqlpoolplan.xml.

Listing 2. SQL realm plan using database pool

                    

  
    
      db2
      pool-realm
      1.0
      car
    
    
      
        geronimo
        j2ee-security
        1.1
        car
      
      
        console.dbpool
        DB2Realm
        1.0
        rar
      
    
    
    
  
  
    org.apache.geronimo.security.realm.
        providers.SQLLoginModule
    true
    
      userSelect=select username, password from ADMINISTRATOR.USERS
      groupSelect=select groupname, username from ADMINISTRATOR.GROUPS
      dataSourceName=DB2Realm
    sqlpool-realm
  
  
    sqlpool-realm
    
      sqlpool-login
    
    
      ServerInfo
    
    
    
      JaasLoginService
    
  
  
    REQUIRED
    
      sqlpool-login
    
  
  
    sqlpooltest

Deploy the realm

You can deploy the realms to the server using the administrative console:

Start the Community Edition server from Eclipse WTP. In Eclipse, select the server you created earlier by right-clicking on the Server tab, then select Start (Figure 16).

Figure 16. Start server
Login to the Community Edition administrative console.
Deploy the SQL realm plan that uses JDBC Driver (sqlplan.xml shown in Listing 1) by selecting Deploy New on the console (Figure 17).

Figure 17. Deploy database realm
Deploy the SQL database realm plan that uses the database pool (sqlpoolplan.xml shown in Listing 2).
Check to see that these two plans are deployed successfully by selecting Systems Modules under Applications in the console (Figure 18).

Figure 18. Check successful real deployment

Deploy the application

With the application and server configuration defined in Eclipse, and the database realm deployed, you can now deploy the application to the server.

In Community Edition, select Server tab, right-click on the server you created earlier, and then select Add and Remove Projects.
Select the SQLRealmApp from the Available projects list and click Add > to move it over to the Configured projects list (Figure 19).
Click Finish.

Figure 19. Add to configured projects
Start the server. From the Server tab, right-click again on your server and select Start. The application will run on the server you selected.
To launch the console for the server, right-click on the Community Edition server, then select Launch Community Edition Console. Enter the login ID and password: system and manager, respectively (Figure 20).

Figure 20. Launch administrative consoles

Running the application
In the prior sections, you created and deployed the Web application to the server from Eclipse WTP. Next, you can use the application, following the instructions in this section to test authentication, authorization, and access to the database pool. The application referred to in this section is the sample application provided in the download file.
Access the application
To access the Web application:
1. From the Eclipse Navigator, right-click the Web application SQLRealmWeb, then select Run As => Run on Server.
2. Select WebSphere Application Server Community Edition 1.1, which is the server you defined earlier.
3. The project should already be added. Select Next and Finish.
4. The application should now be available at http://localhost:8080/SQLRealmWeb/ (Figure 21).
  
  Figure 21. Test the application
Test the authentication
Included with this sample application are several valid user ID and password combinations (for testing authentication) with different roles (for testing authorization). Test the authentication by logging in. Using a correct user ID and password will log you in. An incorrect user ID and password will display the error page shown in Figure 22.
Valid user ID/password values are as follows:
system/manager admin/admin123 user1/user1123 user2/user2123 guest1/guest1123 guest2/guest2123

Figure 22. Application error page

Test authorization
Once authenticated and inside the application, the user is allowed access to areas of Web application based on the user's business role, as defined in the deployment descriptor. The sample application is defined with three roles: admin, user, and guest. A user with an admin role has access to all accounts in the sample application, but a user with a guest role will only be able to access pages defined for the guest. Test this by entering the application with different user IDs and passwords with admin, user, and guest roles. Figure 23 shows a user logged in as admin, but who is able to view the guest pages.

Figure 23. Admin user viewing Guest page

In the case of unauthorized access (for example, if a guest user attempts to access a page authorized for admin users only), an HTTP 403 status error occurs (Figure 24) and prevents access to the page.

Figure 24. Authorization error

Using the database pool
The default Web application is configured to use SQL realm that uses the JDBC driver. You can change this so that it uses the database pool by changing the realm name in the geronimo-web.xml file as sqlpool-realm, and republishing the server. Verify if this works by stopping the db2/realm/1.0/car configuration in the server.
Contents of the download file
The download file included with this tutorial, sample-db2-realm.zip, contains the following files:
- db2-realm.sql - SQL script file to create database and tables
- db2-plan.xml - Plan to deploy a DB2 database pool.
- sqlplan.xml - SQL realm plan that uses JDBC driver.
- sqlpoolplan.xml - SQL realm plan that uses a database pool.
- SQLRealmAppSrc.ear - Source for sample Web application.

草儿 2007-01-12 13:37 发表评论

BlogJava-无为-随笔分类-java

Java heap dump触发和分析

java中Class.getResource用法

OOME错误抛出原因

Java学习笔记 - 基础篇

Java 5|6 并发包介绍

1、堆排序的实现

DB连接池管理编程举例

Java中如何重设数组的大小？

常去的几个外国技术门户

Java Annotation手册

什么是JMX?

表现层

代理层

MBean

MBean服务器

代理服务

分布式服务层

协议适配器和连接器

协议适配器是代理与管理客户通信的手段，每个通信的协议都可能不同。

JMX的好处

转 侯捷谈Java反射机制

国外开源网站聚合

JavaFX编程语言基础

深入学习JavaFX脚本语言-參考

访问内存中JDBC驱动信息的小程序

如何在Java中使用Robot类

JavaFX入门教程二

JavaFX入门教程一

基于Struts1.2.9框架的登录页面的处理过程

JSP在TOMCAT中的处理生命周期

一个Servlet生命周期（Tomcat处理请求中）

Adobe Flex2

JDOM简介

Groovy（ 一个属于JAVA平台的动态开发语言）与JAVA 的异同

Default imports

Common gotchas

Things to be aware of

Uncommon Gotchas

New features added to Groovy not available in Java

生成一个java编制的可执行文件[1]

java 面试题

Eclipse 快捷键 指南

Set up an SQL realm with DB2 Express-C, Eclipse WTP, and WebSphere Application Server Community Edition V1.1（2）

Set up an SQL realm with DB2 Express-C, Eclipse WTP, and WebSphere Application Server Community Edition V1.1（一）

转侯捷谈Java反射机制

Groovy（一个属于JAVA平台的动态开发语言）与JAVA 的异同

Eclipse 快捷键指南