语源科技BlogJava-Pudgy's World

2005.08.30

Pudgy's World — Tue, 30 Aug 2005 05:09:00 GMT

把SwingWorker 的Thread 参数弄明白
线程组的调用.

Pudgy's World 2005-08-30 13:09 发表评论

Thumbnail.java - Load an image, scale it to thumbnail size and save it as JPEG

Pudgy's World — Mon, 29 Aug 2005 08:12:00 GMT

From http://schmidt.devlib.org/java/save-jpeg-thumbnail.html

Thumbnail.java - Load an image, scale it to thumbnail size and save it as JPEG

This programm loads an image via java.awt.Toolkit, scales it down to a user-defined resolution and saves it as a JPEG file. The first part, the loading of the original image, is done the same way as in Viewer. So if you don't know yet how loading images with Toolkit works you might want to study that program first.

Different from Viewer, this program (Thumbnail) works on the command line. So you won't get any windows or other graphical user interface components. The only visual feedback is the word Done. after the program successfully terminated.

To use this program do the following:

Save the program's source code as Thumbnail.java (regard case).
Open a shell (prompt), go to the directory where Thumbnail.java is and compile it:
```
javac Thumbnail.java
```
You should now have a new class file Thumbnail.class.
Run the program with five parameters for image file, thumbnail file, thumbnail width and thumbnail height and quality (a value from 0 to 100, 100 being the best and 0 the worst quality), e.g.:
```
java Thumbnail c:\image.jpg c:\thumbnail.jpg 120 80 75
```
The file image.jpg must exist already, thumbnail.jpg will be created (and any existing file of that name overwritten).

You will need Java 1.2 or higher to successfully run this program. The com.sun.image.codec.jpeg package that will be used for saving the thumbnail is not available with all Java development kits, but as long as you are using a Sun JDK, it should be present.

With Java 1.4 a new way of writing JPEG files was introduced, the image I/O library in the package javax.imageio. See the Screenshot.java example program. It saves as PNG, but all you have to do is change the second argument of ImageIO.write from png to jpg. The advantage of ImageIO: It is available with each 1.4+ JDK and JRE, not only those coming from Sun.

Explanation

Now let's see how this program works. First, it is checked that we have exactly five arguments. If this is not the case, an error message is printed to output and the program terminates.

Next, the input image is loaded via Toolkit and MediaTracker just as it was done in Viewer.

The third and fourth program argument contain the maximum size of the thumbnail to be created. The actual size of the thumbnail will be computed from that maximum size and the actual size of the image (all sizes are given as pixels). The code that does this is not really very readable, and also not essential to loading and saving image files. But it is necessary to create a thumbnail that is scaled correctly.

As an example, if the two arguments for the maximum thumbnail size are both 100 and the image that was loaded is 400 times 200 pixels large, we want the thumbnail to be 100 times 50 pixels large, not 100 times 100, because the original image is twice as wide as it is high. A 100 times 100 pixel thumbnail would contain a very skewed version of the original image.

Now that we have determined the size of the thumbnail we create a BufferedImage of that size, named thumbImage. We ask for a Graphics2D object for that new thumbnail image and call its drawImage method to draw the original image on that new image. The call to drawImage does the actual scaling. The rendering hints for bilinear interpolation can be left out if quality is not that necessary and speed more important. For nicer results (at least in some cases) try RenderingHints.VALUE_INTERPOLATION_BICUBIC instead of RenderingHints.VALUE_INTERPOLATION_BILINEAR.

In order to save the scaled-down image to a JPEG file, we create a buffered FileOutputStream with the second argument as name and initialize the necessary objects from the com.sun.image.codec.jpeg package. The quality argument from the command line is converted from the interval 0 to 100 to the interval 0.0f to 1.0f, because that's what the codec expects (I mostly use 0.75f). The higher that quality number is, the better the resulting thumbnail image quality, but also the larger the resulting file.

The call to System.exit(0); is unfortunately necessary for some Java runtime environments (because of a bug that keeps the AWT thread from terminating).

Source code of Thumbnail.java

 import com.sun.image.codec.jpeg.*;
import java.awt.*;
import java.awt.image.*;
import java.io.*;

/**
 * Thumbnail.java (requires Java 1.2+)
 * Load an image, scale it down and save it as a JPEG file.
 * @author Marco Schmidt
 */
public class Thumbnail {
  public static void main(String[] args) throws Exception {
    if (args.length != 5) {
      System.err.println("Usage: java Thumbnail INFILE " +
        "OUTFILE WIDTH HEIGHT QUALITY");
      System.exit(1);
    }
    // load image from INFILE
    Image image = Toolkit.getDefaultToolkit().getImage(args[0]);
    MediaTracker mediaTracker = new MediaTracker(new Container());
    mediaTracker.addImage(image, 0);
    mediaTracker.waitForID(0);
    // determine thumbnail size from WIDTH and HEIGHT
    int thumbWidth = Integer.parseInt(args[2]);
    int thumbHeight = Integer.parseInt(args[3]);
    double thumbRatio = (double)thumbWidth / (double)thumbHeight;
    int imageWidth = image.getWidth(null);
    int imageHeight = image.getHeight(null);
    double imageRatio = (double)imageWidth / (double)imageHeight;
    if (thumbRatio < imageRatio) {
      thumbHeight = (int)(thumbWidth / imageRatio);
    } else {
      thumbWidth = (int)(thumbHeight * imageRatio);
    }
    // draw original image to thumbnail image object and
    // scale it to the new size on-the-fly
    BufferedImage thumbImage = new BufferedImage(thumbWidth, 
      thumbHeight, BufferedImage.TYPE_INT_RGB);
    Graphics2D graphics2D = thumbImage.createGraphics();
    graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
      RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);
    // save thumbnail image to OUTFILE
    BufferedOutputStream out = new BufferedOutputStream(new
      FileOutputStream(args[1]));
    JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
    JPEGEncodeParam param = encoder.
      getDefaultJPEGEncodeParam(thumbImage);
    int quality = Integer.parseInt(args[4]);
    quality = Math.max(0, Math.min(quality, 100));
    param.setQuality((float)quality / 100.0f, false);
    encoder.setJPEGEncodeParam(param);
    encoder.encode(thumbImage);
    out.close(); 
    System.out.println("Done.");
    System.exit(0);
  }
}

Pudgy's World 2005-08-29 16:12 发表评论

时标和历法

Pudgy's World — Mon, 29 Aug 2005 03:42:00 GMT

转自http://fmddlmyy.home4u.china.com/text8.html

时标和历法

1、时标

时标（Time Scale）就是标度时间的方法。在时间的标度上，存在着两个相互独立的需求：一方面，我们希望时间标度能与地球的自转相吻合，可以称作天文学需求；另一方面，我们要求时间标度的单位是精确的，便于大家获得准确的时间。由于地球自转的不均匀性，从这两个需求出发制定的时标会有细微的差异。
世界时（UT1）是基于地球自转的时标，下文会详细介绍。国际原子时（TAI）是基于单位时间的时标，它以“铯-133原子基态两个超精细能级间跃迁辐射 9,192,631,770周所持续的时间”为一秒，可以称作原子时标。原子时标的准确度为每日数纳秒，而世界时的准确度只有数毫秒。

1.1 本初子午线

对于基于天文观测的时标，地球上位于不同经度的观测者，在同一瞬间测得的结果是不同的。因此需要统一的地理经度基准。
1884年在华盛顿举行的国际子午线会议决定，采用英国伦敦格林威治（Greenwich）天文台埃里中星仪所在的子午线作为时间和经度计量的标准参考子午线，称为本初子午线，又称格林威治子午线。格林威治天文台于1948年迁到苏塞克斯郡（Sussex）的Herstmonceux Castle，但旧址继续被用作0度经线的位置。
1957年国际上以若干天文测时结果长期稳定性较好的天文台数据为参考，求得平均天文台经度原点。1968年国际上把通过地极原点和平均天文台经度原点的子午线称为本初子午线。可见，本初子午线的定义已经不依赖于格林威治天文台旧址。

1.2 世界时

世界时的制定基准是太阳的周日视运动。视运动就是我们看到的运动。本来是地球绕着地轴由西向东转动。但如果观测者以为自己不动，就可以认为太阳在由东向西转动，这就是太阳的周日视运动。
地球在自转的同时还围绕太阳公转，因为地球公转轨道是椭圆的，所以太阳的周日视运动是不均匀的。天文学家制定了以太阳周日视运动的平均速度为基础的平太阳时，平太阳时的基本单位是平太阳日。国际天文学联合会于1928年决定，将由格林威治平子夜起算的平太阳时称为世界时，简称UT。
UT0是天文台观测到的原始数据。UT1在UT0的基础上，消除了地轴摆动的影响。还有一个修正了地球自转速度季节性变动的UT2，现在已经不用了。其实UT0、UT1、UT2的差异很小，不超过0.03秒。现在提到的世界时一般指UT1。

1.3 时区

世界时区的划分,是以本初子午线为标准，从西经7度5分到东经7度5分为零时区；从零时区的边界分别向东和向西，每隔经度15度划一个时区。东、西各划出 12个时区，东十二时区与西十二时区相重合。全球共划分成24个时区。各时区都以中央经线的地方时为本区的区时，相邻两时区的区时相差一小时。
在太平洋中靠近180°经线附近有一条国际规定的国际日期变更线(简称日界线)。此线两侧的日期不同。由东向西过日界线，日期要增加一天（即略去一天不算）；由西向东过日界线，日期要减少一天(即日期重复一次)。

1.4 协调世界时（UTC）和闰秒

为了调和天文学需求和单位时间需求的差异，一种称为协调世界时（UTC）的折衷时标于1972年面世。UTC的秒长与国际原子时（TAI）相同。但在必要时，UTC会增加1秒或去掉1秒，使UTC和世界时(UT1)的时刻之差保持在±0.9秒以内。这一技术措施被称为闰秒（Leap Second）。
因此，UTC与TAI之间会出现若干整数秒的差别。位于巴黎的国际地球自转事务中央局(IERS)负责决定何时加入闰秒。TAI是从1958年1月1日0 时0分0秒开始计时的。在本文写作时（2005年7月），UTC时间比TAI时间小32秒。最近一次闰秒调整是1999年1月1日。下次闰秒调整是 2006年1月1日。
我们提到的地区标准时就是在UTC上加上时差得到的本地时间。

1.5 格林威治时间（GMT）

格林威治时间（GMT）是一个比较模糊的概念。在1928年，GMT就是世界时。在UTC被广泛采用后，我们提到的GMT实际上是UTC时间，或者说零时区的标准时。

1.6 GPS时间

GPS时间可以看作没有闰秒调整的UTC时间，并以1980年1月6日0时0分0秒为起点。目前GPS时间比UTC时间大13秒。
协调世界时（UTC）将在2005年底实施一个正闰秒。届时，所有的时钟将拨慢1秒。GPS时间不做闰秒调整，所以将比UTC时间大14秒。从GPS时间计算本地时间，需要减去目前累计的闰秒，再加上本地的时差。

1.7 小结

在所有时标中，日和秒的关系都是固定的，每日86400秒。确定了秒的长度，就确定了日的长度，反之亦然。原子时标以秒为基准，秒和日的长度都是固定的。世界时以日为基本单位，每日的长度会有毫秒级的差异。UTC既保证了单位时间的精确，又通过闰秒调整与天文观测的时间保持不大于±0.9秒的误差。我们日常生活中使用的时间都以UTC时间为标准。
时标作为时间的刻度，为时间长河建立了一根以秒或日为单位的坐标轴。虽然，“GPS时间280948秒”可以标志一个唯一的时刻，但用于日常生活未免不太方便。在日常生活中，我们需要更方便的标记时间的方法，这就是下面要谈到的历法。

2、历法

所谓历法，就是通过合理地安排年、月、日这三个基本量的关系，为时间建立标记的方法。

2.1 回归年和朔望月

前面说过：地球自转可以看作太阳的周日视运动。同理，地球绕太阳的公转，可以被看作太阳的周年视运动。周年视运动的轨道被称作黄道，黄道面和赤道面的夹角是23°27′。随着太阳在黄道上的位置不同，地球上的季节也由春到夏，以至秋冬。
黄道和赤道的两个交点分别被称作春分点和秋分点，这两点在黄道上的两个中点分别被称作夏至点和冬至点。太阳从春分点出发，绕黄道一周，又回到春分点所花的时间被称为回归年。目前测量的回归年长度是365.242189日。
月亮的盈亏变化，产生了月。月亮绕地球旋转，当转到正对着太阳的位置，我们就会观测到满月，这就是望；当转到背对太阳的位置，我们会完全看不到，这就是朔。月亮从朔到朔，或从望到望所花的时间被称作朔望月。目前测量的朔望月长度是29.530588853000001日。

2.2 历法的分类

仅以太阳运动为依据的历法被称作阳历或太阳历。例如我们现在使用的公历。阳历以回归年为基本周期，与月亮运动没有任何关系。
仅以月亮运动为依据的历法被称作阴历或太阴历。例如伊斯兰教国家和地区使用的回历。阴历以朔望月为基本周期，与太阳运动没有任何关系。
同时考虑太阳和月亮运动的历法被称作阴阳历，例如我国的农历。在我国，农历习惯上也被称作阴历。阴阳历把回归年和朔望月并列为制历的基本周期。
由于回归年、朔望月的长度都不是日的整数倍，所以各种历法都要通过增加闰日或闰月，来调整自己与基本周期的差异。下面介绍几种常用的历法。

2.3 儒略历

公元前46年，罗马执政官儒略·凯撒颁布了儒略历。儒略历每年12个月，平年365天，闰年366天。除2月外，单数月份31天，偶数月份30天。2月份平年29天，闰年30天。每隔3年置一闰年。
儒略历是纯太阳历，每年的平均长度是365.25天。每400年，儒略历与回归年大约相差3天，即：
(365.25-365.242189)*400 = 3.1244
凯撒为了纪念改历成功，将他出生的7月从Quintilis改成自己的名字Julius。

2.4 奥古斯都历

奥古斯都是“神圣”的意思，这是当时人们对罗马统治者屋大维的尊称。
从公元前42年到公元前9年，儒略历被错误地执行为“每3年置一闰年”。儒略·凯撒的侄子屋大维纠正了这个错误，同时将自己出生的8月从Sextilis 改成自己的称号Augustus，将8月改成31天，将9、10、11、12月的大小月对换，并从2月份扣去一天，成为平年28天，闰年29天。
奥古斯都历的月份设置和现在的公历已经完全相同了。

2.5 格里高利历——公历

公元1582年3月1日，罗马教皇格里高利十三世颁布了格里高利历，将不能被4整除的世纪年算作平年，这就是我们现在使用的公历。
在公历中，每400年有97个闰年，平均每年的长度是：
(365*400+97)/400 = 365.2425 天
每400年，公历与回归年大约相差0.1244天，即：
(365.2425-365.242189)*400 = 0.1244

2.6 儒略日和简化儒略日

在天文学有一种连续纪日的儒略日（JD），它以儒略历公元前4713年1月1日的GMT正午为第0日的开始。还有一种简化儒略日（MJD）：
MJD=JD-2400000.5
MJD的第0日是从公历1858年11月17日的GMT零时开始的。我写完前一个句号时的MJD是53583.22260。小数部分是以UTC时间在当天逝去的秒数除以86400得到的。0.22260约为UTC时间的5:20，加上中国的时区就是13:20。
需要注意：儒略历公元前4713年1月1日相当于公历公元前4713年11月24日。在香港天文台的网页上，将儒略历说成以“公元前4713年1月1日格林尼治平时正午”起算，是错误的。

2.7 农历

2.7.1 月的划分

农历的月是严格按照朔的时刻确定的，朔所在日是初一。由于朔望月的长度约为29.A日（将小数部分记作A），假设朔发生在(30-29.A)日以内的时刻，两个朔之间就只有29天，该月就是小月；否则两个朔之间有30天，该月就是大月。

2.7.2 设计

我们已经根据月亮的运动规律将时间长轴划分为一个个月，下面要做的就是确定将哪些月组合成年。设计要求是：该设计应使四季在每年的位置相对稳定。
设计思路是这样的：四季变化以回归年为周期，回归年的长度约为365.242189日。12个朔望月的长度约为354.367066236日，13个朔望月的长度约为383.897655089。如果我们让有的年份有12个朔望月，有的年份有13个朔望月，并按照一定周期循环；在一个周期内，年的平均长度接近回归年的长度，就能实现我们的设计目标。例如：我们在19年中，让7年有13个月，其它年为12个月，则在19年的周期里，每年的平均长度是：
(29.530588853000001*(12*19+7))/19 ≈ 365.246756866 天
这个结果与回归年的长度已经比较接近。包含12个朔望月的年份被称作平年，包含13个朔望月的年份被称作闰年，闰年多加的一个月被称作闰月，这就是《尚书·尧典》中所说的“以闰月定四时成岁”。
那么，闰月加在哪里呢？在介绍置闰的规则前，必须先介绍一下节气。

2.7.3 二十四节气

以春分点为黄经0度，将黄道分成二十四等分，每等分占黄经15度，太阳通过等分点的时刻就是对应节气的时刻。二十四节气只与太阳的运动有关，所以它们在公历中的日期变化不大。
二十四节气从立春（黄经30度）开始，依次为立春、雨水、惊蛰、春分、清明、谷雨、立夏、小满、芒种、夏至、小暑、大暑、立秋、处暑、白露、秋分、寒露、霜降、立冬、小雪、大雪、冬至、小寒、大寒。
将立春作为第1个节气，依次编号。偶数编号的节气被称为“中气”（major solar terms），奇数编号的节气仍称作“节气”（minor solar terms）。我们在日常生活中将节气和中气统称为节气（solar terms）。中气是置闰的重要依据。

2.7.4 置闰

在农历中，从前一年正月初一到下一年正月初一被称作年。显然，必须先确定了闰月，才能确定年的范围，我们不可能在置闰规则中用到“年”。实际上，我们用到了另一个概念：岁。从前一个冬至到下一个冬至被称作岁。“岁”的长度就是回归年的长度。
冬至所在的月被定义为11月。如果在两个11月间有12个完整的月，那么这两个11月间的岁就被称作闰岁。因为这两个11月间只有11个中气，所以闰岁的12个月中至少有一个月没有中气。
闰岁的第一个不含中气的月，就是闰月。至此，我们已经描述了编制农历的完整规则。

2.7.5 闰年和Y2033问题

包含闰月的年被称作闰年。如果闰月出现在11月，就可能出现前一年是闰年，但不是闰岁；后一年是闰岁，但不是闰年。一个典型的例子就是Y2033问题。
从2033年的第1个月算起，第8个月没有中气，第11个月有两个中气，第12个月没有中气，第13个月有两个中气，第14个月没有中气。在2032年的 11月和2033年11月间只有11个完整的月，不是闰岁。在2033年的11月和2034年11月间有12个完整的月，是闰岁。
按照置闰规则，第12个月被作为闰月，即闰11月。8月没有中气，又不是闰月，被称作伪闰月（Fake leap month）。2034年是闰岁，但不是闰年。2034岁的闰月已经在2033年加过了。
国内1990年以前的万年历都将2033年设为闰7月，这个错误被称作Y2033问题。以后出版的万年历都改成了闰11月。但网上的一些万年历程序现在还在使用错误的农历数据。

2.7 回历

作为太阴历的例子，简单介绍一下回历。回历是伊斯兰教国家和地区采用的历法。它以朔望月为基本周期，每年12个月。平年奇数月30天，偶数月29天，共354天。
每30年为一周，加11个闰日。在30年循环周期中，第2、5、7、10、13、16、18、21、24、26、29年为闰年。闰年在12月底增加一天,共355天。
在回历中，月的平均长度是：
(354*30+11)/30/12 ≈ 29.53 天
这和朔望月长度非常接近，很好地符合了月亮的运动规律。年的平均长度是：
(354*30+11)/30 ≈ 354.366667 天
这和回归年约差11天。因此回历的新年在公历中会逐年提早，循环周期为
365.242189/(365.242189-354.366667) ≈ 33.5838766176 年
回历的起始历元被称作伊斯兰教纪元，定在穆罕默德从麦加迁到麦地那的一天，即儒略历公元622年7月16日，在公历中是公元622年7月19日。例如：伊斯兰教纪元1426年1月1日是公元2005年2月10日。伊斯兰教纪元1427年1月1日是公元2006年1月31日。

2.8 小结

公历和回历的计算都很简单。但公历的月不能符合月亮的运动规律。回历的年不能符合太阳的运动规律。农历较好地符合了太阳和月亮的运动规律，但计算比较复杂。
在网上可以找到计算各国历法的程序。我曾经将其中一个Java程序库的农历部分改写成C/C++程序，以提高运算速度。在我的个人主页上有关于农历计算程序的进一步讨论(http://fmddlmyy.home4u.china.com/cal.html)。不过这些内容已经超出了本文的范围。
在写这篇文章前，我不知道“时标”，对历法的概念也很模糊。通过查资料、写作，我对相关概念的了解越来越清晰。这篇文章的写作目的是将时标、历法的一些基本概念简单、清晰地描述出来，希望有更多的读者像我一样从中受益。

Pudgy's World 2005-08-29 11:42 发表评论

谈谈Unicode编码，简要解释UCS、UTF、BMP、BOM等名词

Pudgy's World — Mon, 29 Aug 2005 03:39:00 GMT

转自http://fmddlmyy.home4u.china.com/text6.html

谈谈Unicode编码，简要解释UCS、UTF、BMP、BOM等名词

这是一篇程序员写给程序员的趣味读物。所谓趣味是指可以比较轻松地了解一些原来不清楚的概念，增进知识，类似于打RPG游戏的升级。整理这篇文章的动机是两个问题：

问题一：

使用Windows记事本的“另存为”，可以在GBK、Unicode、Unicode big endian和UTF-8这几种编码方式间相互转换。同样是txt文件，Windows是怎样识别编码方式的呢？

我很早前就发现Unicode、Unicode big endian和UTF-8编码的txt文件的开头会多出几个字节，分别是FF、FE（Unicode）,FE、FF（Unicode big endian）,EF、BB、BF（UTF-8）。但这些标记是基于什么标准呢？

问题二：

最近在网上看到一个ConvertUTF.c，实现了UTF-32、UTF-16和UTF-8这三种编码方式的相互转换。对于Unicode(UCS2)、 GBK、UTF-8这些编码方式，我原来就了解。但这个程序让我有些糊涂，想不起来UTF-16和UCS2有什么关系。

查了查相关资料，总算将这些问题弄清楚了，顺带也了解了一些Unicode的细节。写成一篇文章，送给有过类似疑问的朋友。本文在写作时尽量做到通俗易懂，但要求读者知道什么是字节，什么是十六进制。

0、big endian和little endian

big endian和little endian是CPU处理多字节数的不同方式。例如“汉”字的Unicode编码是6C49。那么写到文件里时，究竟是将6C写在前面，还是将49写在前面？如果将6C写在前面，就是big endian。如果将49写在前面，就是little endian。

“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开，由此曾发生过六次叛乱，一个皇帝送了命，另一个丢了王位。

我们一般将endian翻译成“字节序”，将big endian和little endian称作“大尾”和“小尾”。

1、字符编码、内码，顺带介绍汉字编码

字符必须编码后才能被计算机处理。计算机使用的缺省编码方式就是计算机的内码。早期的计算机使用7位的ASCII编码，为了处理汉字，程序员设计了用于简体中文的GB2312和用于繁体中文的big5。

GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。

GB2312支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。

从ASCII、GB2312到GBK，这些编码方法是向下兼容的，即同一个字符在这些方案中总是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文可以统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB2312、GBK都属于双字节字符集 (DBCS)。

2000年的GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。从汉字字汇上说，GB18030在GB13000.1的20902个汉字的基础上增加了CJK扩展A的6582个汉字（Unicode码 0x3400-0x4db5），一共收录了27484个汉字。

CJK就是中日韩的意思。Unicode为了节省码位，将中日韩三国语言中的文字统一编码。GB13000.1就是ISO/IEC 10646-1的中文版，相当于Unicode 1.1。

GB18030的编码采用单字节、双字节和4字节方案。其中单字节、双字节和GBK是完全兼容的。4字节编码的码位就是收录了CJK扩展A的6582个汉字。例如：UCS的0x3400在GB18030中的编码应该是8139EF30，UCS的0x3401在GB18030中的编码应该是8139EF31。

微软提供了GB18030的升级包，但这个升级包只是提供了一套支持CJK扩展A的6582个汉字的新字体：新宋体-18030，并不改变内码。Windows 的内码仍然是GBK。

这里还有一些细节：

GB2312的原文还是区位码，从区位码到内码，需要在高字节和低字节上分别加上A0。
对于任何字符编码，编码单元的顺序是由编码方案指定的，与endian无关。例如GBK的编码单元是字节，用两个字节表示一个汉字。这两个字节的顺序是固定的，不受CPU字节序的影响。UTF-16的编码单元是word（双字节），word之间的顺序是编码方案指定的，word内部的字节排列才会受到endian的影响。后面还会介绍UTF-16。
GB2312 的两个字节的最高位都是1。但符合这个条件的码位只有128*128=16384个。所以GBK和GB18030的低字节最高位都可能不是1。不过这不影响DBCS字符流的解析：在读取DBCS字符流时，只要遇到高位为1的字节，就可以将下两个字节作为一个双字节编码，而不用管低字节的高位是什么。

2、Unicode、UCS和UTF

前面提到从ASCII、GB2312、GBK到GB18030的编码方法是向下兼容的。而Unicode只与ASCII兼容（更准确地说，是与ISO-8859-1兼容），与GB码不兼容。例如“汉”字的Unicode编码是6C49，而GB码是BABA。

Unicode也是一种字符编码方法，不过它是由国际组织设计，可以容纳全世界所有语言文字的编码方案。Unicode的学名是"Universal Multiple-Octet Coded Character Set"，简称为UCS。UCS可以看作是"Unicode Character Set"的缩写。

根据维基百科全书(http://zh.wikipedia.org/wiki/)的记载：历史上存在两个试图独立设计Unicode的组织，即国际标准化组织（ISO）和一个软件制造商的协会（unicode.org）。ISO开发了ISO 10646项目，Unicode协会开发了Unicode项目。

在1991年前后，双方都认识到世界不需要两个不兼容的字符集。于是它们开始合并双方的工作成果，并为创立一个单一编码表而协同工作。从Unicode2.0开始，Unicode项目采用了与ISO 10646-1相同的字库和字码。

目前两个项目仍都存在，并独立地公布各自的标准。Unicode协会现在的最新版本是2005年的Unicode 4.1.0。ISO的最新标准是ISO 10646-3:2003。

UCS只是规定如何编码，并没有规定如何传输、保存这个编码。例如“汉”字的UCS编码是6C49，我可以用4个ascii数字来传输、保存这个编码；也可以用utf-8编码:3个连续的字节E6 B1 89来表示它。关键在于通信双方都要认可。UTF-8、UTF-7、UTF-16都是被广泛接受的方案。UTF-8的一个特别的好处是它与ISO-8859-1完全兼容。UTF是“UCS Transformation Format”的缩写。

IETF的RFC2781和RFC3629以RFC的一贯风格，清晰、明快又不失严谨地描述了UTF-16和UTF-8的编码方法。我总是记不得IETF是Internet Engineering Task Force的缩写。但IETF负责维护的RFC是Internet上一切规范的基础。

2.1、内码和code page

目前Windows的内核已经支持Unicode字符集，这样在内核上可以支持全世界所有的语言文字。但是由于现有的大量程序和文档都采用了某种特定语言的编码，例如GBK，Windows不可能不支持现有的编码，而全部改用Unicode。

Windows使用代码页(code page)来适应各个国家和地区。code page可以被理解为前面提到的内码。GBK对应的code page是CP936。

微软也为GB18030定义了code page：CP54936。但是由于GB18030有一部分4字节编码，而Windows的代码页只支持单字节和双字节编码，所以这个code page是无法真正使用的。

3、UCS-2、UCS-4、BMP

UCS有两种格式：UCS-2和UCS-4。顾名思义，UCS-2就是用两个字节编码，UCS-4就是用4个字节（实际上只用了31位，最高位必须为0）编码。下面让我们做一些简单的数学游戏：

UCS-2有2^16=65536个码位，UCS-4有2^31=2147483648个码位。

UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据次高字节分为256个plane。每个plane根据第3个字节分为256行 (rows)，每行包含256个cells。当然同一行的cells只是最后一个字节不同，其余都相同。

group 0的plane 0被称作Basic Multilingual Plane, 即BMP。或者说UCS-4中，高两个字节为0的码位被称作BMP。

将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。在UCS-2的两个字节前加上两个零字节，就得到了UCS-4的BMP。而目前的UCS-4规范中还没有任何字符被分配在BMP之外。

4、UTF编码

UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下：

UCS-2编码(16进制)	UTF-8 字节流(二进制)
0000 - 007F	0xxxxxxx
0080 - 07FF	110xxxxx 10xxxxxx
0800 - FFFF	1110xxxx 10xxxxxx 10xxxxxx

例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间，所以肯定要用3字节模板了：1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是：0110 110001 001001，用这个比特流依次代替模板中的x，得到：11100110 10110001 10001001，即E6 B1 89。

读者可以用记事本测试一下我们的编码是否正确。需要注意，UltraEdit在打开utf-8编码的文本文件时会自动转换为UTF-16，可能产生混淆。你可以在设置中关掉这个选项。更好的工具是Hex Workshop。

UTF-16以16位为单元对UCS进行编码。对于小于0x10000的UCS码，UTF-16编码就等于UCS码对应的16位无符号整数。对于不小于0x10000的UCS码，定义了一个算法。不过由于实际使用的UCS2，或者UCS4的BMP必然小于0x10000，所以就目前而言，可以认为 UTF-16和UCS-2基本相同。但UCS-2只是一个编码方案，UTF-16却要用于实际的传输，所以就不得不考虑字节序的问题。

5、UTF的字节序和BOM

UTF-8以字节为编码单元，没有字节序的问题。UTF-16以两个字节为编码单元，在解释一个UTF-16文本前，首先要弄清楚每个编码单元的字节序。例如“奎”的Unicode编码是594E，“乙”的Unicode编码是4E59。如果我们收到UTF-16字节流“594E”，那么这是“奎” 还是“乙”？

Unicode规范中推荐的标记字节顺序的方法是BOM。BOM不是“Bill Of Material”的BOM表，而是Byte Order Mark。BOM是一个有点小聪明的想法：

在UCS编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输字符"ZERO WIDTH NO-BREAK SPACE"。

这样如果接收者收到FEFF，就表明这个字节流是Big-Endian的；如果收到FFFE，就表明这个字节流是Little-Endian的。因此字符"ZERO WIDTH NO-BREAK SPACE"又被称作BOM。

UTF-8不需要BOM来表明字节顺序，但可以用BOM来表明编码方式。字符"ZERO WIDTH NO-BREAK SPACE"的UTF-8编码是EF BB BF（读者可以用我们前面介绍的编码方法验证一下）。所以如果接收者收到以EF BB BF开头的字节流，就知道这是UTF-8编码了。

Windows就是使用BOM来标记文本文件的编码方式的。

6、进一步的参考资料

本文主要参考的资料是 "Short overview of ISO-IEC 10646 and Unicode" (http://www.nada.kth.se/i18n/ucs/unicode-iso10646-oview.html)。

我还找了两篇看上去不错的资料，不过因为我开始的疑问都找到了答案，所以就没有看：

"Understanding Unicode A general introduction to the Unicode Standard" (http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter04a)
"Character set encoding basics Understanding character set encodings and legacy encodings" (http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&item_id=IWS-Chapter03)

我写过UTF-8、UCS-2、GBK相互转换的软件包，包括使用Windows API和不使用Windows API的版本。以后有时间的话，我会整理一下放到我的个人主页上(http://fmddlmyy.home4u.china.com)。

我是想清楚所有问题后才开始写这篇文章的，原以为一会儿就能写好。没想到考虑措辞和查证细节花费了很长时间，竟然从下午1:30写到9:00。希望有读者能从中受益。

附录1 再说说区位码、GB2312、内码和代码页

有的朋友对文章中这句话还有疑问：
“GB2312的原文还是区位码，从区位码到内码，需要在高字节和低字节上分别加上A0。”

我再详细解释一下：

“GB2312的原文”是指国家1980年的一个标准《中华人民共和国国家标准信息交换用汉字编码字符集基本集 GB 2312-80》。这个标准用两个数来编码汉字和中文符号。第一个数称为“区”，第二个数称为“位”。所以也称为区位码。1-9区是中文符号，16-55 区是一级汉字，56-87区是二级汉字。现在Windows也还有区位输入法，例如输入1601得到“啊”。（这个区位输入法可以自动识别16进制的 GB2312和10进制的区位码，也就是说输入B0A1同样会得到“啊”。）

内码是指操作系统内部的字符编码。早期操作系统的内码是与语言相关的。现在的Windows在系统内部支持Unicode，然后用代码页适应各种语言，“内码”的概念就比较模糊了。微软一般将缺省代码页指定的编码说成是内码。

内码这个词汇，并没有什么官方的定义，代码页也只是微软这个公司的叫法。作为程序员，我们只要知道它们是什么东西，没有必要过多地考证这些名词。

所谓代码页(code page)就是针对一种语言文字的字符编码。例如GBK的code page是CP936，BIG5的code page是CP950，GB2312的code page是CP20936。

Windows中有缺省代码页的概念，即缺省用什么编码来解释字符。例如Windows的记事本打开了一个文本文件，里面的内容是字节流：BA、BA、D7、D6。Windows应该去怎么解释它呢？

是按照Unicode编码解释、还是按照GBK解释、还是按照BIG5解释，还是按照ISO8859-1去解释？如果按GBK去解释，就会得到“汉字”两个字。按照其它编码解释，可能找不到对应的字符，也可能找到错误的字符。所谓“错误”是指与文本作者的本意不符，这时就产生了乱码。

答案是Windows按照当前的缺省代码页去解释文本文件里的字节流。缺省代码页可以通过控制面板的区域选项设置。记事本的另存为中有一项ANSI，其实就是按照缺省代码页的编码方法保存。

Windows的内码是Unicode，它在技术上可以同时支持多个代码页。只要文件能说明自己使用什么编码，用户又安装了对应的代码页，Windows就能正确显示，例如在HTML文件中就可以指定charset。

有的HTML文件作者，特别是英文作者，认为世界上所有人都使用英文，在文件中不指定charset。如果他使用了0x80-0xff之间的字符，中文Windows又按照缺省的GBK去解释，就会出现乱码。这时只要在这个html文件中加上指定charset的语句，例如：

如果原作者使用的代码页和ISO8859-1兼容，就不会出现乱码了。

再说区位码，啊的区位码是1601，写成16进制是0x10,0x01。这和计算机广泛使用的ASCII编码冲突。为了兼容00-7f的ASCII 编码，我们在区位码的高、低字节上分别加上A0。这样“啊”的编码就成为B0A1。我们将加过两个A0的编码也称为GB2312编码，虽然GB2312的原文根本没提到这一点。

Pudgy's World 2005-08-29 11:39 发表评论

Gmail Invitation Send

Pudgy's World — Sat, 27 Aug 2005 02:43:00 GMT

本人还有N多的Gmail Invitation 放送，要的留言。

Pudgy's World 2005-08-27 10:43 发表评论

DotDashBorder 可以实现点划线的CustomBorder

Pudgy's World — Sat, 27 Aug 2005 02:19:00 GMT

一个Custom Border
可以实现点划线的Border.
代码如下：

import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;

/**
* DotDashBorder is a java.swing.border.Border implementation
* that draws a dotted and/or dashed line border.  The dot/dash pattern is
* defined as an array of ints, with every two indices defining the number
* of pixels for each dot/dash and space.  E.g.:

* { 1, 1 } == 1-pixel-dot, 1-pixel-space, 1-pixel-dot, 1-pixel-space, etc.

* { 4, 2 } == 4-pixel-dash, 2-pixel-space, 4-pixel-dash, 2-pixel-space, etc.

*/
public class DotDashBorder extends AbstractBorder {
    /**
     * Defines a dotted line pattern:

. . . .

     */
    public static final int[] DOT = { 1, 1 };

    /**
     * Defines a dashed line pattern:

- - - -

     */
    public static final int[] DASH_SHORT = { 4, 4 };

    /**
     * Defines a long dashed line pattern:

---   ---   ---

     */
    public static final int[] DASH_LONG = { 10, 10 };

    /**
     * Defines a long/short dashed line pattern:

-- - -- - -- -

     */
    public static final int[] DASH_LONG_SHORT = { 6, 3, 3, 3 };

    /**
     * Defines a long/short/short dashed line pattern:

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

     */
    public static final int[] DASH_LONG_SHORT_SHORT = { 6, 3, 3, 3, 3, 3 };

    /**
     * The dot/dash pattern.
     */
    private int[] pattern = DOT;

    /**
     * The border thickness
     */
    private int thickness = 1;

    /**
     * The foreground color.  If not specified, the component's foreground
     * color is used.
     */
    private Color colorFG = null;

    /**
     * The background color.  If not specified, the component's background
     * color is used.
     */
    private Color colorBG = null;

    /**
     * Thicken border pattern relative to thickness flag.
     */
    private boolean thicken = false;

    /**
     * Create a new 1-pixel thick DotDashBorder using the component's
     * background color.
     * @param  pattern  int[]: the dot/dash-space pattern
     * @param  fg  Color: the foreground (dot/dash) color
     */
    public DotDashBorder(int[] pattern, Color fg) {
        this(pattern, 1,  fg, null);
    }

    /**
     * Create a new DotDashBorder using the component's foreground and
     * background colors.
     * @param  pattern  int[]: the dot/dash-space pattern
     * @param  thickness  int: the border thickness
     */
    public DotDashBorder(int[] pattern, int thickness) {
        this(pattern, thickness, null, null);
    }

    /**
     * Create a new DotDashBorder using the component's
     * background color.
     * @param  pattern  int[]: the dot/dash-space pattern
     * @param  thickness  int: the border thickness
     * @param  fg  Color: the foreground (dot/dash) color
     */
    public DotDashBorder(int[] pattern, int thickness, Color fg) {
        this(pattern, thickness,  fg, null);
    }

    /**
     * Create a new DotDashBorder.
     * @param  pattern  int[]: the dot/dash-space pattern
     * @param  thickness  int: the border thickness
     * @param  fg  Color: the foreground (dot/dash) color
     * @param  bg  Color: the background (space) color
     */
    public DotDashBorder(int[] pattern, int thickness, Color fg, Color bg) {
        for(int i = 0; i < pattern.length; i++) {
            if(pattern[i] <= 0) {
                throw new IllegalArgumentException("Pattern cannot have values <= 0.");
            }
        }
        this.pattern = pattern;
        if(thickness <= 0) {
            throw new IllegalArgumentException("Thickness cannot be <= 0.");
        }
        this.thickness = thickness;
        this.colorFG = fg;
        this.colorBG = bg;
    }

    /**
     * Get the insets for the border.
     * @param  Component c: the component the border is for
     * @return  Insets: the insets for the border
     * @see  #getBorderInsets(Component, Insets)
     */
    public Insets getBorderInsets(Component c) {
        return new Insets(thickness, thickness, thickness, thickness);
    }

    /**
     * Get the insets for the border.
     * @param  Component c: the component the border is for
     * @param  insets  Insets: the insets
     * @return  Insets: the insets for the border
     * @see  #getBorderInsets(Component)
     */
    public Insets getBorderInsets(Component c, Insets insets) {
        return new Insets(thickness, thickness, thickness, thickness);
    }

    /**
     * Check if the border is opaque.
     * @return  boolean: true if the border is opaque
     */
    public boolean isBorderOpaque() {
        return true;
    }

    /**
     * Check if pattern will be thickened by thickness.
     * @return  boolean: true if pattern will be thickened by thickness
     * @see  #setThickenPattern(boolean)
     */
    public boolean isThickenPattern() {
        return this.thicken;
    }

    /**
     * Set if the pattern should be thickened by thickness.  If true, a
     * pattern of { 1, 1 } and thickness of 5, the pattern would be expanded
     * to { 5, 5 }.  This allows setting a pattern based on small pixel
     * measurements that grows proportionally with the thickness.
     * @param  boolean t: true if pattern should be thickened by thickness
     * @see  #isThickenPattern()
     */
    public void setThickenPattern(boolean t) {
        this.thicken = t;
    }

    /**
     * Paint the border.
     * @param  Component c: the component the border is for
     * @param  Graphics g: the graphics object to draw on
     * @param  x  int: the border y position
     * @param  y  int: the border x position
     * @param  width  int: the border width
     * @param  height  int: the border height
     */
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
        Color colorFGX = c.getBackground();
        if(colorFG != null) {
            colorFGX = colorFG;
        }
        Color colorBGX = c.getBackground();
        if(colorBG != null) {
            colorBGX = colorBG;
        }
        g.setColor(colorFGX);
        g.fillRect(x, x, width, thickness);                // top
        g.fillRect(x, y+height-thickness, width, thickness);    // bottom
        g.fillRect(x, y, thickness, height);                // left
        g.fillRect(x+width-thickness, y, thickness, height);    // right
        g.setColor(colorBGX);
        // top/bottom
        int cx = 0;
        // get real pattern
        int[] realPattern = new int[pattern.length];
        for(int i = 0; i < pattern.length; i++) {
            if(thicken) {
                realPattern[i] = pattern[i]*thickness;
            } else {
                realPattern[i] = pattern[i];
            }
        }
        for(int i = 0, j = 0; i < width; i++, j+=2) {
            if(j >= realPattern.length) {
                j = 0;
            }
            cx += realPattern[j];
            g.fillRect(cx, y, realPattern[j+1], thickness);                // top
            g.fillRect(cx, y+height-thickness, realPattern[j+1], thickness);    // bottom
            cx += realPattern[j+1];
        }
        // left/right
        int cy = 0;
        for(int i = 0, j = 0; i < height; i++, j+=2) {
            if(j >= realPattern.length) {
                j = 0;
            }
            cy += realPattern[j];
            g.fillRect(x, cy, thickness, realPattern[j+1]);                // left
            g.fillRect(x+width-thickness, cy, thickness, realPattern[j+1]);    // right
            cy += realPattern[j+1];
        }
    }
}

Pudgy's World 2005-08-27 10:19 发表评论

一个简单的SplashScreen

Pudgy's World — Mon, 22 Aug 2005 13:29:00 GMT

最近编写项目，用到一个Splash Screen。
现奉献给大家。

import java.awt.Dimension;
import java.awt.Toolkit;
import java.net.URL;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class SplashScreen extends JFrame {
    /**Date 08.17.2005
     *
     * Splash Screen
     * Very Simple
     * @author Pudgy
     * @version 0.01
     *
     *
     */
    private static final long serialVersionUID = 5124L;

    public SplashScreen() {
        super("Starting jDicomSee");
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Dimension screenSize = toolkit.getScreenSize();
        URL imageURL = searchFile("splash.png");
        if (imageURL != null) {
            getContentPane().add(new JLabel(new ImageIcon(imageURL)));

        }
        setUndecorated(true);
        pack();
        setLocation((screenSize.width - getWidth()) / 2,
                (screenSize.height - getHeight()) / 2);
        setVisible(true);
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private URL searchFile(String fileName) {
        URL url = getClass().getClassLoader().getResource(fileName);
        if (url == null)
            url = getClass().getClassLoader().getResource("images/" + fileName);
        return url;
    }
}

Pudgy's World 2005-08-22 21:29 发表评论

Fat Jar Eclipse Plug-In Tutorial

Pudgy's World — Mon, 22 Aug 2005 12:31:00 GMT

Fat Jar Eclipse Plug-In [FJEP] (http://fjep.sourceforge.net/) 是应用One-Jar(http://one-jar.sourceforge.net/)技术的一个Eclipse 插件。利用FatJar，可以极大地方便发布Java应用程序与Applet。
下面是我写的一个教程，欢迎指教。

1.介绍
一个非常简单的软件打包解决方案，它利用 Java 的定制类装入器，动态地从单一档案文件中装入应用程序所有的类，同时保留支持 JAR 文件的结构。随着 FatJar Eclipse 插件 FJEP 的推出， Eclipse 的用户现在只要在向导中选中一个复选框，就可以创建 One-JAR 应用程序。依赖的库被放进 lib/ 目录，主程序和类被放进 main/main.jar，并自动写好 META-INF/MANIFEST.MF 文件。

2.安装
安装很简单，只需把解压出来的文件放到Eclipse 的目录中即可。

3.使用图解
我以打包我的程序文件作为例子。

(1)在包浏览器面板中，选中Build Fat Jar。

(2)选择主类入口。注意选中Merge individual-sections of all MANIFEST.MF Files.。

(3)选择你要打包的独立JAR文件，这些文件会打包进入最后的Fat-Jar。

(4)成功了。

4.SWT 程序的打包
同样的步骤，只不过最后发布时，连带SWT-XXX.DLL放在同一目录下即可。
参见http://fjep.sourceforge.net/fjepfaq.html

5.下载
http://fjep.sourceforge.net/
也可下载我已打包好的文件。
http://www.blogjava.net/Files/Pudgy/net.sf.fjep.fatjar_0.0.18.rar

Pudgy's World 2005-08-22 20:31 发表评论

基于Batik的SVG应用: 关于几何变换

Pudgy's World — Sat, 20 Aug 2005 00:55:00 GMT

摘自http://www-128.ibm.com/developerworks/cn/xml/x-BatikSvg/?ca=dwcn-newsletter-xml
陈柯
技术总监, 南京安元科技
2005 年 1 月

本文是作者在 SVGGIS 系统的开发实践过程中关于 SVG 坐标转换的总结。在描述 SVG 坐标变换原理的同时，使用 Apache Batik 项目实现了相关例子。

SVG 是一种用 xml 语言来描述二维图形对象的语言，SVG 允许三种图形对象：1．矢量图形，2．图片，3．文本对象。这三种图形对象都可以支持分组，使用样式渲染，进行几何变换。

SVG 还能够通过脚本来实现交互操作和动态显示。可以通过定义动画对象或使用script 脚本来实现动画。

1. SVG 下几种常见的几何变换方式

1.1 一个 SVG 例子
我们首先来看一个 SVG 的例子，窗口右上角有四个色块，每个色块是一个50×50的矩形。

图 1. 一个 SVG 的样本

图 2. 样本文档

1.2 使用 Adobe SVG Viewer 展示在 SVG 文档中实现的几何变换
缩放

图 3. 放大一倍

平移

图 4. 平移200，200个像素

旋转

图 5. 顺时针旋转45度

横切

图 6. 以 y 轴为基线在 X 方向横切45度

2. 在 Batik 下实现 SVG 的几何变换

2.1 Batik 的基础知识
2.1.1 Batik 的用途

Batik 是基于 java 语言实现的一个 SVG 应用的工具集，用于实现对 SVG 对象的显示、编辑以及将 SVG 图形对象转换成其他图片格式，如 jpg、gif 等。

这个项目的目标就是给开发人员一套用于处理或应用 SVG 对象的基础核心模型。作为Apache 项目成员之一，该项目也为开发人员提供了一个开发的可扩展的平台。同时 batik 也维护了一个可以查看 SVG 文件的浏览器。虽然 batik 还没有完全实现 SVG 的所有标准语法和标记，但通过比较不同版本的区别就会发现，他正在以很高的效率覆盖 SVG 所有的标准。

2.1.2 让我们实现一个简单的 Batik 程序

首先让我们实现一个简单的基于 Batik 的 SVG 浏览器。Batik 封装了org.apache.batik.swing.JSVGCanvas 对象可以用于在 swing 中嵌入 SVG 显示容器，并可以通过 org.apache.batik.swing.JSVGCanvas 提供的方法对 SVG 文档和图像进行操作。这个浏览器可以支持大部分 SVG 的语法和标准包括脚本交互的功能，但暂时还没有引入动画。关于动画和脚本交互的内容我们会在以后的文章中讲述，今天先集中解决几何变换的问题。

图 7. 运行程序打开我们编写的 SVG 的例子

可以通过该页面引导运行该程序：
从附件中可以查看该程序的完整代码，也可通过网上下载地址运行该程序。

图 8. 将一个 SVGCanvas 添加到界面


private javax.swing.JPanel SVGPanel = new javax.swing.JPanel();
private JSVGCanvas svgCanvas = new org.apache.batik.swing.JSVGCanvas();
SVGPanel.add("Center", svgCanvas);

2.2 通过 Batik 的 GVT 模型实现 SVG 的几何变换
2.2.1 为什么要使用 Batik 来实现 SVG 的几何变换

当我们用 Batik 工具集作为 SVG 客户端的解决方案时，如缩放平移这样的操作就在所难免了。但 Batik 并没有直接支持如 Adobe SVG Viewer 那样的鼠标拖动几何变换的操作，这就要求我们对这些功能进行编程处理。

在分析 SVG 的几何变换的细节之前，先让我们了解一下基本的操作编程方式。

2.2.2 Batik 下通过 java.awt.geom.AffineTransform 来实现 SVG 的几何变换

JSVGCanvas 提供方法可以获取 java.awt.geom.AffineTransform 对象。AffineTransform 是用于实现2D 几何图形坐标变换处理的对象，可以通过该对象进行二维几何空间中两个坐标系的相互映射和变换。

平移:


//向左和向下平移50个像素
java.awt.geom.AffineTransform  rat = svgCanvas.getRenderingTransform();
rat.translate(50,50);
svgCanvas.setRenderingTransform(rat);

缩放:


//以屏幕左上角原点为固定点进行缩放操作
java.awt.geom.AffineTransform  rat = svgCanvas.getRenderingTransform();
rat.scale(0.5,0.5);
svgCanvas.setRenderingTransform(rat);

旋转:


//以屏幕左上角原点为固定点进行旋转缩放
java.awt.geom.AffineTransform  rat = svgCanvas.getRenderingTransform();
rat.rotate(3.1415926/4);
svgCanvas.setRenderingTransform(rat);

复合变换:


//一个综合平移、放大和旋转90度的复合变换
java.awt.geom.AffineTransform  rat = svgCanvas.getRenderingTransform();
rat.translate(50，50);
rat.scale(2，2);
rat.rotate(3.1415926/4);
svgCanvas.setRenderingTransform(rat);

3. 当我们需要进行复合几何变换的时候

3.1 先来让我们通过不同的变换代码组合实现复合几何变换
先让我们看第一个例子:

//放大一倍和平移50个像素的复合变换


AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.scale(2,2);
rat.translate(50,50);
svgCanvas.setRenderingTransform(rat);

图 9. 复合变换一

可以看得出来，这个变换的最终效果是：图形的形状放大一倍，原图形的（0，0）原点坐标平移100个像素。

再来看第二个例子:


//放大一倍和平移50个像素的复合变换
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.translate(50,50);
rat.scale(2,2);
svgCanvas.setRenderingTransform(rat);

图 10. 复合变换二

这个变换的最终效果是：图形的形状放大一倍，原图形的（0，0）原点坐标平移50个像素。

3.2 关键是顺序
比较一下这两种平移后的效果会发现,只是因为缩放和平移的顺序不同，变换后的结果就发生了区别。第一个例子实际平移的不是50个像素,而是100个像素。而第二个例子则是平移了50个像素。

有兴趣的读者可以添加其他几何变换方式，并测试不同的变换顺序，会发现复合变换的顺序与复合变换的最终效果是紧密相关的。那么如何分析和计算复合变换的变换结果呢？这里我们需要补充一点数学知识了。

3.3 对单一的几何变换进行数学模型分析
对计算机图形学中图形变换相关理论很熟悉的人可以跳过这部分直接看 Batik 的实现方式。这节使用的齐次式图片引用自 SVG标准中关于坐标变换的齐次式的例子插图。

首先我们来了解一下图形变换的齐次式计算方法：

图 11. 基本几何变换齐次式

这是一个基本图形变换齐次式。等式的最右边是一个坐标点未变换前的坐标矩阵，最左边是该坐标点变换后所在位置的一个三行一列的坐标矩阵，中间那个三行三列的矩阵就是变换矩阵。不同的变换方式将对应不同的变换矩阵，图形平移效果就是通过这样一个变换齐次式来实现的。

平移:如果需要将图形平移（tx，ty）个坐标时，采用如下的变换矩阵带入变换方程。

图 12. 平移变换矩阵

缩放：如果需要在 x 轴方向实现 sx 倍缩放，在 y 轴方向实现 sy 轴缩放时，采用如下的变换矩阵带入变换方程。

图 13. 缩放变换矩阵

旋转:如果需要将图像旋转 a 度时，使用如下的变换矩阵带入变换方程。

图 14. 旋转变换矩阵

3.4 采用复合几何变换的数学模型分析
3.4.1 数学分析

当两组变换同时作用于同一个图像时，连续使用该等式，得出如下等式。由于做变换的时候是将变换矩阵放在矩阵积的左边，所以对于复合变换的式子，应该从右向左进行读。对于如下的式子：从右至左依次是变换前的坐标，第一次转换的转换矩阵，第二次转换的转换矩阵，转换后的坐标值。

图 15. 进行两次变换的复合矩阵

进一步推导 n 次几何变换的复合变换等式：

图 16. n次变换的复合矩阵

3.4.2 来实践一下

图 17. 变换前效果

使用这样一个复合变换方式：

根据前面的分析结果带入变换方程，得出如下等式

图 18. 推导矩阵

根据计算后的变换矩阵，可得变换结果是图形整体平移到（255.03,111.21），同时图形自身沿顺时针方向旋转45度。查看实际变换结果，这里我们可以发现，对于 SVG 的变换来说，虽然我们习惯上从左往右写变换参数的，实际上图形做变换的时候是从右边的变换参数开始依次进行图形变换的。

图 19. 变换后效果

3.5 分析一下 Batik 是如何实现 SVG 的复合几何变换的
3.5.1 先看第一个例子：

这个变换是先放大后平移的变换，其变换效果最终是，先将图形的形状放大一倍，然后将图形整个平移100个像素。这里我们可以看出，虽然我们是先进行的放大变换，后进行的平移操作，但当我们进行复合变换的时候由于实际运算时上是先进行了平移，后进行了缩放。或者简单的理解为从左向右先写缩放矩阵，再写平移矩阵，这样得出的变换矩阵就可以对变换后的效果进行计算了。


//放大一倍和平移50个像素的复合变换
//
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.scale(2,2);
rat.translate(50,50);
svgCanvas.setRenderingTransform(rat);

我们可以将这个变换对应的计算矩阵写出来：

图 20. 复合变换例一的变换矩阵

根据上面的分析我们可以看的出，先进行缩放变换在进行平移变换的复合变换时，变换后原图元的坐标会映射到新的位置，其中：

X1=Sx(X+dx)
Y1=Sy(Y+dy)

3.5.2 再来看第二个例子：

这个变换是先放大后平移的变换，其变换效果最终是，先将图形整个平移50个像素，然后将图形的形状放大一倍。


//放大一倍和平移50个像素的复合变换
//
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.translate(50,50);
rat.scale(2,2);
svgCanvas.setRenderingTransform(rat);

我们可以将这个变换对应的 svg 文档实现写出来：

图 21. 复合变换例二的变换矩阵

根据上面的分析我们可以看的出，先进行平移变换再进行缩放变换的复合变换时，变换后原图元的坐标会映射到新的位置，其中：

X1=Sx*X+dx
Y1=Sy*Y+dy

3.5.3 实用这两个例子的成果

假设我们需要将图形原点的位置移动到（150，300），同时形状放大到原来的3倍，该如何进行变换来实现这样的效果呢？

图 22. 变换效果

使用第一个例子的分析结果，先进行缩放变换，再进行平移变换的方程变换：

图 23. 方程推演

根据推导可知需先进行3倍的缩放变换，再平移（50，100）个坐标就可以实现指定的变换效果。实现程序如下


//
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.scale(3,3);
rat.translate(50,100);
svgCanvas.setRenderingTransform(rat);

若先进行平移变换，再进行缩放变换的话，根据第二个例子的推导结果：

图 24. 方程推演

可知应先进行（150，300）的平移操作，再实现3倍的缩放操作。实现程序如下：


//
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.translate(150,300);
rat.scale(3,3);
svgCanvas.setRenderingTransform(rat);

4. 一个常用复合变换实例的实现--定点变换
上边我们分析了 Batik 实现 SVG 图形变换的原理和计算方法。下面我们用分析的结果实现一个常用的变换实例：定点变换。变换的种类包括缩放，旋转（一般不考虑定点平移这个概念）。

所谓定点变换就是在图形变换中指定一个固定的点，在变换结束后，该点的位置不发生变化。定点变换在 GIS 的实际运用中很常见，比如将地图放大到指定倍数而保持地图的某个位置（如：鼠标点击的位置）不发生变化。我们以定点缩放为例描述定点变换的使用方法。

假设我们用(x1,y1)点来做定点变换的基准点进行几何变换，要求实现变换后（x1,y1）的位置不变。

定点变换的基本思想是基于这样一个特性：当图像进行缩放，或旋转变换的时候，坐标原点的位置并不发生变化。定点变换的实现方法就是，先将基准点（x1,y1）平移到原点即做一次[-x1,-y1]变换，进行变换后再将变换后的原点平移到（x1,y1）即再进行一次[x1,y1]变换。

图 25. 基于（x1,y1）定点变换

实际编程的时候，我们无需对定点变换做如此复杂的运算。例如可以采用如下的方式实现针对（50,50）的定点变换：


//以（50，50）点为基准点进行几何变换
//
AffineTransform rat = svgCanvas.getRenderingTransform();

        rat.translate(50，50);
//其他变换方式
………………
………………
………………
rat.translate(-50,-50);
svgCanvas.setRenderingTransform(rat);

参考资料

有关 SVG 的背景知识，请阅读 developerWorks 上的教程，" 可伸缩向量图形介绍"
Scalable Vector Graphics (SVG) 1.0 Specification
Batik项目介绍 http://xml.apache.org/batik/

Pudgy's World 2005-08-20 08:55 发表评论

log4j Tutorials

Pudgy's World — Thu, 18 Aug 2005 08:58:00 GMT

1. 简介

2. 安装

3. log4j基本概念

3.1. Logger

3.2. Appender

3.2.1. 使用ConsoleAppender
3.2.2. 使用FileAppender
3.2.3. 使用WriterAppender

3.3. Layout

3.4. 基本示例

3.4.1. SimpleLayout和FileAppender
3.4.2. HTMLLayout和WriterAppender
3.4.3. PatternLayout和ConsoleAppender

4. 使用外部配置文件

5. 参考资料 (以及一些有参考价值的链接)

1.简介

程序开发环境中的日志记录是由嵌入在程序中以输出一些对开发人员有用信息的语句所组成。例如，跟踪语句（trace），结构转储和常见的 System.out.println或printf调试语句。log4j提供分级方法在程序中嵌入日志记录语句。日志信息具有多种输出格式和多个输出级别。

使用一个专门的日志记录包，可以减轻对成千上万的System.out.println语句的维护成本，因为日志记录可以通过配置脚本在运行时得以控制。 log4j维护嵌入在程序代码中的日志记录语句。通过规范日志记录的处理过程，一些人认为应该鼓励更多的使用日志记录并且获得更高程度的效率。

2.安装

为了使用我们即将要安装的日志记录工具，还必须要设置操作环境，只有这样，工具才能知道从哪里找到它所需要的信息，并且操作系统知道从哪里找到这个工具。那么，怎样做呢？实际上，它要求更改操作环境。我有一些这方面的资格文档。 Configuring A Windows Working Environment 和 Configuring A Unix Working Environment.

从 http://jakarta.apache.org/log4j/docs/download.html下载log4j发行版。
解压存档文件到合适的目录中。
添加文件 dist/lib/log4j-1.2.6.jar 到 CLASSPATH 环境变量中。

3.log4j的基本概念

使用log4j大概涉及3个主要概念:

公共类 Logger

Logger 负责处理日志记录的大部分操作。
公共接口 Appender

Appender 负责控制日志记录操作的输出。
公共抽象类Layout

Layout 负责格式化Appender的输出。

3.1.Logger

日志记录器(Logger)是日志处理的核心组件。log4j具有5种正常级别(Level)。日志记录器(Logger)的可用级别Level (不包括自定义级别 Level)，以下内容就是摘自log4j API (http://jakarta.apache.org/log4j/docs/api/index.html):

static Level DEBUG

DEBUG Level指出细粒度信息事件对调试应用程序是非常有帮助的。
static Level INFO

INFO level表明消息在粗粒度级别上突出强调应用程序的运行过程。
static Level WARN

WARN level表明会出现潜在错误的情形。
static Level ERROR

ERROR level指出虽然发生错误事件，但仍然不影响系统的继续运行。
static Level FATAL

FATAL level指出每个严重的错误事件将会导致应用程序的退出。

另外，还有两个可用的特别的日志记录级别: (以下描述来自log4j API http://jakarta.apache.org/log4j/docs/api/index.html):

static Level ALL

ALL Level是最低等级的，用于打开所有日志记录。
static Level OFF

OFF Level是最高等级的，用于关闭所有日志记录。

日志记录器（Logger）的行为是分等级的。如下表所示：

图.日志输出等级

有很多方法可以创建一个日志记录器（Logger），下面方法可以取回root日志记录器:

Logger logger = Logger.getRootLogger();

还可以这样创建一个新的日志记录器:

Logger logger = Logger.getLogger("MyLogger");

比较常用的用法，就是根据类名实例化一个静态的全局日志记录器:

static Logger logger = Logger.getLogger(test.class);

所有这些创建的叫"logger"的日志记录器都可以用下面方法设置级别:

logger.setLevel((Level)Level.WARN);

可以使用7个级别中的任何一个; Level.DEBUG, Level.INFO, Level.WARN, Level.ERROR, Level.FATAL, Level.ALL and Level.OFF.

3.2.Appender

Appender 控制日志怎样输出。下面列出一些可用的Appender(log4j API中所描述的 http://jakarta.apache.org/log4j/docs/api/index.html):

ConsoleAppender:使用用户指定的布局(layout) 输出日志事件到System.out或者 System.err。默认的目标是System.out。
DailyRollingFileAppender 扩展FileAppender，因此多个日志文件可以以一个用户选定的频率进行循环日志记录。
FileAppender 把日志事件写入一个文件
RollingFileAppender 扩展FileAppender备份容量达到一定大小的日志文件。
WriterAppender根据用户的选择把日志事件写入到Writer或者OutputStream。
SMTPAppender 当特定的日志事件发生时，一般是指发生错误或者重大错误时，发送一封邮件。
SocketAppender 给远程日志服务器（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。
SocketHubAppender 给远程日志服务器群组（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。
SyslogAppender给远程异步日志记录的后台精灵程序(daemon)发送消息。
TelnetAppender 一个专用于向只读网络套接字发送消息的log4j appender。

还可以实现 Appender 接口，创建以自己的方式进行日志输出的Appender。

3.2.1.使用ConsoleAppender

ConsoleAppender可以用这种方式创建：

ConsoleAppender appender = new ConsoleAppender(new PatternLayout());

创建了一个控制台appender，具有一个默认的PatternLayout。它使用了默认的System.out 输出。

3.2.2.使用FileAppender

FileAppender可以用这种方式创建:

          FileAppender appender = null;
          try {
             appender = new FileAppender(new PatternLayout(),"filename");
          } catch(Exception e) {}

上面用到的构造函数:

FileAppender(Layout layout, String filename) 
          实例化一个FileAppender并且打开变量"filename"指定的文件。

另一个有用的构造函数是：

FileAppender(Layout layout, String filename, boolean append) 
          实例化一个FileAppender并且打开变量"filename"指定的文件。

这个构造函数还可以选择是否对指定的文件进行追加的方式输出。如果没有指定值，那么默认的方式就是追加。

3.2.3.使用WriterAppender

WriterAppender可以用这种方式创建:

          WriterAppender appender = null;
          try {
            appender = new WriterAppender(new PatternLayout(),new FileOutputStream("filename"));
          } catch(Exception e) {}

这个WriterAppender使用的构造函数带有PatternLayout和OutputStream参数，在这种情况下， FileOutputStream用于向一个文件输出。当然，它还具有其他可用的构造函数。

3.3.Layout

HTMLLayout 格式化日志输出为HTML表格。
PatternLayout 根据指定的 转换模式格式化日志输出，或者如果没有指定任何转换模式，就使用默认的转换模式。
SimpleLayout 以一种非常简单的方式格式化日志输出，它打印级别 Level，然后跟着一个破折号“-“ ，最后才是日志消息。

3.4.基本示例

3.4.1.SimpleLayout和 FileAppender

这里是一个非常简单的例子，程序实现了SimpleLayout和FileAppender:

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.FileAppender;
public class simpandfile {
   static Logger logger = Logger.getLogger(simpandfile.class);
   public static void main(String args[]) {
      SimpleLayout layout = new SimpleLayout();
      FileAppender appender = null;
      try {
         appender = new FileAppender(layout,"output1.txt",false);
      } catch(Exception e) {}
      logger.addAppender(appender);
      logger.setLevel((Level) Level.DEBUG);
      logger.debug("Here is some DEBUG");
      logger.info("Here is some INFO");
      logger.warn("Here is some WARN");
      logger.error("Here is some ERROR");
      logger.fatal("Here is some FATAL");
   }
}

你可以下载: simpandfile.java。还可以查看它的输出： output1.txt.

3.4.2.HTMLLayout和 WriterAppender

这里是一个非常简单的例子，程序实现了 HTMLLayout和WriterAppender:

import java.io.*;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.HTMLLayout;
import org.apache.log4j.WriterAppender;
public class htmlandwrite {
   static Logger logger = Logger.getLogger(htmlandwrite.class);
   public static void main(String args[]) {
      HTMLLayout layout = new HTMLLayout();
      WriterAppender appender = null;
      try {
         FileOutputStream output = new FileOutputStream("output2.html");
         appender = new WriterAppender(layout,output);
      } catch(Exception e) {}
      logger.addAppender(appender);
      logger.setLevel((Level) Level.DEBUG);
      logger.debug("Here is some DEBUG");
      logger.info("Here is some INFO");
      logger.warn("Here is some WARN");
      logger.error("Here is some ERROR");
      logger.fatal("Here is some FATAL");
   }
}

你可以下载: simpandfile.java. 还可以查看它的输出：output1.txt.

3.4.3.PatternLayout和 ConsoleAppender

这里是一个非常简单的例子，程序实现了PatternLayout和ConsoleAppender:

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.ConsoleAppender;
public class consandpatt {
   static Logger logger = Logger.getLogger(consandpatt.class);
   public static void main(String args[]) {
      // Note, %n is newline
      String pattern =  "Milliseconds since program start: %r %n";
             pattern += "Classname of caller: %C %n";
             pattern += "Date in ISO8601 format: %d{ISO8601} %n";
             pattern += "Location of log event: %l %n";
             pattern += "Message: %m %n %n"; 
      
      PatternLayout layout = new PatternLayout(pattern);
      ConsoleAppender appender = new ConsoleAppender(layout);
      logger.addAppender(appender);
      logger.setLevel((Level) Level.DEBUG);
      logger.debug("Here is some DEBUG");
      logger.info("Here is some INFO");
      logger.warn("Here is some WARN");
      logger.error("Here is some ERROR");
      logger.fatal("Here is some FATAL");
   }
}

你可以下载:simpandfile.java. 还可以查看它的输出： output2.txt.

4.使用外部配置文件

Log4j经常与外部日志文件联合使用，这样很多可选项不必硬编码在软件中。使用外部配置文件的优点就是修改可选项不需要重新编译程序。唯一的缺点就是，由于用到io 指令，速度稍微有些减慢。

有两个方法可以用来指定外部配置文件：文本文件或者XML文件。既然现在所有事情都写成XML文件，那么该教程就重点讲解XML文件方法，但是也包含相关文本文件的例子。首先，看看下面的XML配置文件示例：

文件以标准的XML声明作为开始，后面跟着指出DTD（文档类型定义）的DOCTYPE声明，它定义了XML文件的结构，例如，什么元素可以嵌入在其他元素中等等。上面文件在log4j发行版的src/java/org/apache/log4j/xml目录中。接着看看封装所有元素的 log4j:configuration 元素，它在DOCTYPE声明中被指定为根元素。嵌入在根元素中有两个结构：

这里创建一个名叫"ConsoleAppender"的 Appender，注意，你可以选择任何名字，该示例之所以选择"ConsoleAppender"，完全是为了示例的设计。接着这个appender类以全名形式给出，经常用规范（fully qualified）类名。 Appender必须具有一个指定的 name和class。嵌入在 Appender之内的是 layout元素，这里它被指定为SimpleLayout。 Layout 必须具有一个 class属性。

root元素必须存在且不能被子类化。示例中的优先级被设置为"debug"，设置appender饱含一个appender-ref元素。还有更多的属性或元素可以指定。查看log4j发行版中的src/java/org/apache/log4j/xml/log4j.dtd以了解关于XML配置文件结构的更多信息。可以用下面这种方法把配置信息文件读入到Java程序中:

DOMConfigurator.configure("configurationfile.xml");

DOMConfigurator 用一棵DOM树来初始化log4j环境。这里是示例中的XML配置文件：plainlog4jconfig.xml。这里是执行该配置文件的程序: files/externalxmltest.java:

import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;
public class externalxmltest {
   static Logger logger = Logger.getLogger(filetest.class);
   public static void main(String args[]) {
      DOMConfigurator.configure("xmllog4jconfig.xml");
      logger.debug("Here is some DEBUG");
      logger.info("Here is some INFO");
      logger.warn("Here is some WARN");
      logger.error("Here is some ERROR");
      logger.fatal("Here is some FATAL");
   }
}

这里是一个实现带有PatternLayout的FileAppender的日志记录器Logger的XML配置文件:

你可以从这里下载示例: xmllog4jconfig2.xml。想要得到更多的使用XML文件配置log4j环境的例子，请查看log4j发行版的目录src/java/org/apache/log4j/xml/examples/ 。

这就是上面讨论的文本文件形式的配置文件:

# initialise root logger with level DEBUG and call it BLAH
log4j.rootLogger=DEBUG, BLAH
# add a ConsoleAppender to the logger BLAH
log4j.appender.BLAH=org.apache.log4j.ConsoleAppender
# set set that layout to be SimpleLayout
log4j.appender.BLAH.layout=org.apache.log4j.SimpleLayout

从这里可以下载: plainlog4jconfig.txt。这就是执行该配置文件的程序:

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
public class externalplaintest {
   static Logger logger = Logger.getLogger(externalplaintest.class);
   public static void main(String args[]) {
      PropertyConfigurator.configure("plainlog4jconfig.xml");
      logger.debug("Here is some DEBUG");
      logger.info("Here is some INFO");
      logger.warn("Here is some WARN");
      logger.error("Here is some ERROR");
      logger.fatal("Here is some FATAL");
   }
}

你可以下载使用该配置文件的示例： externalplaintest.java。想要获得更多的使用文本文件配置log4j环境的例子，请查看log4j发行版中的目录examples。

使用外部配置文件的例子就简单的讨论到这里，现在应该可以肯定你已经有能力独立学习更多的log4j发行版和测试版中提供的例子。

5.参考资料 (以及一些有参考价值的链接)

http://jakarta.apache.org/log4j/docs/manual.html

log4j的简明介绍 - Ceki G- 2002年3月
http://www.vipan.com/htdocs/log4jhelp.html

不要用System.out.println！用Log4j - Vipan Singla
http://www.opensymphony.com/guidelines/logging.jsp

LOG4J / OpenSymphony日志记录入门
http://builder.com.com/article.jhtml?id=u00820020124kev01.htm

给你的Java应用程序添加日志记录 - Kevin Brown

Pudgy's World 2005-08-18 16:58 发表评论

程序员心声

Pudgy's World — Tue, 16 Aug 2005 04:58:00 GMT

这些日子我一直在写一个实时操作系统内核，已有小成了，等写完我会全部公开，希望能够为国内IT的发展尽自己一份微薄的力量。最近看到很多学生朋友和我当年一样没有方向，所以把我的经历写出来与大家共勉，希望能给刚如行的朋友们一点点帮助。一转眼我在IT行业学习工作已经七年多了，这期间我做过网页，写过MIS、数据库，应用程序，做过通信软件、硬件驱动、协议栈，到现在做操作系统内核和IC相关开发，这中间走了很多弯路，也吃了不少苦。
我上的是一个三流的高校，就连同一个城市的人多数都不知道。因为学校不好也就没有指望能靠学校名气找一个好工作。所有的希望都寄托在自己的努力上了，大一开学前的假期我就开始了学习，记得我买的第一本书是《计算机基础DOS3.0》，大家别吓着了，其实当时已经普及了DOS6.22了，只是我在书店里看到了DOS4.0，5.0，6.0的书，以为像英语那样是第四、五、六册，记得当时到处找DOS1.0，现在想想也幸好我没有找到：）开学前我学完了PASCAL，那时既没有计算机也没有人可以请教，我连程序是什么的概念都没有，只好死记硬背代码，然后拿纸写，我一直到大三才有了一台486，在这之前用纸写了多少程序我也记不清楚了，只知道最长的一个我拿A4大小的草稿纸写了30多页，我的C语言、C++ 、VC都是在这样的条件下入门的。所以说条件是可以克服的，希望我的经历多少给条件艰苦的同学们一点信心。第一次上机是在我姐夫的机房，我的心情激动的无与伦比，但是一上机我立刻傻了眼，他们用的是英文版的Win3.1，我的那点DOS知识都见了鬼，上机提心吊胆的一阵瞎摸，一不小心把Word弄成了全屏，怎么都还不了原，当时真是心急如焚，我以为机器被我弄坏了。第一个C语言程序，就是那个经典的HelloWorld，我调了几个星期，上机机会非常少，也没有书告诉我开发环境（TC2.0）需要设置，而且开始我都不知道有编译器，我甚至自作聪明把写好的程序扩展名从.c改成.exe，结果可想而知。大一学完了C、X86的汇编、数据结构、C++。由于精力都花在自学上了，大一下四门课挂了彩，三类学校就是这点好，挂上一二十门也照样毕业。不过扯远点说，我那么刻苦都及不了格，可见我们国家的计算机教育有多死板。
　　大二准备学VC和BC，当时难以取舍，后来选了VC，不为别的，只为书店里两本书，VC 那本便宜6块钱。我的努力在班上无人能及，学的日夜不分，大三有了计算机后更是如此，很多次父亲半夜教训我说我不要命了，我一直觉得自己基础差，记忆又不行，条件也不好，所以觉得只有多花点时间才能赶上别人。居然后来有许多朋友说我有学计算机的天赋，让我哭笑不得。我用的是486，16M内存，1G硬盘，当时同学们的配置都是P166MMX，我安装一个Windows NT4.0需要一个通宵，编译一个BC5.0向导生成的程序需要近两个小时，我的显示器是个二手的，辐射非常大，开机屏幕冒火花，看起来很酷的：），有一次程序写的太久，觉得怎么白色的编辑器背景变成了紫色，以为显示器坏了，后来才发现眼睛不行了，不过说来也奇怪，到今天我的视力还能保持1.5，真是个奇迹。但是就是那台破机器陪伴了我两年，让我学会了VC、Delphi、SQLServer等。后来那台机器给我阿姨打字用，据她说一天她正打的开心，一股青烟夹着火苗从显示器钻出来，之后它才寿终正寝。
　　大三假期找了个机会在一个计算机研究所实习，与其说实习不如说是做义工，工作了两个月一分钱没有拿。但是这两个月对我的发展帮助很大，让我早一步了解了社会，刚去的时候我当然是一窍不通，在那里我熟悉了网络，学会了Delphi和Oracle。由于工作很认真，得到了比较好的评价，在一位长者的引荐下，我开始和他们一起做项目，这使我在大三大四就有了自己的收入，大四又找了两家MIS公司兼职，虽然钱不多，但是在学生期间有1000多的收入我已经非常满足了，我终于用自己赚的钱把计算机换了。大四下开始找工作，这时我的工作经验已经比较多（当然现在想想非常幼稚），开始听父母的想去那个研究所，实习过那个部门也希望我能去，但是不知道为什么最后不了了之，这种单位就是比较官僚，我一气之下就到了我兼职的一个公司做MIS的TeamLeader。在大三到毕业一年的时间，做过了各种MIS，从煤气、烟厂、公安、铁路、饮食到高校，什么有钱做什么，工作也很辛苦，经常加班和熬通宵，从跟客户谈需求到设计、编码、测试、交付都要上。那时觉得很有成就感，觉得自己还不错，现在想想真是很肤浅。
　　刚走上工作岗位的学生很容易被误导，各种开发工具让人眼花缭乱，同时也觉得很受公司器重，但这样工作永远是一个低层次的开发者。不要跟我说什么系统分析有多么多么重要，多么多么难。你以为自己跟用户谈需求做设计就是系统分析和设计了吗，国内又有几个公司能够做的很到位很规范？我是ISO9000内审员，也在Rational公司受过多次培训，拿了4个证书，还有一个公司让我去做CMM。这些我听过很多，但是很多事情到国内就变了性质，一个公司不是通过了ISO9000或者CMM就能规范了，我现在在一家有几十年历史的外企工作，里面的管理不是一般国内企业能及的。作为一个毕业不久以前没有步入过社会的学生，几乎不可能在很短的时间掌握系统分析和设计，面向对象、UML只是一个工具，关键是人本身的思想，不是说你熟悉了C++、Rose就能够做出好的设计，相反如果你具备了很高的素质，你可以用C写出比别人用C++更加模块化的程序。
　　话说远一些，国内软件开发行业有一个怪圈，很多人觉得VC > Delphi > VB，真是很搞笑。这几个软件我都做过开发，说白了他们都是工具，应该根据应用的需要选择采用哪个，而不是觉得哪个上层次。如果你因为用某个开发工具很有面子而选择的话，只能说明你很浅薄。如果说层次，那么这些工具都不上层次，因为它们用来用去都是一些系统的API，微软的朋友不会因为你记住他们多少个API或者多少个类就会觉得你很了不起，你永远只是他们的客户，他们看重的是你口袋里的银子。我也做过系统内核，我也封装过很多API，同样我也不会看重那些使用这些API做二次开发的客户，除非他能够作出自己独到的设计。
　　至于有人认为C++ > C那更是让人笑掉大牙，不妨你去打听一下，现在有几个操作系统内核是用C++写的，又有几个实时系统用的是C++，当然我也不是说C++不好，但是目前的内核和实时系统中C++还无法与C匹敌，至于说C++适合做应用系统的开发那是另外一回事。所以我的观点是不在于你用什么工具和语言，而在于你干什么工作。你的设计体现了你的技术层次。
　　这样干了一年我觉得非常苦闷，做的大多数都是熟练工种的活，个人技术上没有太多的提高也看不到方向。所以决定离开这个城市去上海，寻求更好的发展，并且打算放弃我以前的MIS转到通信行业。
　　写到这里不能不提到我女朋友，我们是在来上海前半年认识的，她大四在我公司实习，公司派她给我写文档，我们的感情发展的很快。她告诉我很多事情，她家原本是改革开放的第一批暴发户，她母亲爱打牌，输掉了几百万，还欠了很多债，她有男朋友，但是她对他没有感情，只因为他给了她母亲两万多块钱，后来还强迫她写了四万块的借条，她男朋友背叛过她并且不止一次打她，现在逼她结婚不然就要她还钱。这人居然还是一个高校的老师！她母亲把父亲给她的学费花了，因为拖欠学费她没有办法拿到毕业证。她母亲现在有病需要钱，我拿出了自己的一点积蓄并且跟朋友们接了一些，替她交了学费并给她母亲看病（后来才知道看病的钱又不知所终，就连她母亲是不是有病我都不知道，但她也是没有办法）。这个时候我家知道了一些事情，坚决反对我和她在一起，她原来的男朋友也极力破坏。无奈之下我们决定早一定离开这个伤心的城市，并且瞒着我们家。由于时间仓促，我只准备了4000块钱，她仅有的几百块钱也被她母亲要去了，我买了三张票，一张是中午的，两张是晚上的，中午我的家人把我送上船，他们一离开我就下了船，我和她乘坐晚上的船离开了这个我和她生活了很多年的城市，带走的只是一身债务。没有来过上海的我们两个性倔强，都不愿意去麻烦同学和朋友。来到上海是傍晚6点半，我们都不知道该去哪里，我们找了一个20块钱的旅馆，这个房间连窗户都没有，7月份的天气酷热难耐，房间里非常闷热。第二天我们开始租房子，因为身上的钱不多，我们基本都是步行，花了一个星期时间，不知道在浦东转了多少圈后找到了一个400块的房子，但是我们都不了解上海是付三压一，还要付半个月的中介费，买了一些锅碗瓢盆后，我们身上只有800块钱了，工作都还没有着落，这800块钱要支持到我们拿到第一个月工资，为了省钱我们自己做饭，每天买菜只花两块钱，她非常喜欢吃（也可能她在大学经常挨饿的愿意），看到她现在这样省吃俭用我真的很不忍心。她以前的男朋友也没有放过她，经常打电话来骚扰，并且来上海看她，还说了不少恐吓她的话，她过于善良，说他以前毕竟帮助过她，叫我不要与他一般见识。以后的每天在家就是苦等面试通知，原本我想迅速找一家MIS公司解决眼前的困难，但是她坚持让我不要放弃自己的理想，终于功夫不负有心人，我找到了一家通信公司，4000块的工资虽然赶不上MIS公司给我开出的价位，但也够在上海生存。她也找到了工作，第一天上班她哭了，这是她来上海第一次流泪，我心里很难受也很感动。
　　由于是全新的行业，我把自己降到了零点，我学的VC、Delphi、数据库派不上用场，摆在我面前的是嵌入式、协议、信令一些我从未接触过的知识。我知道我没有退路，于是拼命的学习，我把自己当做一个应届毕业生一样，一分努力一分收获，半年过去我终于熟悉了工作，并且得到了公司的表彰，薪水也加了一级。后面的日子里我们省吃俭用，把欠朋友的1万多块钱还了，日子终于上了正轨。这时女朋友告诉我她想考研究生，我也很支持，于是她辞职在家备考。
　　另外，在这里我要感谢我的ProjectManager，他原来是一个大通信公司的产品经理，对人非常和善，我从他那里学到了很多知识，而且他也给了我许许多多无私的帮助。在工作上他给我充分的空间和信任。记得公司安排我维护一个接入服务器软件，由于代码量不算太小（5万行），资料和文档都不齐全，我维护起来非常吃力，所以想重新把它做一遍，公司领导不太支持，可能觉得工作量太大，但是他极力支持我，私下里他让我放手去做，我的维护工作他挤时间做。在他的支持下，我花了半年时间完成了接入服务器的软件，并且实现了一个相对完整的TCP/IP协议栈。在这里我学会了嵌入式系统设计、驱动开发、TCP/IP和很多通信的知识，我花了一年时间终于使自己从MIS开发转到了通信行业，并且站稳了脚跟。我的开发大量是对硬件的直接操作，不再受微软的操作系统，VC、Delhpi这些开发工具的约束，我终于看到了另外一片天空。
　我做事情喜欢追根问底，随着开发的深入，软件开发与硬件联系越来越紧密，硬件知识的匮乏又对我的发展产生了障碍，而且芯片技术基本上掌握在国外公司的手里，这对做系统级设计是一个非常大的制约，一个新产品出来，第一道利润（也往往是最丰厚的利润）常常都被IC公司如Intel、Motorola赚去了，国内的厂商只能喝点汤。所以我决心解决自己的硬件技术障碍，并打算离开通信行业，进入IC设计相关领域。
　　当然我明白如果我对硬件了解的非常少，没有哪家IC公司会仁慈到招我这样一个一窍不通的人来培训。所以我必须努力打好基础，学一些相关知识为以后做准备。就像我开始从MIS转到通信一样，我看过大量通信方面的书，并且给一个ISP做过RADIUS计费分拣台，在这样的背景下这家通信公司才给了我这个机会。我在的通信公司是做系统设计的，有不少PCB Layout硬件人员，平常我就注意向他们学习，由于我做的是软件，在公司看硬件资料不好意思，所以开始只好在家看，刚来上海工作我连续一年都在加班，后来不加了，因为我要挤出时间学习，通常我12点左右睡，第二天5点半起，我上班比较早，地铁上如果人不多我也用来看书。学习当然不会是一帆风顺的，有些实在不懂的问题就积累起来问硬件人员，他们的帮助使我学习进度快了很多，因为在没有人点拨的情况下自学，我的一半时间是花在解决疑难问题上，但这种问题经常是别人的一句话就可以让我豁然开朗，我非常庆幸我有这样的学习环境。在后面的一年里，我学会了看硬件原理图，学会了简单的硬件设计（模拟电路方面还有不小的差距），事情就是这样的，当你安安份份做软件，别人永远认为你是软件开发人员，在你开始学习硬件时别人未必会认同，有位中兴通讯的朋友还对我说过，一个人不可能把所有东西都学完。我也明白这一点，但我希望自己做的更好。但当你熟悉硬件后大家又会觉得你好像原本就是软硬件都懂的，同事们也都习以为常了。这个时候我可以把硬件资料堂堂正正的拿到公司看，没有人再大惊小怪了。让我比较自豪的是我通过自己的努力做了一个IAD（软交换的终端设备）系统方案，包含软硬件的选型、设计等内容，这个方案得到了公司和同事们的认同，让我感到非常欣慰。
　　技术是相辅相成的，当我的硬件有了一定的进步后，我的软件设计也有了很大的提高，我可以从更深层次理解问题，我做的接入服务器CPU是Motorola PowerPC860，熟悉的朋友都知道860 QMC与软件的批量数据传输通常采用BD表的方式，硬件人员做驱动的时候习惯采用固定BD表，每接收或发送数据都将数据从BD表拷贝到用户Buffer，或从用户Buffer拷贝到BD表，由于理解的比较深入，我自己重新实现了这个过程，采用动态BD表的方式，驱动从一个网口接收数据，提交给我的软件进行三层交换，直至从另外的接口发送出去，没有进行一次拷贝。这样的设计大大提高了性能，使系统的指标接近理论值。软硬件的结合使我的设计水平上了一个台阶。我现在写的这个操作系统，编译后我把程序反编译成汇编，找出其中不优化的代码，然后在C程序中进行调整。举个例子，很多CPU没有专门的乘法指令，这个大家应该都知道，在这种CPU上进行一个乘法操作常常会花费大量的指令周期，有的朋友会说这个我知道，我会尽量避免采用×号，但是事情往往不是那么简单，你知道C语言中数组的下标操作是怎么实现的吗？仔细看看反汇编的代码你就会明白，同样是通过下标的定位操作，C编译器会有时候会产生位移指令，但有时候会用乘法实现，两者效率往往是天壤之别，所以明白这些问题你才能将系统性能提升到极致。这些问题就不多说了，有兴趣的话以后可以共同探讨。
　　话说远一点，我由衷的希望在软件上做的比较深入的朋友们有机会学学硬件以及其它相关知识，尤其是做底层开发和嵌入式设计的。这对软件技术的提高有非常大的帮助，否则很多事情你只知道该这样但不会明白为什么该这样。我这个观点在我现在的IC公司Project Manager那里也得到了验证。他告诉我们公司现在的802.11芯片产品的软件经理原本是做该芯片硬件设计的，某某某原本是做软件的，现在在做IC，类似的例子还有很多，只是在国内这样的风气不是非常流行。
　　我有一些心得体会与大家分享，只有当我干好本职工作后，我才会学习与工作关系不大的技术，这样公司的上司才不至于反感，在入门阶段的问题我通常不去问那些资深人士，而是问一些资历比较浅的朋友，比如刚毕业不久的学生，因为他们往往会跟你详细的讲解，而资深人士通常觉得你的问题太简单，所以回答的也很简单，我又不好意思多问。等技术上了一定的层次后我才会问他们，他们也能给你比较深入的回答。另外，有些朋友说我机会比较好，他们也希望能从事新的工作可惜没有机会，我听了只有苦笑，我的机会了解的人都应该知道，我没有出生在什么IT世家：）也没有谁一路提拔我，所有的路都是自己走出来的，我母亲去世比较早，我的后母（我叫她阿姨）看着我努力过来的，一次她看我大年30还在写程序，她说像我这样努力木头都能学出来。
　　我的最终目的是IC而不是PCB，所以我下一步的准备开始学习IC设计的知识。公司的同事没有懂IC设计的，后面的路又要靠自己了，我买了不少相关的书，在网上也查了很多的资料，我花了大量的时间去学习VHDL，并且用软件进行了一些简单的设计和仿真（没有设计ASIC，只是针对FPGA），随着学习的深入，我渐渐明白了IC设计的基本流程，同时也明白了这条路的艰辛。这个时候我已经做好了跳槽的准备，我向一家业界又一定知名度的IC设计公司投了简历，并通过了漫长的面试（4个多小时）。其他的一切我都比较满意，唯独薪资差强人意，我也明白原因，因为我是这个行业的新人，我没有经验，我再一次将自己清零了。公司老板问我6000多一个月能不能接受，我知道他也是照章办事。想想我通信行业的朋友们，基本上都是年薪10万以上，月薪过万的也比比皆是，朋友们也帮我介绍了不少待遇不错的公司，我该怎么选择，当时我很犹豫，我热爱我的事业，我向往我的追求，但我也是一个普通的人，我也需要养家糊口，我也想早一点买房买车。生活给我出了一道难题。
　爱因斯坦在63岁时说过“一个人没有在30岁以前达成科学上的最大成就，那他永远都不会有。”这句话给了我很大的压力和震动，我马上就26岁了，离30只有四年时间，我必须抓紧这几年宝贵的时间，努力达到我技术上的最高峰。为了这个理想，为了能离自己的梦更近一些，我选择了这家IC公司，我明白自己的薪资和公司刚进来的硕士研究生相差无几，但为了今后的发展只能忍受，一切又得重新开始。换行业是一个非常痛苦的过程，尤其从一个春风得意的位置换到一个陌生的岗位，感觉象从温暖的被子里钻出来跳进冰水中，让人难以接受。在原来那家通信公司，我是唯一两年时间涨了五次工资的员工，公司和同事都给了我极大的认可，工作上也常常被委以重任。但现在这一切都成了过去，在新的公司我只是一个新人,没有人知道也没有人在意我过去的成绩。我决定重新开始，我把自己看作新毕业的学生，我要用自己的努力得到公司的认可。进入新的行业是非常痛苦的，我告诉自己必须忍受这一切，虽然外面有很多诱惑，但是既然作出了选择我就不允许自己轻易放弃。
　　我现在已经在这家新公司上了一个多月的班，开始非常艰难，现在慢慢适应了。第一个月结束时，Team Leader找我谈话，说我是新进员工中最优秀的一个，我心里很欣慰，这也算对我努力的一个肯定吧。在这里还要感谢我的女朋友，她给了我很大的支持和鼓舞，每次在我动摇的时候她都在鼓励我，让我坚持自己的理想，刚来上海是她让我不要勉强去做MIS，这次也是她让我顶住了月薪过万的诱惑，没有她我可能不会有今天的成绩。现在的公司有自己的操作系统，自己的CPU、DSP和其它芯片，在这里我能学到世界上最先进的技术，我们的设计开发不再完全依赖别人的硬件和系统，这让我很开心。我打算等工作步入正轨后，全力学习新的知识，实现我的理想。

在后面的两年里我给自己定下了几个目标：

一.努力做好本职工作，在工作上得到公司和同事们的认同；

二.努力学习IC硬件设计知识，多向同事请教，并利用一切机会多实践；

三.实现我的实时操作系统的主要部分，完成TCP/IP协议栈模块，并免费发布源代码；

四.和我女朋友结婚并买一套小房子，这是最重要的，因为我明白事业是可以重来的，但是珍贵的感情很难失而复得。

这里提一下我现在开发的操作系统，它是一个实时嵌入式系统，目前支持以下特性：

a.支持时间片轮转调度和基于优先级调度，最多64个优先级；

b.抢占式实时内核；

c.为了便于移植，主体用标准C实现；

d.汇编代码非常少，不到100行；

e.支持任务管理，各任务有独立的堆栈；

f.进程同步和通信目前完成了Semaphore，Message Queue正在调试；

g.实现了定时系统调用；

h.可以在windows上仿真调试

我还打算下一步实现优先级反转保护，Event Flag，Data Pipe，内存管理（以前实现过）、驱动接口等。在这之后我还会努力完善它，比如加入文件系统，协议栈、调试接口等。希望朋友们提出自己的意见和建议，在此不胜感激！

后记：

　　就像有的朋友说的，我的经历或许会给一些朋友产生误导，在这里我必须说明一下。我来上海以前学习过于拼命，常常晚上只睡3个多小时，我身高1米71，那时只有108斤（我现在130多），家人也说我这样拼命活不过60岁，但是当时的我太固执，我对他们说只要能实现理想活50岁我就够了。那时的拼命使我的身体受到了影响，有一次早上突然腰肌剧痛难忍，痛的我倒在床上站不起来。虽然我现在已经比较注意，但有时候还会隐隐作痛。后来在女朋友说服了我，来上海以后我不再如此。我经常引用父亲的一句话“身体是革命的本钱”。
　　而且我也发现拼命不是办法，我可以熬一两个通宵，最多的一次我连续工作了三天三夜，但是我半个月都没有恢复过来，这样是不是得不偿失？学习工作应该是一个长期的过程，像马拉松而不是百米冲刺。我现在非常注意调整学习和工作的强度，我要保证每天尽量有相对充沛的精力，一些年轻的朋友觉得自己也应该拼命努力，这让我多少有些担心，如果我的故事能让你在学习工作上多一点兴趣，我会感到很开心，但如果误导了某些朋友，让你做一些不值得的付出，我会感到很内疚。
　技术没有贵贱之分，我以前换行业是因为自己的兴趣所致，而不是对哪个行业有什么偏见。我希望我的经历不要给朋友一个错误的导向，觉得我始终向更高的技术发展。其实各行各业做到顶尖都是很困难的。话又说回来虽然技术没有贵贱，但是门槛是有高低的，无论如何，做IC的门槛要比做网页的高，这一点无可否认。国家各种人才都是需要的，但是作为个人奋发向上的想法还是应该有的，努力在自己喜欢的行业上做的更好，而不应该停留在比较肤浅的层次上。
　　我是一个自己觉得比较有自知之明的人，或许我最大的优点就是知道自己有很多缺点：）。我的故事中很多的曲折和错误都是由我的缺点造成的，希望大家用审慎的眼光看待我的经历，不要被我的“花言巧语”所迷惑。我学习有些随心所欲，这给我带来了无尽的麻烦，也大大阻碍的我的发展。记得我小时候成绩比较出色，但是后来学习严重偏科，导致我中学成绩一再滑坡，也没有考上什么好的学校，小时候的一个朋友，当时的成绩和我相仿，但是没有我这个缺点，她上了清华，后来在去了美国深造，在一个著名导师手下研究理论科学，这未尝不是一条更好的出路。另外我的学习方法也是在不断改善中的，过去的学习过于讲究数量和时间，那样学习既苦而已效率不高，现在我非常注意学习的效率和技巧，这样才是学习的捷径（当然不是指投机取巧），比如说学一相对陌生的技术，如果有条件，不妨问一问有经验的人，不需要问很多，往往他不经意的几句话会给你非常大的帮助，甚至超过你看一个星期的书。带着这样的思想再去学习你会节省很多时间，这样何乐不为呢？这些年中我学了不少的东西，由于开始非常盲目，所以学的东西杂乱无章，现在回想起来让我啼笑皆非，我把大量的时间浪费在一些没有必要深入了解的知识上，毕竟一个人的精力是有限度的。很多朋友很我一样都背过五笔字形，的确它是个不错的输入法，但是对一个研发人员它绝对不值得你去背，你的时间应该花在有价值的地方。我这样的事情还做过很多，我背过CCED、WPS的命令和快捷键，在dBase基本退出历史舞台后我还花了很多时间去学习它的使用。所以我的学习在前期缺乏规划，没有明确的短期目的、中期目标，只有一个虚无飘渺的长期的理想。这就像做设计一样，好的设计是从需求抽象到代码有很多过程，而不能得到了需求就立刻开始开始编码。
　　当然这么些年的学习和工作多多少少有些收获，下面我说说我的一些学习的心得，这些方法未必正确，我也在不断探索和改进中。我的学习和工作有相对明确的目标，我不会一时心动而去学习某一技术，在下决定之前我会考虑很多，包括长期的发展，个人路线的规划，需要付出的代价、可能遇到的困难及解决的办法等等，在决定后还会制定更加明确的计划，包括短期、中期和长期的，身边可以利用到的资源（包括好的书籍、资料、软硬件环境，也包括有经验的朋友或者师长），以及每一个阶段是怎么过渡到高一阶段的计划，往往在一个学习阶段一旦上路后会走的相对顺利，但是跨阶段通常比较麻烦，比如从学习基础知识转到实践。另外我买书也有自己的方法，现在世面上高质量的书远不如低质量书多，对于一个陌生的技术，往往在第一次买书会选择错误，即使买到一本好书但是它的方向也未必适合你，所以我通常会先在网上查找一些该技术的介绍，有了一点点概念后再去买一本比较薄、相对便宜并且内容相对泛泛而谈的书，这是国内作者最善于写的书：），再把它浏览一遍后我就会基本明白这门技术的要点，后面买书和制定计划就会明确的多。否则一开始就想找本好书往往比较困难，而且买回来后努力学习，有时候学了一半才发现是本低质量的书或者是相对过时技术，让人非常懊恼。另外让有经验的人帮你介绍，通常也是一个不错的选择。
　　有些朋友想学通信、嵌入式开发，但总觉得自己没有软硬件环境，我就按我的了解给大家介绍一下怎么建立这样的环境，当然我了解的只是我学习和工作的方向。通信我做的是数据网方面的工作，包括TCP/IP、二三层交换、对接入网、H.323和软交换也有一点认识。这些软硬件环境都是可以在PC上构建的。你甚至可以在一个没有网卡的PC上建立一个包含多个路由器、接入服务器、VoIP网关、网守、主机等的仿真网络环境，而且与实际的网络相当接近，当然这需要你有清晰的网络概念和一定的网络知识，我一直在努力开发一套软件将这个过程简化，目前试验已经做完，我可能会将它融入我的操作系统外围扩展软件中。这样的方法我无法用简单的语句讲的很清楚，我可以说一下大概的思想，就是在PC上实现仿真网卡，（知道Windows怎么在没有网卡的机器实现虚拟网卡技术的朋友都应该会明白），然后每一个仿真网卡对应一个虚拟设备，如路由器或者主机。你也可以借助第三方工具完成部分工作，如VmWare等。我现在就是利用一个仿真网卡做自己的开发的。
　　至于嵌入式开发环境更加容易实现，PC就是一个非常大的硬件平台，现有的嵌入式操作系统通常都支持X86，你可以在上面做开发，通过软盘Boot或者使用虚拟机装载，我用VxWorks做了试验，在一台PC上跑Windows和VxWorks两个系统。另外Windows上的兼容DOS的16位仿真X86环境也为很多操作系统提供了绝佳的试验环境，我的操作系统在Windows上就是这样实现的。Linux在嵌入式中应用也比较广泛，它在网上有大量的资料，而且也相对比较容易实践。同时很多完善的嵌入式开发环境支持软件仿真，如Tornado、WinCE等。

Pudgy's World 2005-08-16 12:58 发表评论

ImageIO 's IIOReadProgressListener

Pudgy's World — Tue, 16 Aug 2005 04:19:00 GMT

Recently, I am working on graphic project. This project I faced is a big challenge to me. Here is a sloution to show the progress bar when loading the image from the net.
PS:
If you install the JAI, it will break the progress interrupt.
See this in Sun's Bug Database http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4842452

  1 import java.awt.BorderLayout;
  2 import java.awt.event.ActionEvent;
  3 import java.awt.event.ActionListener;
  4 import java.awt.image.BufferedImage;
  5 import java.io.IOException;
  6 import java.net.MalformedURLException;
  7 import java.net.URL;
  8 import java.util.Iterator;
  9
10 import javax.imageio.ImageIO;
11 import javax.imageio.ImageReader;
12 import javax.imageio.event.IIOReadProgressListener;
13 import javax.imageio.stream.ImageInputStream;
14 import javax.swing.*;
15
16 public class IIOProgressTest
17 {
18     public static void main(String[] args)
19     {
20         try {
21             UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
22         } catch (Exception e) {
23             e.printStackTrace();
24         }
25
26         final JLabel imageLabel = new JLabel();
27         JScrollPane scrollPane = new JScrollPane(imageLabel);
28         final JButton startBtn = new JButton("Load Image");
29         final JProgressBar progressBar = new JProgressBar();
30         progressBar.setVisible(false);
31         JPanel p = new JPanel(new BorderLayout(5, 5));
32         p.add(startBtn, BorderLayout.WEST);
33         p.add(progressBar, BorderLayout.CENTER);
34
35         final IIOReadProgressListener progressListener = new IIOReadProgressListener() {
36             public void imageStarted(ImageReader source, int imageIndex)
37             {
38                 SwingUtilities.invokeLater(new Runnable()
39                 {
40                     public void run()
41                     {
42                         startBtn.setEnabled(false);
43                         progressBar.setValue(0);
44                         progressBar.setVisible(true);
45                         invalidate();
46
47                     }
48                 });
49             }
50             public void imageProgress(ImageReader source, final float percentageDone)
51             {
52                 SwingUtilities.invokeLater(new Runnable()
53                 {
54                     public void run()
55                     {
56                         System.out.println("percentageDone" + percentageDone);
57                         progressBar.setValue((int) (percentageDone));
58                     }
59                 });
60             }
61             public void imageComplete(ImageReader source)
62             {
63                 SwingUtilities.invokeLater(new Runnable()
64                 {
65                     public void run()
66                     {
67                         startBtn.setEnabled(true);
68                         progressBar.setValue(100);
69                         progressBar.setVisible(false);
70                     }
71                 });
72             }
73
74             public void sequenceStarted(ImageReader source, int minIndex) {}
75             public void sequenceComplete(ImageReader source) {}
76             public void thumbnailStarted(ImageReader source, int imageIndex, int thumbnailIndex) {}
77             public void thumbnailProgress(ImageReader source, float percentageDone) {}
78             public void thumbnailComplete(ImageReader source) {}
79             public void readAborted(ImageReader source) {}
80         };
81
82         startBtn.addActionListener(new ActionListener()
83         {
84             public void actionPerformed(ActionEvent e)
85             {
86                 final String urlStr = JOptionPane.showInputDialog(
87                         SwingUtilities.getWindowAncestor(startBtn), "Input image URL");
88                 if (urlStr == null) {
89                     return;
90                 }
91
92                 new Thread() {
93                     public void run()
94                     {
95                         try {
96                             URL url = new URL(urlStr);
97                             ImageInputStream iis = ImageIO.createImageInputStream(url.openStream());
98                             Iterator iter = ImageIO.getImageReaders(iis);
99                             if (iter.hasNext()) {
100                                 ImageReader reader = (ImageReader) iter.next();
101                                 reader.setInput(iis);
102                                 reader.addIIOReadProgressListener(progressListener);
103                                 BufferedImage image = reader.read(reader.getMinIndex());
104                                 final ImageIcon icon = new ImageIcon(image);
105
106                                 SwingUtilities.invokeLater(new Runnable()
107                                 {
108                                     public void run()
109                                     {
110                                         imageLabel.setIcon(icon);
111                                         imageLabel.revalidate();
112                                     }
113                                 });
114                             }
115                         } catch (MalformedURLException e) {
116                             e.printStackTrace();
117                         } catch (IOException e) {
118                             e.printStackTrace();
119                         }
120                     }
121                 }.start();
122             }
123         });
124
125         JFrame f = new JFrame("IIOProgressTest");
126         f.getContentPane().setLayout(new BorderLayout(5, 5));
127         f.getContentPane().add(scrollPane, BorderLayout.CENTER);
128         f.getContentPane().add(p, BorderLayout.SOUTH);
129         f.setSize(800, 600);
130         f.setLocationRelativeTo(null);
131         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
132         f.setVisible(true);
133     }
134 }
135

Pudgy's World 2005-08-16 12:19 发表评论

Java Learning Path

Pudgy's World — Mon, 15 Aug 2005 14:31:00 GMT

Java Learning Path （一）、工具篇
一、 JDK (Java Development Kit)

JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。

1、 JDK的下载和安装
JDK又叫做J2SE（Java2 SDK Standard Edition），可以从Sun的Java网站上下载到，http://java.sun.com/j2se/downloads.html ，JDK当前最新的版本是J2SDK1.4.2，建议下载该版本的JDK，下载页面在这里：http://java.sun.com/j2se/1.4.2/download.html。

下载好的JDK是一个可执行安装程序，默认安装完毕后会在C:\Program Files\Java\目录下安装一套JRE（供浏览器来使用），在C:\j2sdk1.4.2下安装一套JDK（也包括一套JRE）。然后我们需要在环境变量PATH的最前面增加java的路径C:\j2sdk1.4.2\bin。这样JDK就安装好了。

2、 JDK的命令工具
JDK的最重要命令行工具：
java：启动JVM执行class
javac： Java编译器
jar： Java打包工具
javadoc： Java文档生成器
这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。

二、 JDK Documentation

Documentation在JDK的下载页面也有下载连接，建议同时下载Documentation。Documentation是最最重要的编程手册，涵盖了整个Java所有方面的内容的描述。可以这样说，学习Java编程，大部分时间都是花在看这个Documentation上面的。我是随身携带的，写Java代码的时候，随时查看，须臾不离手。

三、应用服务器(App Server)

App Server是运行Java企业组件的平台，构成了应用软件的主要运行环境。当前主流的App Server是BEA公司的Weblogic Server和IBM公司的Websphere以及免费的Jboss，选择其中一个进行学习就可以了，个人推荐Weblogic，因为它的体系结构更加干净，开发和部署更加方便，是Java企业软件开发人员首选的开发平台。下面简要介绍几种常用的App Server：

1、 Tomcat
Tomcat严格意义上并不是一个真正的App Server，它只是一个可以支持运行Serlvet/JSP的Web容器，不过Tomcat也扩展了一些App Server的功能，如JNDI，数据库连接池，用户事务处理等等。Tomcat被非常广泛的应用在中小规模的Java Web应用中，因此本文做一点下载、安装和配置Tomcat的介绍：

Tomcat是Apache组织下Jakarta项目下的一个子项目，它的主网站是：http://jakarta.apache.org/tomcat/ ，Tomcat最新版本是Tomcat4.1.27，软件下载的连接是：http://www.apache.org/dist/jakarta/tomcat-4/binaries/ 。

下载Tomcat既可以直接下载zip包，也可以下载exe安装包（个人建议zip更干净些），不管哪种情况，下载完毕安装好以后（zip直接解压缩就可以了）。需要设置两个环境变量：

JAVA_HOME=C:\j2sdk1.4.2
CATALINA_HOME=D:\tomcat4 (你的Tomcat安装目录)

这样就安装好了，启动Tomcat运行CATALINA_HOME\bin\startup.bat，关闭Tomcat运行shutdown.bat脚本。Tomcat启动以后，默认使用8080端口，因此可以用浏览器访问http://localhost:8080来测试Tomcat是否正常启动。

Tomcat提供了两个Web界面的管理工具，URL分别是：
http://localhost:8080/admin/index.jsp
http://localhost:8080/manager/html
在启用这两个管理工具之前，先需要手工配置一下管理员用户和口令。用一个文本工具打开CATALINA_HOME\conf\tomcat-users.xml这个文件，加入如下几行：

这样用户“robbin”就具备了超级管理员权限。重新启动Tomcat以后，你就可以使用该用户来登陆如上的两个管理工具，通过Web方式进行Tomcat的配置和管理了。

2、 BEA Weblogic
Weblogic可以到BEA的网站上免费注册之后下载到最新的Weblogic8.1企业版，License可以免费使用1年时间，其实这已经完全足够了。Weblogic的下载连接：http://commerce.bea.com/index.jsp，Weblogic的在线文档：http://edocs.bea.com/ 。

3、 IBM Webshpere
Websphere同样可以下载到免费的试用版本，到IBM的developerWorks网站可以看到Websphere试用产品的下载和相关的Websphere的资料，developerWorks中文网站的连接是：http://www-900.ibm.com/developerWorks/cn/wsdd/ ，Websphere的下载连接：http://www7b.software.ibm.com/wsdd/downloads/WASsupport.html 。

4、 Jboss
Jboss是免费开源的App Server，可以免费的从Jboss网站下载：http://www.jboss.org/index.html，然而Jboss的文档是不免费，需要花钱购买，所以为我们学习Jboss设置了一定的障碍。在Jdon上有几篇不错的Jboss配置文档，可以用来参考：http://www.jdon.com/idea.html

四、 Java应用的运行环境

Java的应用可以简单分为以下几个方面：

1、 Java的桌面应用
桌面应用一般仅仅需要JRE的支持就足够了。

2、 Java Web应用
Java的Web应用至少需要安装JDK和一个web容器（例如Tomcat），以及一个多用户数据库，Web应用至少分为三层：
Browser层：浏览器显示用户页面
Web层：运行Servlet/JSP
DB层：后端数据库，向Java程序提供数据访问服务

3、 Java企业级应用
企业级应用比较复杂，可以扩展到n层，最简单情况会分为4层：
Browser层：浏览器显示用户页面
Client层：Java客户端图形程序（或者嵌入式设备的程序）直接和Web层或者EJB层交互
Web层：运行Servlet/JSP
EJB层：运行EJB，完成业务逻辑运算
DB层：后端数据库，向Java程序提供数据访问服务

4、 Java嵌入式应用
Java嵌入式应用是一个方兴未艾的领域，从事嵌入式开发，需要从Sun下载J2ME开发包，J2ME包含了嵌入式设备专用虚拟机KVM，和普通的JDK中包含的JVM有所不同。另外还需要到特定的嵌入式厂商那里下载模拟器。

Java Learning Path（二）、书籍篇

学习一门新的知识，不可能指望只看一本，或者两本书就能够完全掌握。需要有一个循序渐进的阅读过程。我推荐Oreilly出版的Java系列书籍。

在这里我只想补充一点看法，很多人学习Java是从《Thinking in Java》这本书入手的，但是我认为这本书是不适合初学者的。我认为正确的使用这本书的方法应该是作为辅助的读物。《Thinking in Java》并不是在完整的介绍Java的整个体系，而是一种跳跃式的写作方法，是一种类似tips的方法来对Java很多知识点进行了深入的分析和解释。

对于初学者来说，最好是找一本Java入门的书籍，但是比较完整的循序的介绍Java的语法，面向对象的特性，核心类库等等，在看这本书的同时，可以同步来看《Thinking in Java》，来加深对Java的理解和原理的运用，同时又可以完整的了解Java的整个体系。

对于Java的入门书籍，蔡学镛推荐的是Oreilly的《Exploring Java, 2nd Edition》或者《Java in a Nutshell,2nd Edition（针对C++背景）》，我并没有看过这两本书。其实我觉得电子工业出版社的《Java 2编程详解》或者《Java 2从入门到精通》就很不错。

在所有的Java书籍当中，其实最最有用的，并不是O'reilly的 Java Serials，真正最最有用处是JDK的Documentation！几乎你想获得的所有的知识在Documentation里面全部都有，其中最主要的部分当然是Java基础类库的API文档，是按照package来组织的，对于每一个class都有详细的解释，它的继承关系，是否实现了某个接口，通常用在哪些场合，还可以查到它所有的public的属性和方法，每个属性的解释，意义，每个方法的用途，调用的参数，参数的意义，返回值的类型，以及方法可能抛出的异常等等。可以这样来说，所有关于Java编程方面的书籍其实都不过是在用比较通俗易懂的语言，和良好的组织方式来介绍Documentation里面的某个package里面包含的一些类的用法而已。所以万变不离其宗，如果你有足够的能力来直接通过Documentation来学习Java的类库，那么基本上就不需要看其他的书籍了。除此之外，Documentation也是编程必备的手册，我的桌面上有三个Documentation的快捷方式，分别是J2SDK1.4.1的Documentation，Servlet2.3的Documentation和J2SDKEE1.3.1的Documentation。有了这个三个Documentation，什么其他的书籍都不需要了。

对于Java Web 编程来说，最核心的是要熟悉和掌握HTTP协议，这个就和Java无关了，在熟悉HTTP协议之后，就需要熟悉Java的实现HTTP协议的类库，也就是Servlet API，所以最重要的东西就是Servlet API。当然对于初学者而言，直接通过Servlet API来学习Web编程有很大的难度，我推荐O'reilly的《Java Server Pages 》这本书来学习Web 编程。

EJB的书籍当中，《Enterprise JavaBeans, 2nd Edition》是一本很不错的书， EJB的学习门槛是比较高，入门很难，但是这本书完全降低了学习的难度，特别重要的一点是，EJB的学习需要结合一种App Server的具体实现，所以在学习EJB的同时，必须同步的学习某种App Server，而这本书相关的出了三本书，分别是Weblogic6.1，Websphere4.0和JBoss3.0上面部署书中例子的实做。真是既有理论，又有实践。在学习EJB的同时，可以边看边做，EJB的学习会变得很轻松。

但是这本书也有一个问题，就是版本比较旧，主要讲EJB1.1规范和部分EJB2.0的规范。而Ed Roman写的《Mastering EJB 2.0》这本书完全是根据EJB2.0规范写的，深入浅出，覆盖了EJB编程的各个方面，并且还有很多编程经验tips，也是学习EJB非常推荐的书籍之一。

如果是结合Weblogic来学习J2EE的话，《J2EE应用与BEA Weblogic Server》绝对是首选读物，虽然是讲述的Weblogic6.0，仍然值得购买，这本书是BEA官方推荐的教材，作者也是BEA公司的工程师。现在中文版已经随处可见了。这本书结合Weblogic介绍了J2EE各个方面的技术在Weblogic平台上的开发和部署，实践指导意义非常强。

在掌握了Java平台基础知识和J2EE方面的知识以后，更进一步的是学习如何运用OO的方法进行软件的设计，那么就一定要学习“设计模式”。Sun公司出版了一本《J2EE核心模式》，是每个开发Java企业平台软件的架构师必备的书籍。这本书全面的介绍了J2EE体系架构的各种设计模式，是设计师的必读书籍。

Java Learning Path（三）过程篇

每个人的学习方法是不同的，一个人的方法不见得适合另一个人，我只能是谈自己的学习方法。因为我学习Java是完全自学的，从来没有问过别人，所以学习的过程基本上完全是自己摸索出来的。我也不知道这种方法是否是比较好的方法，只能给大家提供一点参考了。

学习Java的第一步是安装好JDK，写一个Hello World，? 其实JDK的学习没有那么简单，关于JDK有两个问题是很容易一直困扰Java程序员的地方：一个是CLASSPATH的问题，其实从原理上来说，是要搞清楚JRE的ClassLoader是如何加载Class的；另一个问题是package和import问题，如何来寻找类的路径问题。把这两个问题摸索清楚了，就扫除了学习Java和使用JDK的最大障碍。推荐看一下王森的《Java深度历险》，对这两个问题进行了深入的探讨。

第二步是学习Java的语法。Java的语法是类C++的，基本上主流的编程语言不是类C，就是类C++的，没有什么新东西，所以语法的学习，大概就是半天的时间足够了。唯一需要注意的是有几个不容易搞清楚的关键字的用法，public，protected，private，static，什么时候用，为什么要用，怎么用，这可能需要有人来指点一下，我当初是完全自己琢磨出来的，花了很久的时间。不过后来我看到《Thinking in Java》这本书上面是讲了这些概念的。

第三步是学习Java的面向对象的编程语言的特性的地方。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，我觉得这个过程需要花很长很长时间，因为学习Java之前没有C++的经验，只有C的经验，我是大概花了一个月左右吧，才彻底把这些概念都搞清楚，把书上面的例子反复的揣摩，修改，尝试，把那几章内容反复的看过来，看过去，看了不下5遍，才彻底领悟了。不过我想如果有C++经验的话，应该一两天时间足够了。那么在这个过程中，可以多看看《Thinking in Java》这本书，对面向对象的讲解非常透彻。可惜的是我学习的时候，并没有看到这本书，所以自己花了大量的时间，通过自己的尝试和揣摩来学会的。

第四步就是开始熟悉Java的类库。Java的基础类库其实就是JDK安装目录下面jre\lib\rt.jar这个包。学习基础类库就是学习rt.jar。基础类库里面的类非常非常多。据说有3000多个，我没有统计过。但是真正对于我们来说最核心的只有4个，分别是
java.lang.*;
java.io.*;
java.util.*;
java.sql.*;

这四个包的学习，每个包的学习都可以写成一本厚厚的教材，而O'reilly也确实是这样做的。我觉得如果时间比较紧，是不可能通过读四本书来学习。我觉得比较好的学习方法是这样的：
首先要通读整个package的框架，了解整个package的class，interface，exception的构成，最好是能够找到介绍整个包框架的文章。这些专门介绍包的书籍的前几章应该就是这些总体的框架内容介绍。

对包整体框架的把握并不是要熟悉每个类的用法，记住它有哪些属性，方法。想记也记不住的。而是要知道包有哪些方面的类构成的，这些类的用途是什么，最核心的几个类分别是完成什么功能的。我在给人培训的时候一般是一次课讲一个包，所以不可能详细的介绍每个类的用法，但是我反复强调，我给你们讲这些包的不是要告诉你们类的方法是怎么调用的，也不要求你们记住类的方法调用，而是要你们了解，Java给我们提供了哪些类，每个类是用在什么场合，当我遇到问题的时候，我知道哪个类，或者哪几个类的组合可以解决我的问题，That'all！，当我们具体写程序的时候，只要你知道该用哪个类来完成你的工作就足够了。编码的时候，具体的方法调用，是边写代码，边查Documentation，所有的东西都在Documentation里面，不要求你一定记住，实际你也记不住3000多个类的总共将近10万个方法调用。所以对每个包的总体框架的把握就变得极为重要。

第五步，通过上面的学习，如果学的比较扎实的话，就打好了Java的基础了，剩下要做的工作是扫清Documentation里面除了上面4个包之外的其他一些比较有用处的类。相信进展到这一步，Java的自学能力已经被培养出来了，可以到了直接学习Documentation的水平了。除了要做GUI编程之外，JDK里面其他会有用处的包是这些：
java.text.*;
java.net.*;
javax.naming.*;
这些包里面真正用的比较多的类其实很少，只有几个，所以不需要花很多时间。

第六步，Java Web 编程
Web编程的核心是HTTP协议，HTTP协议和Java无关，如果不熟悉HTTP协议的话，虽然也可以学好Servlet/JSP编程，但是达不到举一反三，一通百通的境界。所以HTTP协议的学习是必备的。如果熟悉了HTTP协议的话，又有了Java编程的良好的基础，学习Servlet/JSP简直易如反掌，我学习Servlet/JSP就用了不到一周的时间，然后就开始用JSP来做项目了。

在Servlet/JSP的学习中，重头仍然是Servlet Documentation。Servlet API最常用的类很少，花比较少的时间就可以掌握了。把这些类都看一遍，多写几个例子试试。Servlet/JSP编程本质就是在反复调用这些类来通过HTTP协议在Web Server和Brower之间交谈。另外对JSP，还需要熟悉几个常用JSP的标记，具体的写法记不住的话，临时查就是了。

此外Java Web编程学习的重点要放在Web Application的设计模式上，如何进行业务逻辑的分析，并且进行合理的设计，按照MVC设计模式的要求，运用Servlet和JSP分别完成不同的逻辑层，掌握如何在Servlet和JSP之间进行流程的控制和数据的共享，以及Web Application应该如何配置和部署。

第七步，J2EE编程
以上的学习过程如果是比较顺利的话，进行到这一步，难度又陡然提高。因为上面的知识内容都是只涉及一个方面，而像EJB，JMS，JTA等核心的J2EE规范往往是几种Java技术的综合运用的结晶，所以掌握起来难度比较大。

首先一定要学习好JNDI，JNDI是App Server定位服务器资源（EJB组件，Datasouce，JMS）查找方法，如果对JNDI不熟悉的话，EJB，JMS这些东西几乎学不下去。JNDI其实就是javax.naming.*这个包，运用起来很简单。难点在于服务器资源文件的配置。对于服务器资源文件的配置，就需要看看专门的文档规范了，比如web.xml的写法，ejb-jar.xml的写法等等。针对每种不同的App Server，还有自己的服务资源配置文件，也是需要熟悉的。

然后可以学习JTA，主要是要理解JTA对于事务的控制的方法，以及该在什么场合使用JTA。这里可以简单的举个例子，我们知道一般情况可以对于一个数据库连接进行事务控制(conn.setAutoCommit(false),....,conn.commit())，做为一个原子操作，但是假设我的业务需求是要把对两个不同数据库的操作做为一个原子操作，你能做的到吗？这时候只能用JTA了。假设操作过程是先往A数据库插一条记录，然后删除B数据库另一个记录，我们自己写代码是控制不了把整个操作做为一个原子操作的。用JTA的话，由App Server来完成控制。

在学习EJB之前要学习对象序列化和RMI，RMI是EJB的基础。接着学习JMS和EJB，对于EJB来说，最关键是要理解EJB是如何通过RMI来实现对远端对象的调用的，以及在什么情况下要用到EJB。

在学习完EJB，JMS这些东西之后，你可能会意识到要急不可待学习两个领域的知识，一个是UML，另一个是Design Pattern。Java企业软件的设计非常重视框架(Framework)的设计，一个好的软件框架是软件开发成功的必要条件。在这个时候，应该开始把学习的重点放在设计模式和框架的学习上，通过学习和实际的编程经验来掌握EJB的设计模式和J2EE的核心模式。

J2EE规范里面，除了EJB，JMS，JTA，Servlet/JSP，JDBC之外还有很多很多的企业技术，这里不一一进行介绍了。

另外还有一个最新领域Web Services。Web Services也完全没有任何新东西，它像是一种黏合剂，可以把不同的服务统一起来提供一个统一的调用接口，作为使用者来说，我只要获得服务提供者给我的WSDL（对服务的描述），就够了，我完全不知道服务器提供者提供的服务究竟是EJB组件，还是.Net组件，还是什么CORBA组件，还是其他的什么实现，我也不需要知道。Web Services最伟大的地方就在于通过统一的服务提供方式和调用方式，实现了整个Internet服务的共享，是一个非常令人激动的技术领域。Web Services好像目前还没有什么很好的书籍，但是可以通过在网络上面查资料的方式来学习。

Java Learning Path（四）方法篇

Java作为一门编程语言，最好的学习方法就是写代码。当你学习一个类以后，你就可以自己写个简单的例子程序来运行一下，看看有什么结果，然后再多调用几个类的方法，看看运行结果，这样非常直观的把类给学会了，而且记忆非常深刻。然后不应该满足把代码调通，你应该想想看如果我不这样写，换个方式，再试试行不行。记得哪个高人说过学习编程就是个破坏的过程，把书上的例子，自己学习Documentation编写的例子在运行通过以后，不断的尝试着用不同的方法实现，不断的尝试破坏代码的结构，看看它会有什么结果。通过这样的方式，你会很彻底的很精通的掌握Java。

举个例子，我们都编过Hello World

public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}

很多初学者不是很理解为什么main方法一定要这样来定义public static void main(String[] args)，能不能不这样写？包括我刚学习Java的时候也有这样的疑问。想知道答案吗？很简单，你把main改个名字运行一下，看看报什么错误，然后根据出错信息进行分析；把main的public取掉，在试试看，报什么错误；static去掉还能不能运行；不知道main方法是否一定要传一个String[]数组的，把String[]改掉，改成int[]，或者String试试看；不知道是否必须写args参数名称的，也可以把args改成别的名字，看看运行结果如何。

我当初学习Java的时候就是这样做的，把Hello World程序反复改了七八次，不断运行，分析运行结果，最后就彻底明白为什么了main方法是这样定义的了。

此外，我对于staic，public，private，Exception，try{ }catch {}finally{}等等等等一开始都不是很懂，都是把参考书上面的例子运行成功，然后就开始破坏它，不断的根据自己心里面的疑问来重新改写程序，看看能不能运行，运行出来是个什么样子，是否可以得到预期的结果。这样虽然比较费时间，不过一个例子程序这样反复破坏几次之后。我就对这个相关的知识彻底学通了。有时候甚至故意写一些错误的代码来运行，看看能否得到预期的运行错误。这样对于编程的掌握是及其深刻的。

其中特别值得一提的是JDK有一个非常棒的调试功能，-verbose
java -verbose
javac -verbose 以及其它很多JDK工具都有这个选项
-verbose 可以显示在命令执行的过程中，JVM都依次加载哪里Class，通过这些宝贵的调试信息，可以帮助我们分析出JVM在执行的过程中都干了些什么。

另外，自己在学习过程中，写的很多的这种破坏例程，应该有意识的分门别类的保存下来，在工作中积累的典型例程也应该定期整理，日积月累，自己就有了一个代码库了。遇到类似的问题，到代码库里面 Copy & Paste ，Search & Replace，就好了，极大提高了开发速度。最理想的情况是把一些通用的例程自己再抽象一层，形成一个通用的类库，封装好。那么可复用性就更强了。

所以我觉得其实不是特别需要例程的，自己写的破坏例程就是最好的例子，如果你实在对自己写的代码不放心的话，我强烈推荐你看看JDK基础类库的Java源代码。在JDK安装目录下面会有一个src.zip，解开来就可以完整的看到整个JDK基础类库，也就是rt.jar的Java源代码，你可以参考一下Sun是怎么写Java程序的，规范是什么样子的。我自己在学习Java的类库的时候，当有些地方理解的不是很清楚的时候，或者想更加清晰的理解运作的细节的时候，往往会打开相应的类的源代码，通过看源代码，所有的问题都会一扫而空。

Java Learning Path（五）资源篇

1、 http://java.sun.com/ (英文)
Sun的Java网站，是一个应该经常去看的地方。不用多说。

2、 http://www-900.ibm.com/developerWorks/cn/
IBM的developerWorks网站，英语好的直接去英文主站点看。这里不但是一个极好的面向对象的分析设计网站，也是Web Services，Java，Linux极好的网站。强烈推荐！！！

3、 http://www.java-cn.com/ (中文)
JAVA中文站，目前国内资料最全、会员最多的JAVA技术网站，人气极高。有《JAVA电子书库》、《JAVA视频库》(国内唯一)、《JAVA技术文摘库》、《JAVA源代码库》、《JAVA工具库》、《招聘求职广场》等主要栏目，还有一些专家栏目。目前会员有5万多，VIP会员近1000人。无论是菜鸟还是老鸟，都能在此网站中找到自己所需要的东东！！　最强烈推荐！！！！！！

4、 http://www.javaworld.com/ (英文)
关于Java很多新技术的讨论和新闻。想多了解Java的方方面面的应用，这里比较好。

5、 http://dev2dev.bea.com.cn/index.jsp
BEA的开发者园地，BEA作为最重要的App Server厂商，有很多独到的技术，在Weblogic上做开发的朋友不容错过。

6、 http://www.huihoo.com/
灰狐动力网站，一个专业的中间件网站，虽然不是专业的Java网站，但是在J2EE企业应用技术方面有深厚的造诣。

7、 http://www.theserverside.com/home/ (英文)
TheServerSide是一个著名的专门面向Java Server端应用的网站。

8、 http://www.javaresearch.org/
Java研究组织，有很多优秀的Java方面的文章和教程，特别是在JDO方面的文章比较丰富。

9、 http://www.cnjsp.org/
JSP技术网站，有相当多的Java方面的文章和资源。

10、 http://www.jdon.com/
Jdon论坛，是一个个人性质的中文J2EE专业技术论坛，在众多的Java的中文论坛中，Jdon一个是技术含量非常高，帖子质量非常好的论坛。

11、 http://sourceforge.net/
SourgeForge是一个开放源代码软件的大本营，其中也有非常非常丰富的Java的开放源代码的著名的软件。

Pudgy's World 2005-08-15 22:31 发表评论