BlogJava-Calvin's Tech Space-随笔分类-Java

InputStream.available()方法

calvin — Fri, 18 Nov 2011 06:16:00 GMT

首先这个方法不能用来判断文件长度！获取文件长度可以使用File.length()方法，它返回一个long类型的以字节为单位的值。

看文档：
Returns an estimated number of bytes that can be read or skipped without blocking for more input.

Note that this method provides such a weak guarantee that it is not very useful in practice.

Firstly, the guarantee is "without blocking for more input" rather than "without blocking": a read may still block waiting for I/O to complete — the guarantee is merely that it won't have to wait indefinitely for data to be written. The result of this method should not be used as a license to do I/O on a thread that shouldn't be blocked.

Secondly, the result is a conservative estimate and may be significantly smaller than the actual number of bytes available. In particular, an implementation that always returns 0 would be correct. In general, callers should only use this method if they'd be satisfied with treating the result as a boolean yes or no answer to the question "is there definitely data ready?".

Thirdly, the fact that a given number of bytes is "available" does not guarantee that a read or skip will actually read or skip that many bytes: they may read or skip fewer.

It is particularly important to realize that you must not use this method to size a container and assume that you can read the entirety of the stream without needing to resize the container. Such callers should probably write everything they read to a ByteArrayOutputStream and convert that to a byte array. Alternatively, if you're reading from a file, length() returns the current length of the file (though assuming the file's length can't change may be incorrect, reading a file is inherently racy).

The default implementation of this method in InputStream always returns 0. Subclasses should override this method if they are able to indicate the number of bytes available.

calvin 2011-11-18 14:16 发表评论

重写equals和hashCode方法

calvin — Thu, 10 Nov 2011 10:25:00 GMT

以下总结自effective java.
实现equals方法的过程如下：
1 使用==运算符来判断是否引用同一个对象。
2 使用instance of操作符来判断参数是否是正确的类型。
3 将实参cast成正确的类型。
4 对于每个关键属性，进行比较:
对于非float或double的primitive类型，使用==判断等价性;
对于floa类型，先使用Float.floatToIntBits转换成int类型，然后使用==比较int类型的值;
对于double类型，先使用Double.doubleToLongBits转换成long类型，然后使用==比较long类型;
对于对象引用，递归的调用equals方法。
对于数组类型，对其中的元素进行上述的操作,或者使用Arrays.equals方法(version 1.5)。
为了避免NPE，可以使用
field == null ? o.field == null : fleld.equals(o.field);

重写hashCode方法如下：
1 把某个非零常数值，例如17，保存在int变量result中；
2 对于对象中每一个关键域f（指equals方法中考虑的每一个域）,计算散列码c：
2.1 boolean型，计算(f ? 0 : 1);
2.2 byte,char,short型，计算(int);
2.3 long型，计算(int) (f ^ (f>>>32));
2.4 float型，计算Float.floatToIntBits(f);
2.5 double型，计算Double.doubleToLongBits(f)得到一个long，再执行[2.3];
2.6 对象引用，递归调用它的hashCode方法;
2.7 数组域，对其中每个元素按照上面的规则计算hash code。
3 将上面计算得到的散列码保存到int变量c，然后执行 result=37*result+c;
4 返回result。

calvin 2011-11-10 18:25 发表评论

利用javap生成方法签名

calvin — Mon, 24 Oct 2011 08:04:00 GMT

使用JNI在native内调用java方法时，需要知道java方法的方法签名，利用javap工具可以方便的生成签名。由于java方法签名在jni层的表示方法的复杂性，利用这个工具生成签名信息可以避免人工分析带来的错误。
如：

1 package com.demo;
2
3 public class SigTest {
4
5     public static final String name = null;
6
7     public int getName(int[] data,long index) {
8         return 0;
9     }
10 }
11

[calvin@calvin-desktop /tmp 15:59:50 ]
$ javac SigTest.java
[calvin@calvin-desktop /tmp 15:59:57 ]
$ javap -s -p -classpath . SigTest
Compiled from "SigTest.java"
public class com.demo.SigTest extends java.lang.Object{
public static final java.lang.String name;
Signature: Ljava/lang/String;
public com.demo.SigTest();
Signature: ()V
public int getName(int[], long);
Signature: ([IJ)I
static {};
Signature: ()V
}

-s表示打印签名信息
-p表示打印所有函数和成员的签名信息，默认只打印public的签名信息。

注意：
粗体部分是.class文件的文件名，不要.class后缀，否则提示
ERROR:Could not find SigTest.class.

calvin 2011-10-24 16:04 发表评论

Java foreach与泛型擦除

calvin — Fri, 17 Jun 2011 10:47:00 GMT

如下代码：

1         List appleList = new ArrayList<String>();
2         for(String apple:appleList){
3             //blabla
4         }

编译器 complains:Type mismatch: cannot convert from element type Object to String

http://www.infoq.com/cn/articles/cf-java-generics

calvin 2011-06-17 18:47 发表评论

chechstyle异常 “Static variable definition in wrong order”

calvin — Sat, 12 Feb 2011 02:52:00 GMT

原因在于变量声明的顺序不正确。

参见
http://java.sun.com/docs/codeconv/html/CodeConventions.doc2.html#1852

calvin 2011-02-12 10:52 发表评论

When Runtime.exec() won't

calvin — Tue, 23 Nov 2010 05:49:00 GMT

摘要: When Runtime.exec() won't http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html When Runtime.exec() won't Navigate yourself around pitfalls related to the Runtime.exec() method Summar... 阅读全文

calvin 2010-11-23 13:49 发表评论

如何中断线程

calvin — Fri, 29 Oct 2010 08:44:00 GMT

1.不要使用thread.stop()方法。
2.使用共享变量来检查是否需要终止线程。
但是如果线程被阻塞了，它就不可能去主动去检查变量了，这时要使用thread.interrupt来中断线程吗？
谨慎使用thread.interrupt方法！

Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。

因此，如果线程被上述几种方法阻塞，正确的停止线程方式时设置共享变量，并调用interrupt()（注意变量应该先设置）。如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，线程最后都将检查共享变量然后再停止。

中断标志必须是volatile的，以便run方法能够看到它，否则的话，这个值很有可能在本地有缓存。

线程代码为：

1 public void run() {
2     while(running) {
4         try {
5             // do something may block...

9         } catch (InterruptedException e) {
10             running = false;
12         }
13
14     }   //while
15     //.
16 }

需要停止线程时，调用：

1 running = false;
2 thread.interrupt();

注意，一定要先设置标志位后再调用interrupt！

如果线程因为其他原因阻塞，例如socket.accept()，这时，调用interrupt不会抛出异常，又该如何处理？
这些情况下，需要分别处理，例如在socket上调用close方法，它将抛出一个SocketException，这与抛出InterruptException类似。

参考：
1、http://blog.csdn.net/nihaozhangchao/archive/2010/01/07/5147803.aspx
2、http://blog.chenlb.com/2009/07/incorrect-use-thread-interrupt-cause-not-exit.html

calvin 2010-10-29 16:44 发表评论

线程相关知识点

calvin — Fri, 29 Oct 2010 07:23:00 GMT

线程概念
线程：是指进程中的一个执行流程。
线程与进程的区别：每个进程都需要操作系统为其分配独立的内存地址空间，而同一进程中的所有线程在同一块地址空间中工作，这些线程可以共享同一块内存和系统资源。

如何创建一个线程？
创建线程有两种方式，如下：
1、扩展java.lang.Thread类
2、实现Runnable接口
Thread类代表线程类，它的两个最主要的方法是：
run()——包含线程运行时所执行的代码
Start()——用于启动线程

一个线程被创建后只能被启动一次。第二次启动时将会抛出java.lang.IllegalThreadExcetpion异常

线程间状态的转换
新建状态：用new语句创建的线程对象处于新建状态，此时它和其它的java对象一样，仅仅在堆中被分配了内存
就绪状态：当一个线程创建了以后，其他的线程调用了它的start()方法，该线程就进入了就绪状态。处于这个状态的线程位于可运行池中，等待获得CPU的使用权
运行状态：处于这个状态的线程占用CPU,执行程序的代码
阻塞状态：当线程处于阻塞状态时，java虚拟机不会给线程分配CPU，直到线程重新进入就绪状态，它才有机会转到运行状态。
阻塞状态分为三种情况：
1、位于对象等待池中的阻塞状态：当线程运行时，如果执行了某个对象的wait()方法，java虚拟机就回把线程放到这个对象的等待池中
2、位于对象锁中的阻塞状态，当线程处于运行状态时，试图获得某个对象的同步锁时，如果该对象的同步锁已经被其他的线程占用，JVM就会把这个线程放到这个对象的琐池中。
3、其它的阻塞状态：

当前线程执行了sleep()方法
调用了其它线程的join()方法
发出了I/O请求时

死亡状态：当线程退出了run()方法，就进入了死亡状态，该线程结束了生命周期。
或者正常退出
或者遇到异常退出

Thread类的isAlive()方法判断一个线程是否活着，当线程处于死亡状态或者新建状态时，该方法返回false,在其余的状态下，该方法返回true.

线程调度
线程调度模型：分时调度模型和抢占式调度模型
JVM采用抢占式调度模型。
所谓的多线程的并发运行，其实是指宏观上看，各个线程轮流获得CPU的使用权，分别执行各自的任务。
（线程的调度不是跨平台，它不仅取决于java虚拟机，它还依赖于操作系统）

如果希望明确地让一个线程给另外一个线程运行的机会，可以采取以下的办法之一
1、调整各个线程的优先级
2、让处于运行状态的线程调用Thread.sleep()方法
3、让处于运行状态的线程调用Thread.yield()方法
4、让处于运行状态的线程调用另一个线程的join()方法

调整各个线程的优先级
Thread类的setPriority(int)和getPriority()方法分别用来设置优先级和读取优先级。
如果希望程序能够移值到各个操作系统中，应该确保在设置线程的优先级时，只使用MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY这3个优先级。

线程睡眠：当线程在运行中执行了sleep()方法时，它就会放弃CPU，转到阻塞状态。
线程让步：当线程在运行中执行了Thread类的yield()静态方法时，如果此时具有相同优先级的其它线程处于就绪状态，那么yield()方法将把当前运行的线程放到运行池中并使另一个线程运行。如果没有相同优先级的可运行线程，则yield()方法什么也不做。
Sleep()方法和yield()方法都是Thread类的静态方法，都会使当前处于运行状态的线程放弃CPU，把运行机会让给别的线程，两者的区别在于：
1、sleep()方法会给其他线程运行的机会，而不考虑其他线程的优先级，因此会给较低线程一个运行的机会；yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。
2、当线程执行了sleep(long millis)方法后，将转到阻塞状态，参数millis指定睡眠时间；当线程执行了yield()方法后，将转到就绪状态。
3、sleep()方法声明抛出InterruptedException异常，而yield()方法没有声明抛出任何异常
4、sleep()方法比yield()方法具有更好的移植性

等待其它线程的结束：join()
当前运行的线程可以调用另一个线程的 join()方法，当前运行的线程将转到阻塞状态，直到另一个线程运行结束，它才恢复运行。

定时器Timer:在JDK的java.util包中提供了一个实用类Timer, 它能够定时执行特定的任务。

线程的同步
原子操作：根据Java规范，对于基本类型的赋值或者返回值操作，是原子操作。但这里的基本数据类型不包括long和double, 因为JVM看到的基本存储单位是32位，而long 和double都要用64位来表示。所以无法在一个时钟周期内完成。

自增操作（++）不是原子操作，因为它涉及到一次读和一次写。

原子操作：由一组相关的操作完成，这些操作可能会操纵与其它的线程共享的资源，为了保证得到正确的运算结果，一个线程在执行原子操作其间，应该采取其他的措施使得其他的线程不能操纵共享资源。

同步代码块：为了保证每个线程能够正常执行原子操作，Java引入了同步机制，具体的做法是在代表原子操作的程序代码前加上synchronized标记，这样的代码被称为同步代码块。

同步锁：每个JAVA对象都有且只有一个同步锁，在任何时刻，最多只允许一个线程拥有这把锁。

当一个线程试图访问带有synchronized(this)标记的代码块时，必须获得 this关键字引用的对象的锁，在以下的两种情况下，本线程有着不同的命运。
1、假如这个锁已经被其它的线程占用，JVM就会把这个线程放到本对象的锁池中。本线程进入阻塞状态。锁池中可能有很多的线程，等到其他的线程释放了锁，JVM就会从锁池中随机取出一个线程，使这个线程拥有锁，并且转到就绪状态。
2、假如这个锁没有被其他线程占用，本线程会获得这把锁，开始执行同步代码块。
（一般情况下在执行同步代码块时不会释放同步锁，但也有特殊情况会释放对象锁
如在执行同步代码块时，遇到异常而导致线程终止，锁会被释放；在执行代码块时，执行了锁所属对象的wait()方法，这个线程会释放对象锁，进入对象的等待池中）

线程同步的特征：
1、如果一个同步代码块和非同步代码块同时操作共享资源，仍然会造成对共享资源的竞争。因为当一个线程执行一个对象的同步代码块时，其他的线程仍然可以执行对象的非同步代码块。（所谓的线程之间保持同步，是指不同的线程在执行同一个对象的同步代码块时，因为要获得对象的同步锁而互相牵制）
2、每个对象都有唯一的同步锁
3、在静态方法前面可以使用synchronized修饰符。
4、当一个线程开始执行同步代码块时，并不意味着必须以不间断的方式运行，进入同步代码块的线程可以执行Thread.sleep()或者执行Thread.yield()方法，此时它并不释放对象锁，只是把运行的机会让给其他的线程。
5、 Synchronized声明不会被继承，如果一个用synchronized修饰的方法被子类覆盖，那么子类中这个方法不在保持同步，除非用synchronized修饰。

线程安全的类：
1、这个类的对象可以同时被多个线程安全的访问。
2、每个线程都能正常的执行原子操作，得到正确的结果。
3、在每个线程的原子操作都完成后，对象处于逻辑上合理的状态。

释放对象的锁：
1、执行完同步代码块就会释放对象的锁
2、在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放
3、在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放对象锁，进入对象的等待池。

死锁
当一个线程等待由另一个线程持有的锁，而后者正在等待已被第一个线程持有的锁时，就会发生死锁。JVM不监测也不试图避免这种情况，因此保证不发生死锁就成了程序员的责任。

如何避免死锁
一个通用的经验法则是：当几个线程都要访问共享资源A、B、C 时，保证每个线程都按照同样的顺序去访问他们。

线程通信
Java.lang.Object类中提供了两个用于线程通信的方法
1、 wait():执行了该方法的线程释放对象的锁，JVM会把该线程放到对象的等待池中。该线程等待其它线程唤醒
2、 notify():执行该方法的线程唤醒在对象的等待池中等待的一个线程，JVM从对象的等待池中随机选择一个线程，把它转到对象的锁池中。

转自 http://blog.csdn.net/Android_Tutor/archive/2010/02/06/5293974.aspx

calvin 2010-10-29 15:23 发表评论

UTF-8文件头乱码问题

calvin — Tue, 27 Jul 2010 08:38:00 GMT

摘要: 阅读全文

calvin 2010-07-27 16:38 发表评论

CruiseControl配置说明

calvin — Tue, 29 Jun 2010 12:31:00 GMT

摘要: 阅读全文

calvin 2010-06-29 20:31 发表评论

HashMap，TreeMap，LinkedHashMap比较

calvin — Fri, 21 May 2010 07:51:00 GMT

摘要: 阅读全文

calvin 2010-05-21 15:51 发表评论

cruisecontrol参考

calvin — Thu, 20 May 2010 01:27:00 GMT

摘要: 阅读全文

calvin 2010-05-20 09:27 发表评论

将字节数组转化位int

calvin — Sat, 03 Apr 2010 15:42:00 GMT

摘要: 阅读全文

calvin 2010-04-03 23:42 发表评论

Java对象的强、软、弱和虚引用

calvin — Thu, 18 Mar 2010 13:31:00 GMT

摘要: 阅读全文

calvin 2010-03-18 21:31 发表评论

使用Ant时间戳

calvin — Tue, 16 Mar 2010 09:04:00 GMT

摘要: 阅读全文

calvin 2010-03-16 17:04 发表评论

JSON相关

calvin — Sun, 03 Jan 2010 14:47:00 GMT

摘要: 阅读全文

calvin 2010-01-03 22:47 发表评论

设计模式Double-Checked Locking失效问题

calvin — Sun, 03 Jan 2010 11:55:00 GMT

摘要: 阅读全文

calvin 2010-01-03 19:55 发表评论

Java散列集小结

calvin — Sun, 03 Jan 2010 04:25:00 GMT

摘要: 阅读全文

calvin 2010-01-03 12:25 发表评论

Java多线程编程总结

calvin — Fri, 01 Jan 2010 09:30:00 GMT

摘要: 阅读全文

calvin 2010-01-01 17:30 发表评论

非常有价值的NIO参考资料---The Rox Java NIO Tutorial

calvin — Sun, 27 Dec 2009 05:55:00 GMT

摘要: 阅读全文

calvin 2009-12-27 13:55 发表评论

Unix 5种IO模型的图解分析和比较

calvin — Sun, 27 Dec 2009 05:32:00 GMT

摘要: 阅读全文

calvin 2009-12-27 13:32 发表评论

同步/异步与阻塞/非阻塞的区别

calvin — Sun, 27 Dec 2009 05:24:00 GMT

摘要: 阅读全文

calvin 2009-12-27 13:24 发表评论

Java NIO（未完待续）

calvin — Thu, 24 Dec 2009 14:27:00 GMT

摘要: 阅读全文

calvin 2009-12-24 22:27 发表评论

Unicode详解

calvin — Tue, 22 Dec 2009 15:19:00 GMT

可能大家都听说过 Unicode、UCS-2、UTF-8 等等词汇，但它们具体是什么意思，是什么原理，之间有什么关系，恐怕就很少有人明白了。下面就分别介绍一下它们。
基本知识
字节和字符的区别
Big Endian和Little Endian
UCS-2和UCS-4
UTF-16和UTF-32
UTF-16
UTF-32
UTF-8
基本知识

介绍Unicode之前，首先要讲解一些基础知识。虽然跟Unicode没有直接的关系，但想弄明白Unicode，没这些还真不行。
字节和字符的区别

咦，字节和字符能有什么区别啊？不都是一样的吗？完全正确，但只是在古老的DOS时代。当Unicode出现后，字节和字符就不一样了。

字节（octet）是一个八位的存储单元，取值范围一定是0～255。而字符（character，或者word）为语言意义上的符号，范围就不一定了。例如在UCS-2中定义的字符范围为0～65535，它的一个字符占用两个字节。
Big Endian和Little Endian

上面提到了一个字符可能占用多个字节，那么这多个字节在计算机中如何存储呢？比如字符0xabcd，它的存储格式到底是 AB CD，还是 CD AB 呢？

实际上两者都有可能，并分别有不同的名字。如果存储为 AB CD，则称为Big Endian；如果存储为 CD AB，则称为Little Endian。

具体来说，以下这种存储格式为Big Endian，因为值(0xabcd)的高位(0xab)存储在前面：地址值
0x00000000 AB
0x00000001 CD

相反，以下这种存储格式为Little Endian：地址值
0x00000000 CD
0x00000001 AB

UCS-2和UCS-4

Unicode是为整合全世界的所有语言文字而诞生的。任何文字在Unicode中都对应一个值，这个值称为代码点（code point，参见Java核心技术的相关章节！）。代码点的值通常写成 U+ABCD 的格式。而文字和代码点之间的对应关系就是UCS-2（Universal Character Set coded in 2 octets）。顾名思义，UCS-2是用两个字节来表示代码点，其取值范围为 U+0000～U+FFFF。

为了能表示更多的文字，人们又提出了UCS-4，即用四个字节表示代码点。它的范围为 U+00000000～U+7FFFFFFF，其中 U+00000000～U+0000FFFF和UCS-2是一样的。

要注意，UCS-2和UCS-4只规定了代码点和文字之间的对应关系，并没有规定代码点在计算机中如何存储。规定存储方式的称为UTF（Unicode Transformation Format），其中应用较多的就是UTF-16和UTF-8了。
UTF-16和UTF-32
UTF-16

UTF-16由RFC2781规定，它使用两个字节来表示一个代码点。

不难猜到，UTF-16是完全对应于UCS-2的，即把UCS-2规定的代码点通过Big Endian或Little Endian方式直接保存下来。UTF-16包括三种：UTF-16，UTF-16BE（Big Endian），UTF-16LE（Little Endian）。

UTF-16BE和UTF-16LE不难理解，而UTF-16就需要通过在文件开头以名为BOM（Byte Order Mark）的字符来表明文件是Big Endian还是Little Endian。BOM为U+FEFF这个字符。

其实BOM是个小聪明的想法。由于UCS-2没有定义U+FFFE，因此只要出现 FF FE 或者 FE FF 这样的字节序列，就可以认为它是U+FEFF，并且可以判断出是Big Endian还是Little Endian。

举个例子。“ABC”这三个字符用各种方式编码后的结果如下：UTF-16BE 00 41 00 42 00 43
UTF-16LE 41 00 42 00 43 00
UTF-16(Big Endian) FE FF 00 41 00 42 00 43
UTF-16(Little Endian) FF FE 41 00 42 00 43 00
UTF-16(不带BOM) 00 41 00 42 00 43

Windows平台下默认的Unicode编码为Little Endian的UTF-16（即上述的 FF FE 41 00 42 00 43 00）。你可以打开记事本，写上ABC，然后保存，再用二进制编辑器看看它的编码结果。

另外，UTF-16还能表示一部分的UCS-4代码点——U+10000～U+10FFFF。表示算法比较复杂，简单说明如下：
从代码点U中减去0x10000，得到U'。这样U+10000～U+10FFFF就变成了 0x00000～0xFFFFF。
用20位二进制数表示U'。 U'=yyyyyyyyyyxxxxxxxxxx
将前10位和后10位用W1和W2表示，W1=110110yyyyyyyyyy，W2=110111xxxxxxxxxx，则 W1 = D800～DBFF，W2 = DC00～DFFF。

例如，U+12345表示为 D8 08 DF 45（UTF-16BE），或者08 D8 45 DF（UTF-16LE）。

但是由于这种算法的存在，造成UCS-2中的 U+D800～U+DFFF 变成了无定义的字符。
UTF-32

UTF-32用四个字节表示代码点，这样就可以完全表示UCS-4的所有代码点，而无需像UTF-16那样使用复杂的算法。与UTF-16类似，UTF-32也包括UTF-32、UTF-32BE、UTF-32LE三种编码，UTF-32也同样需要BOM字符。仅用'ABC'举例：UTF-32BE 00 00 00 41 00 00 00 42 00 00 00 43
UTF-32LE 41 00 00 00 42 00 00 00 43 00 00 00
UTF-32(Big Endian) 00 00 FE FF 00 00 00 41 00 00 00 42 00 00 00 43
UTF-32(Little Endian) FF FE 00 00 41 00 00 00 42 00 00 00 43 00 00 00
UTF-32(不带BOM) 00 00 00 41 00 00 00 42 00 00 00 43

UTF-8

UTF-16和UTF-32的一个缺点就是它们固定使用两个或四个字节，这样在表示纯ASCII文件时会有很多00字节，造成浪费。而RFC3629定义的UTF-8则解决了这个问题。

UTF-8用1～4个字节来表示代码点。表示方式如下：UCS-2 (UCS-4) 位序列第一字节第二字节第三字节第四字节
U+0000 .. U+007F 00000000-0xxxxxxx 0xxxxxxx
U+0080 .. U+07FF 00000xxx-xxyyyyyy 110xxxxx 10yyyyyy
U+0800 .. U+FFFF xxxxyyyy-yyzzzzzz 1110xxxx 10yyyyyy 10zzzzzz
U+10000..U+10FFFF 00000000-000wwwxx-
xxxxyyyy-yyzzzzzzz 11110www 10xxxxxx 10yyyyyy 10zzzzzz

可见，ASCII字符（U+0000～U+007F）部分完全使用一个字节，避免了存储空间的浪费。而且UTF-8不再需要BOM字节。

另外，从上表中可以看出，单字节编码的第一字节为[00-7F]，双字节编码的第一字节为[C2-DF]，三字节编码的第一字节为[E0-EF]。这样只要看到第一个字节的范围就可以知道编码的字节数。这样也可以大大简化算法。

calvin 2009-12-22 23:19 发表评论

Java远程通讯可选技术及原理

calvin — Sun, 13 Dec 2009 04:12:00 GMT

摘要: 阅读全文

calvin 2009-12-13 12:12 发表评论

理解ThreadLocal变量

calvin — Wed, 23 Sep 2009 09:15:00 GMT

概述

我们知道Spring通过各种DAO模板类降低了开发者使用各种数据持久技术的难度。这些模板类都是线程安全的，也就是说，多个DAO可以复用同一个模板实例而不会发生冲突。

我们使用模板类访问底层数据，根据持久化技术的不同，模板类需要绑定数据连接或会话的资源。但这些资源本身是非线程安全的，也就是说它们不能在同一时刻被多个线程共享。

虽然模板类通过资源池获取数据连接或会话，但资源池本身解决的是数据连接或会话的缓存问题，并非数据连接或会话的线程安全问题。

按照传统经验，如果某个对象是非线程安全的，在多线程环境下，对对象的访问必须采用synchronized进行线程同步。但Spring的DAO模板类并未采用线程同步机制，因为线程同步限制了并发访问，会带来很大的性能损失。

此外，通过代码同步解决性能安全问题挑战性很大，可能会增强好几倍的实现难度。那模板类究竟仰丈何种魔法神功，可以在无需同步的情况下就化解线程安全的难题呢？答案就是ThreadLocal！

ThreadLocal在Spring中发挥着重要的作用，在管理request作用域的Bean、事务管理、任务调度、AOP等模块都出现了它们的身影，起着举足轻重的作用。要想了解Spring事务管理的底层技术，ThreadLocal是必须攻克的山头堡垒。

ThreadLocal是什么

早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序。

ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。其实，ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。

线程局部变量并不是Java的新发明，很多语言（如IBM IBM XL FORTRAN）在语法层面就提供线程局部变量。在Java中没有提供在语言级支持，而是变相地通过ThreadLocal的类提供支持。

所以，在Java中编写线程局部变量的代码相对来说要笨拙一些，因此造成线程局部变量没有在Java开发者中得到很好的普及。

ThreadLocal的接口方法

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(Object value)

设置当前线程的线程局部变量的值。

public Object get()

该方法返回当前线程所对应的线程局部变量。

public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

protected Object initialValue()

返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

值得一提的是，在JDK5.0中，ThreadLocal已经支持泛型，该类的类名已经变为ThreadLocal。API方法也相应进行了调整，新版本的API方法分别是void set(T value)、T get()以及T initialValue()。

ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单：在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。我们自己就可以提供一个简单的实现版本：

代码清单1 SimpleThreadLocal

public class SimpleThreadLocal {

private Map valueMap = Collections.synchronizedMap(new HashMap());

public void set(Object newValue) {

valueMap.put(Thread.currentThread(), newValue);①键为线程对象，值为本线程的变量副本

}

public Object get() {

Thread currentThread = Thread.currentThread();

Object o = valueMap.get(currentThread);②返回本线程对应的变量

if (o == null && !valueMap.containsKey(currentThread)) {③如果在Map中不存在，放到Map

中保存起来。

o = initialValue();

valueMap.put(currentThread, o);

}

return o;

}

public void remove() {

valueMap.remove(Thread.currentThread());

}

public Object initialValue() {

return null;

}

虽然代码清单9‑3这个ThreadLocal实现版本显得比较幼稚，但它和JDK所提供的ThreadLocal类在实现思路上是相近的。

一个TheadLocal实例

下面，我们通过一个具体的实例了解一下ThreadLocal的具体使用方法。

代码清单2 SequenceNumber

package com.baobaotao.basic;

public class SequenceNumber {

①通过匿名内部类覆盖ThreadLocal的initialValue()方法，指定初始值

private static ThreadLocal seqNum = new ThreadLocal(){

public Integer initialValue(){

return 0;

}

};

②获取下一个序列值

public int getNextNum(){

seqNum.set(seqNum.get()+1);

return seqNum.get();

}

public static void main(String[] args)

{

SequenceNumber sn = new SequenceNumber();

③ 3个线程共享sn，各自产生序列号

TestClient t1 = new TestClient(sn);

TestClient t2 = new TestClient(sn);

TestClient t3 = new TestClient(sn);

t1.start();

t2.start();

t3.start();

}

private static class TestClient extends Thread

{

private SequenceNumber sn;

public TestClient(SequenceNumber sn) {

this.sn = sn;

}

public void run()

{

for (int i = 0; i < 3; i++) {④每个线程打出3个序列值

System.out.println("thread["+Thread.currentThread().getName()+

"] sn["+sn.getNextNum()+"]");

}

通常我们通过匿名内部类的方式定义ThreadLocal的子类，提供初始的变量值，如例子中①处所示。TestClient线程产生一组序列号，在③处，我们生成3个TestClient，它们共享同一个SequenceNumber实例。运行以上代码，在控制台上输出以下的结果：

thread[Thread-2] sn[1]

thread[Thread-0] sn[1]

thread[Thread-1] sn[1]

thread[Thread-2] sn[2]

thread[Thread-0] sn[2]

thread[Thread-1] sn[2]

thread[Thread-2] sn[3]

thread[Thread-0] sn[3]

thread[Thread-1] sn[3]

考察输出的结果信息，我们发现每个线程所产生的序号虽然都共享同一个SequenceNumber实例，但它们并没有发生相互干扰的情况，而是各自产生独立的序列号，这是因为我们通过ThreadLocal为每一个线程提供了单独的副本。

Thread同步机制的比较

ThreadLocal和线程同步机制相比有什么优势呢？ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

由于ThreadLocal中可以持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，需要强制类型转换。但JDK 5.0通过泛型很好的解决了这个问题，在一定程度地简化ThreadLocal的使用，代码清单 9 2就使用了JDK 5.0新的ThreadLocal版本。

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

Spring使用ThreadLocal解决线程安全问题

我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

一般的Web应用划分为展现层、服务层和持久层三个层次，在不同的层中编写对应的逻辑，下层通过接口向上层开放功能调用。在一般情况下，从接收请求到返回响应所经过的所有程序调用都同属于一个线程，如图9‑2所示：

图1同一线程贯通三层

这样你就可以根据需要，将一些非线程安全的变量以ThreadLocal存放，在同一次请求响应的调用线程中，所有关联的对象引用到的都是同一个变量。

下面的实例能够体现Spring对有状态Bean的改造思路：

代码清单3 TopicDao：非线程安全

public class TopicDao {

private Connection conn;①一个非线程安全的变量

public void addTopic(){

Statement stat = conn.createStatement();②引用非线程安全变量

…

}

由于①处的conn是成员变量，因为addTopic()方法是非线程安全的，必须在使用时创建一个新TopicDao实例（非singleton）。下面使用ThreadLocal对conn这个非线程安全的“状态”进行改造：

代码清单4 TopicDao：线程安全

import java.sql.Connection;

import java.sql.Statement;

public class TopicDao {

①使用ThreadLocal保存Connection变量

private static ThreadLocal connThreadLocal = new ThreadLocal();

public static Connection getConnection(){

②如果connThreadLocal没有本线程对应的Connection创建一个新的Connection，

并将其保存到线程本地变量中。

if (connThreadLocal.get() == null) {

Connection conn = ConnectionManager.getConnection();

connThreadLocal.set(conn);

return conn;

}else{

return connThreadLocal.get();③直接返回线程本地变量

}

public void addTopic() {

④从ThreadLocal中获取线程对应的Connection

Statement stat = getConnection().createStatement();

}

不同的线程在使用TopicDao时，先判断connThreadLocal.get()是否是null，如果是null，则说明当前线程还没有对应的Connection对象，这时创建一个Connection对象并添加到本地线程变量中；如果不为null，则说明当前的线程已经拥有了Connection对象，直接使用就可以了。这样，就保证了不同的线程使用线程相关的Connection，而不会使用其它线程的Connection。因此，这个TopicDao就可以做到singleton共享了。

当然，这个例子本身很粗糙，将Connection的ThreadLocal直接放在DAO只能做到本DAO的多个方法共享Connection时不发生线程安全问题，但无法和其它DAO共用同一个Connection，要做到同一事务多DAO共享同一Connection，必须在一个共同的外部类使用ThreadLocal保存Connection。但这个实例基本上说明了Spring对有状态类线程安全化的解决思路。

小结

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

原文出处：http://www.builder.com.cn/2007/0529/404698.shtml

calvin 2009-09-23 17:15 发表评论

常用log4j.properties

calvin — Tue, 22 Sep 2009 07:58:00 GMT

log4j.rootLogger=DEBUG,CONSOLE,DATABASE,FILE
log4j.addivity.org.apache=true

# 应用于控制台
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Threshold=INFO
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.Encoding=GBK
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库
#log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
#log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/ww
#log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
#log4j.appender.DATABASE.user=root
#log4j.appender.DATABASE.password=123
#log4j.appender.CONSOLE.Threshold=WARN
#log4j.appender.DATABASE.sql=INSERT INTO LOG(stamp,thread, infolevel,class,messages) VALUES ('%d{yyyy-MM-dd HH:mm:ss}', '%t', '%p', '%l', '%m')
# INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
# 写入数据库中的表LOG的Message字段中，内容％d（日期）%c: 日志信息所在地（类名）%p: 日志信息级别%m: 产生的日志具体信息 %n: 输出日志信息换行
#log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
#log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 每天新建日志
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=C:/log4j/log
log4j.appender.A1.Encoding=GBK
log4j.appender.A1.Threshold=DEBUG
log4j.appender.A1.DatePattern='.'yyyy-MM-dd
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L : %m%n

#应用于文件
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=C:/log4j/file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.Encoding=GBK
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 应用于文件回滚
log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.CONSOLE_FILE.Encoding=GBK
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#自定义Appender
log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender
log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = corlin@cybercorlin.net
log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n
# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件
log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=user@abc.com
log4j.appender.MAIL.SMTPHost=www.abc.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=user@abc.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

参考资料：
log4j详解与实战

calvin 2009-09-22 15:58 发表评论

参考资源

calvin — Mon, 21 Sep 2009 09:19:00 GMT

1.理解DOM——很详尽的DOM入门资料
https://www6.software.ibm.com/developerworks/cn/education/xml/x-udom/section2.html

http://www.cnblogs.com/huangyu/articles/33572.html

DOM路标图

2.理解SAX

https://www6.software.ibm.com/developerworks/cn/education/xml/x-usax/index.html

http://www.cnblogs.com/huangyu/archive/2004/08/16/33934.html

SAX 是什么？

用于读取和操作 XML 文件的标准是文档对象模型（Document Object Model，DOM）。遗憾的是，DOM 方法涉及读取整个文件并将该文件存储在一个树结构中，而这样可能是低效的、缓慢的，并且很消耗资源。

一种替代技术就是 Simple API for XML，或称为 SAX。SAX 允许您在读取文档时处理它，从而不必等待整个文档被存储之后才采取操作。

SAX 是由 XML-DEV 邮件列表的成员开发的，现在对应的 Java 版本是 SourceForge 项目（请参阅参考资料）。该项目的目的是为 XML 的使用提供一种更自然的手段 —— 换句话说，也就是不涉及 DOM 所必需的开销和概念跳跃。

项目的成果是一个基于事件 的 API。解析器向一个事件处理程序发送事件，比如元素的开始和结束，而事件处理程序则处理该信息。然后应用程序才能够处理该数据。原始的文档仍然保持原样，但是 SAX 提供了操作数据的手段，因此数据可以用于另一个进程或文档。

SAX 没有官方的标准机构，由万维网联盟（Wide Web Consortium，W3C）或其他官方机构维护，但它是 XML 社区事实上的标准。

SAX 处理涉及以下步骤：

创建一个事件处理程序。
创建 SAX 解析器。
向解析器分配事件处理程序。
解析文档，同时向事件处理程序发送每个事件。

基于事件的处理的优点和缺点

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

另一方面，由于应用程序没有以任何方式存储数据，使用 SAX 来更改数据或在数据流中往后移是不可能的。

SAX 和 DOM 不是相互排斥的，记住这点很重要。您可以使用 DOM 来创建 SAX 事件流，也可以使用 SAX 来创建 DOM 树。事实上，用于创建 DOM 树的大多数解析器实际上都使用 SAX 来完成这个任务！

3.DW上的相关资源
http://www.ibm.com/developerworks/cn/xml/

4.使用Xpath提高基于DOM的XML处理效率
http://www.ibm.com/developerworks/cn/xml/x-domjava/index.shtml

calvin 2009-09-21 17:19 发表评论

关于REST

calvin — Thu, 17 Sep 2009 12:06:00 GMT

这阵子正打算用Rails做个东东，所以开始系统地学习起了Rails。巧合的是，大概两周前，dlee邀请我加入Fielding博士关于REST的那篇论文的翻译团队。可以说Rails和REST这两个最热门的词汇几乎同时挤入了我的生活。随着我对Rails的学习和对[Fielding]的翻译，我也开始对REST产生了一些不太成熟的想法，写在这里与大家分享，同时也起到抛砖引玉的作用，欢迎大家讨论。

先复习一下REST的基本思想。[Fielding]把REST形式化地定义为一种架构风格（architecture style），它有架构元素（element）和架构约束（constraint）组成。这些概念比较晦涩难懂，而且我们做工程的往往并不需要形而上的理解。我们只知道，REST是一种针对网络应用的设计和开发方式，可以降低开发的复杂性，提高系统的可伸缩性。REST提出了一些设计概念和准则：

网络上的所有事物都被抽象为资源（resource）；

每个资源对应一个唯一的资源标识（resource identifier）；

通过通用的连接器接口（generic connector interface）对资源进行操作；

对资源的各种操作不会改变资源标识；

所有的操作都是无状态的（stateless）。

对于当今最常见的网络应用来说，resource identifier是url，generic connector interface是HTTP，第4条准则就是我们常说的url不变性。这些概念中的resouce最容易使人产生误解。resouce所指的并不是数据，而是数据+特定的表现形式（representation），这也是为什么REST的全名是Representational State Transfer的原因。举个例子来说，“本月卖得最好的10本书”和“你最喜欢的10本书”在数据上可能有重叠（有一本书即卖得好，你又喜欢），甚至完全相同。但是它们的representation不同，因此是不同的resource。

REST之所以能够简化开发，是因为其引入的架构约束，比如Rails 1.2中对REST的实现默认把controller中的方法限制在7个：index、show、new、edit、create、update和destory，这实际上就是对CURD的实现。更进一步讲，Rails（也是当今大部分网络应用）使用HTTP作为generic connector interface，HTTP则把对一个url的操作限制在了4个之内：GET、POST、PUT和DELETE。

REST之所以能够提高系统的可伸缩性，是因为它强制所有操作都是stateless的，这样就没有context的约束，如果要做分布式、做集群，就不需要考虑context的问题了。同时，它令系统可以有效地使用pool。REST对性能的另一个提升来自其对client和server任务的分配：server只负责提供resource以及操作resource的服务，而client要根据resource中的data和representation自己做render。这就减少了服务器的开销。

既然REST有这样的好处，那我们应该义无反顾地拥抱它啊！目前一些大牛（像DHH）都已经开始投入到了REST的世界，那我们这些人应该做什么或者说思考写什么你呢？我觉得我们应该思考两个问题：

如何使用REST；

REST和MVC的关系。

第一个问题假设REST是我们应该采用的架构，然后讨论如何使用；第二个问题则要说明REST和当前最普遍应用的MVC是什么关系，互补还是取代？

我们先来谈谈第一个问题，如何使用REST。我感觉，REST除了给我们带来了一个崭新的架构以外，还有一个重要的贡献是在开发系统过程中的一种新的思维方式：通过url来设计系统的结构。根据REST，每个url都代表一个resource，而整个系统就是由这些resource组成的。因此，如果url是设计良好的，那么系统的结构就也应该是设计良好的。对于非高手级的开发人员来说，考虑一个系统如何架构总是一个很抽象的问题。敏捷开发所提倡的Test Driven Development，其好处之一（我觉得是最大的好处）就是可以通过testcase直观地设计系统的接口。比如在还没有创建一个class的时候就编写一个testcase，虽然设置不能通过编译，但是testcase中的方法调用可以很好地从class使用者的角度反映出需要的接口，从而为class的设计提供了直观的表现。这与在REST架构中通过url设计系统结构非常类似。虽然我们连一个功能都没有实现，但是我们可以先设计出我们认为合理的url，这些url甚至不能连接到任何page或action，但是它们直观地告诉我们：系统对用户的访问接口就应该是这样。根据这些url，我们可以很方便地设计系统的结构。

让我在这里重申一遍：REST允许我们通过url设计系统，就像Test Driven Development允许我们使用testcase设计class接口一样。

OK，既然url有这样的好处，那我们就着重讨论一下如何设计url。网络应用通常都是有hierarchy的，像棵大树。我们通常希望url也能反映出资源的层次性。比如对于一个blog应用：/articles表示所有的文章，/articles/1表示id为1的文章，这都比较直观。遗憾的是，网络应用的资源结构永远不会如此简单。因此人们常常会问这样一个问题：RESTful的url能覆盖所有的用户请求吗？比如，login如何RESTful？search如何RESTful？

从REST的概念上来看，所有可以被抽象为资源的东东都可以使用RESTful的url。因此对于上面的两个问题，如果login和search可以被抽象为资源，那么就可以使用RESTful的url。search比较简单，因为它会返回搜索结果，因此可以被抽象为资源，并且只实现index方法就可以了（只需要显示搜索结果，没有create、destory之类的东西）。然而这里面也有一个问题：search的关键字如何传给server？index方法显然应该使用HTTP GET，这会把关键字加到url后面，当然不符合REST的风格。要解决这个问题，可以把每次search看作一个资源，因此要创建create和index方法，create用来在用户点击“搜索”按钮是通过HTTP POST把关键字传给server，然后index则用来显示搜索结果。这样一来，我们还可以记录用户的搜索历史。使用同样的方法，我们也可以对login应用REST，即每次login动作是一个资源。

现在，我们来复杂一些的东东。如何用url表达“category为ruby的article”？一开始可能想到的是/category/ruby/articles，这种想法很直观。但是我觉得里面的category是不需要的，我们可以直接把“/ruby”理解为“category是ruby”，也就是说“ruby”出现的位置说明了它指的就是category。OK，/ruby/articles，单单从这个url上看，我们能获得多少关于category的信息呢？显然category隐藏在了url后面，这样做到底好不好，应该是仁者见仁，智者见智了。对于如何表达category这样的东西，我还没想出很好的方式，大家有什么好idea，可以一起讨论。

另外还有一种url形式，它对应到程序中的继承关系。比如product是一个父类，book和computer是其子类。那么所有产品的url应该是/products，所有书籍的url应该是/books，所有电脑的url应该是/computers。这一想法就比较直观了，而且再次验证了url可以帮助我们进行设计的论点。

让我再说明一下我的想法：如果每个用户需求都可以抽象为资源，那么就可以完全使用REST。

由此看来，使用REST的关键是如何抽象资源，抽象得越精确，对REST的应用就越好。因此，如何改变我们目前根深蒂固的基于action的思想是最重要的。

有了对第一个问题的讨论，第二个问题就容易讨论多了。REST会取代MVC吗？还是彼此是互补关系（就像AOP对于OOP）？答案是It depends！如果我们可以把所有的用户需求都可以抽象为资源，那么MVC就可以推出历史的舞台了。如果情况相反，那么我们就需要混合使用REST和MVC。

当然，这是非常理想的论断。可能我们无法找到一种方法可以把所有的用户需求都抽象为资源，因为保证这种抽象的完整性（即真的是所有需求都可以）需要形式化的证明。而且即使被证明出来了，由于开发人员的能力和喜好不同，MVC肯定也会成为不少人的首选。但是对于希望拥抱REST的人来说，这些都没有关系。只要你开发的系统所设计的问题域可以被合理地抽象为资源，那么REST就会成为你的开发利器。

所以，所有希望拥抱REST的朋友们，赶快训练自己如何带上资源的眼镜看世界吧，这才是REST的核心所在。

转载自javaeye论坛　作者：AllenYoung

原文地址：http://www.javaeye.com/topic/70113

资源： http://www.ibm.com/developerworks/cn/web/wa-ajaxarch/

calvin 2009-09-17 20:06 发表评论

[转]线程上下文类加载器

calvin — Thu, 17 Sep 2009 11:15:00 GMT

摘要: 线程上下文类加载器问题：何时使用Thread.getContextClassLoader()? 这是一个很常见的问题，但答案却很难回答。这个问题通常在需要动态加载类和资源的系统编程时会遇到。总的说来动态加载资源时，往往需要从三种类加载器里选择：系统或说程序的类加载器、当前类加载器、以及当前线程的上下文类加载器。在程序中应该使用何种类加载器呢？系统类加载器通常不会使用。此类加载... 阅读全文

calvin 2009-09-17 19:15 发表评论