BlogJava-java 友人帮-文章分类-java SE

commons-lang-2.4.jar 包常用方法集锦

Gavin.lee — Tue, 08 Jun 2010 16:04:00 GMT

import java.util.Iterator;
import java.util.Map;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.ClassUtils;
import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;

/**
* commons-lang-2.4.jar 包常用方法集锦
*
*/
public class CommonsLang {

public static void main(String[] args) {
  String[] test = {"33", "ddffd"};
  String[] test1 = {"ddffd", "33"};

  // 1.判断两个数据是否相等
  System.out.println(ArrayUtils.isEquals(test, test1));
  // 2.{33,ddffd} 将数组内容以{,}形式输出．
  System.out.println(ArrayUtils.toString(test));
  Map map = ArrayUtils.toMap(new String[][] { { "RED", "#FF0000" }, { "GREEN", "#00FF00" }, { "BLUE", "#0000FF" } });
  // 3.toMap 一个数组，但每个元素 Each element of the array
  // must be either a {@link java.util.Map.Entry} or an Array,
  // 方式一下面是遍历map的方式，取得其keySet.iterator();
  Iterator it = map.keySet().iterator();
  while (it.hasNext()) {
   String key = (String) it.next();
   // it.next()只包含key
   System.out.println("key:" + key + "value:" + map.get(key));
  }
  // 方式二,取得其entrySet()集合,
  Iterator it1 = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry entry = (Map.Entry) it1.next();
   // it1.next()中包含key和value
   System.out.println("key :" + entry.getKey() + "value :" + entry.getValue());
  }

  // 4.取得类名
  System.out.println(ClassUtils.getShortClassName(Test.class));
  // 取得其包名
  System.out.println(ClassUtils.getPackageName(Test.class));
  // 5.NumberUtils
  System.out.println(NumberUtils.stringToInt("6"));
  System.out.println(NumberUtils.stringToInt("7", 10));
  // 6.五位的随机字母和数字
  System.out.println(RandomStringUtils.randomAlphanumeric(5));
  // 7.StringEscapeUtils
  System.out.println(StringEscapeUtils.escapeHtml(""));
  // 输出结果为<html>
  System.out.println(StringEscapeUtils.escapeJava("String"));
  // 8.StringUtils,判断是否是空格字符
  System.out.println(StringUtils.isBlank("   "));
  // 将数组中的内容以,分隔
  System.out.println(StringUtils.join(test, ","));
  // 在右边加下字符,使之总长度为6
  System.out.println(StringUtils.rightPad("abc", 6, 'T'));
  // 首字母大写
  System.out.println(StringUtils.capitalize("abc"));
  // Deletes all whitespaces from a String 删除所有空格
  System.out.println(StringUtils.deleteWhitespace("   ab c "));
  // 判断是否包含这个字符
  System.out.println(StringUtils.contains("abc", "ba"));
  // 表示左边两个字符
  System.out.println(StringUtils.left("abc", 2));
  System.out.println(StringUtils.right("abcd", 3));
}
}

Gavin.lee 2010-06-09 00:04 发表评论

String&InputStream的相互转化

Gavin.lee — Wed, 03 Feb 2010 14:15:00 GMT

1.InputStream ---> String

            InputStream is = getMethod.getResponseBodyAsStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            StringBuffer buffer = new StringBuffer();
            String str = "", response = "";

            while((str = br.readLine())!=null){
                response =buffer.append(str).toString();
            }

2.String --->InputStream

InputStream stream = new ByteArrayInputStream("".getBytes());

ByteArrayInputStream 是InputStream 的子类

Gavin.lee 2010-02-03 22:15 发表评论

java 堆与栈的详细介绍

Gavin.lee — Thu, 14 Jan 2010 15:10:00 GMT

http://yysct2005.javaeye.com/category/8938

Gavin.lee 2010-01-14 23:10 发表评论

HttpClient 一文通（摘）

Gavin.lee — Thu, 14 Jan 2010 15:08:00 GMT

原文出处--------http://hi.baidu.com/wader2006/blog/item/7e7b3a291f7801fd99250a91.html

虽然用telnet这样的程序都可把页面取回来，但是在与web服务器的交互中，如果涉及cookie或https或ssl等内容，一般功能相对完备的http客户端还是非常必要的。IE或NetScape等浏览器确实不错，可是如果为实现持续互动而在程序调用浏览器，我个人认为其中的工作量还是不小的，这还没考虑版权问题。最好的办法，就是能有一个开源的包，能实现http客户端的功能，供我们开发的程序调用。httpclient就是这么一个包，我相信可能有比它的实现更好的，但目前我只关注这个。：）
　　下面是nogoop做的功能比较表：

Features	nogoop	Sun JRE < 1.4.2	Sun JRE 1.4.2	Innovation	Apache/Jakarta
cookies				X	X
plug compatible	X	X	X	X	[partial]
true request output stream				X	X
true response input stream	X			X	X
connection keep alive	X	X	X	X	X
connection pool throttling	X				X
connection/request timeout	X		X [uns]	X	X
idle connection timeout	X				X
pipelining of requests				X
alternate DNS resolution (dnsjava)	X
SSL	X	X	X	X	X
basic authentication	X	X	X	X	X
digest authentication	X	X	X	X	X
NTLM authentication	X		[Windows only]		X
proxy authentication	X	X	X	X	X
minimum JRE version	1.2	1	01年4月2日	1.2	1.2
price	$499	free	free	free	free
source available	X			X	X
diagnostic tracing	X			X	X
actively supported	X	X	X		X
fix turnaround	fast	slow	slow	none	medium
license	purchase	Sun JRE	Sun JRE	LGPL	Apache

1、HttpClient的功能

基于标准，纯正java，实现了http1.0和1.1。
在一个可扩展的OO框架内，实现了HTTP的全部方法(GET, POST,
PUT, DELETE, HEAD, OPTIONS, and TRACE)
支持HTTPS(ssl上的HTTP)的加密操作
透明地穿过HTTP代理建立连接
通过CONNECT方法，利用通过建立穿过HTTP代理的HTTPS连接
利用本地Java socket，透明地穿过SOCKS(版本5和4）代理建立连接
支持利用Basic、Digest和NTLM加密的认证
支持用于上传大文件的Multi-Part表单POST方法
插件式安全socket实现，易于使用第三方的解决方案
连接管理，支持多线程应用，支持设定单个主机总连接和最高连接数量,自动检测和关闭失效连接
直接将请求信息流送到服务器的端口
直接读取从服务器的端口送出的应答信息
支持HTTP/1.0中用KeepAlive和HTTP/1.1中用persistance设置的持久连接
直接访问由服务器送出的应答代码和头部信息
可设置连接超时时间
HttpMethods 实现Command Pattern，以允许并行请求或高效连接复用
遵循the Apache Software License协议，源码免费可得

2、预备工作

　　对jre1.3.*，如果要HttpClient支持https，则需要下载并安装 jsse和jce.安装的步骤如下：
1)下载jsse和jce.
2)检查CLASSPATH中没有与jsse和jce相关的jar包
3)将 US_export_policy.jar、local_policy.jar、jsse.jar、jnet.jar、jce1_2_x.jar、sunjce_provider.jar、jcert.jar复制到目录：
UNIX:$JDK_HOME/jre/lib/ext
Windows:%JDK_HOME%\jre\lib\ext
4)修改下述目录下的java.security文件。
UNIX:$JDK_HOME/jre/lib/security/
Windows:%JDK_HOME%\jre\lib\security\
5)

将
#
# List of providers and their preference orders:
#
security.provider.1=sun.security.provider.Sun
security.provider.2=com.sun.rsajca.Provider
改为：
#
# List of providers and their preference orders:
#
security.provider.1=com.sun.crypto.provider.SunJCE
security.provider.2=sun.security.provider.Sun
security.provider.3=com.sun.rsajca.Provider
security.provider.4=com.sun.net.ssl.internal.ssl.Provider

　　HttpClient还要求安装commons-logging，下面跟httpclient一块安装。

3、取得源码

cvs -d :pserver:anoncvs@cvs.apache.org:/home/cvspublic login
password: anoncvs
cvs -d :pserver:anoncvs@cvs.apache.org:/home/cvspublic checkout jakarta-commons/logging
cvs -d :pserver:anoncvs@cvs.apache.org:/home/cvspublic checkout jakarta-commons/httpclient

　　编译：

cd jakarta-commons/logging
ant dist
cp dis/*.jar ../httpclient/lib/
cd ../httpclient
ant dist

4、使用HttpClient编程的基本步聚

创建 HttpClient 的一个实例.
创建某个方法（DeleteMethod，EntityEnclosingMethod，ExpectContinueMethod，GetMethod，HeadMethod，MultipartPostMethod，OptionsMethod，PostMethod，PutMethod，TraceMethod）的一个实例，一般可用要目标URL为参数。
让 HttpClient 执行这个方法.
读取应答信息.
释放连接.
处理应答.

　　在执行方法的过程中，有两种异常，一种是HttpRecoverableException，表示偶然性错误发生，一般再试可能成功，另一种是IOException，严重错误。
　　这儿有这个教程中的一个例程，可以下载。

5、认证

　　HttpClient三种不同的认证方案: Basic, Digest and NTLM. 这些方案可用于服务器或代理对客户端的认证，简称服务器认证或代理认证。
1)服务器认证(Server Authentication)
　　HttpClient处理服务器认证几乎是透明的，仅需要开发人员提供登录信息(login credentials)。登录信息保存在HttpState类的实例中，可以通过 setCredentials(String realm, Credentials cred)和getCredentials(String realm)来获取或设置。注意，设定对非特定站点访问所需要的登录信息，将realm参数置为null. HttpClient内建的自动认证，可以通过HttpMethod类的setDoAuthentication(boolean doAuthentication)方法关闭，而且这次关闭只影响HttpMethod当前的实例。
　　抢先认证(Preemptive Authentication)可以通过下述方法打开.

client.getState().setAuthenticationPreemptive(true);

　　在这种模式时，HttpClient会主动将basic认证应答信息传给服务器，即使在某种情况下服务器可能返回认证失败的应答，这样做主要是为了减少连接的建立。为使每个新建的 HttpState实例都实行抢先认证，可以如下设置系统属性。

setSystemProperty(Authenticator.PREEMPTIVE_PROPERTY, "true");

Httpclient实现的抢先认证遵循rfc2617.
2)代理认证(proxy authentication)
　　除了登录信息需单独存放以外，代理认证与服务器认证几乎一致。用 setProxyCredentials(String realm, Credentials cred)和 getProxyCredentials(String realm)设、取登录信息。
3)认证方案(authentication schemes)
　　Basic
　　是HTTP中规定最早的也是最兼容(?)的方案，遗憾的是也是最不安全的一个方案，因为它以明码传送用户名和密码。它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。
　　Digest
　　是在HTTP1.1中增加的一个方案，虽然不如Basic得到的软件支持多，但还是有广泛的使用。Digest方案比Basic方案安全得多，因它根本就不通过网络传送实际的密码，传送的是利用这个密码对从服务器传来的一个随机数(nonce)的加密串。它要求一个UsernamePasswordCredentials实例，可以指定服务器端的访问空间或采用默认的登录信息。
　　NTLM
　　这是HttpClient支持的最复杂的认证协议。它M$设计的一个私有协议，没有公开的规范说明。一开始由于设计的缺陷，NTLM的安全性比Digest差，后来经过一个ServicePack补丁后，安全性则比较Digest高。NTLM需要一个NTCredentials实例. 注意，由于NTLM不使用访问空间(realms)的概念，HttpClient利用服务器的域名作访问空间的名字。还需要注意，提供给NTCredentials的用户名，不要用域名的前缀 - 如: "adrian" 是正确的，而 "DOMAIN\adrian" 则是错的.
　　NTLM认证的工作机制与basic和digest有很大的差别。这些差别一般由HttpClient处理，但理解这些差别有助避免在使用NTLM认证时出现错误。

从HttpClientAPI的角度来看，NTLM与其它认证方式一样的工作，差别是需要提供'NTCredentials'实例而不是'UsernamePasswordCredentials'(其实，前者只是扩展了后者)
对NTLM认证，访问空间是连接到的机器的域名，这对多域名主机会有一些麻烦.只有HttpClient连接中指定的域名才是认证用的域名。建议将realm设为null以使用默认的设置。
NTLM只是认证了一个连接而不是一请求，所以每当一个新的连接建立就要进行一次认证，且在认证的过程中保持连接是非常重要的。因此，NTLM不能同时用于代理认证和服务器认证，也不能用于http1.0连接或服务器不支持持久连接的情况。

6、重定向

　　由于技术限制，以及为保证2.0发布版API的稳定，HttpClient还不能自动处重定向，但对重定向到同一主机、同一端口且采用同一协议的情况HttpClient可以支持。不能自动的处理的情况，包括需要人工交互的情况，或超出httpclient的能力。
　　当服务器重定向指令指到不同的主机时，HttpClient只是简单地将重定向状态码作为应答状态。所有的300到399（包含两端）的返回码，都表示是重定向应答。常见的有：

301 永久移动. HttpStatus.SC_MOVED_PERMANENTLY
302 临时移动. HttpStatus.SC_MOVED_TEMPORARILY
303 See Other. HttpStatus.SC_SEE_OTHER
307 临时重定向. HttpStatus.SC_TEMPORARY_REDIRECT

　　当收到简单的重定向时，程序应从HttpMethod对象中抽取新的URL并将其下载。另外,限制一下重定向次数是个好的主意，这可以避免递归循环。新的URL可以从头字段Location中抽取，如下：

String redirectLocation;
Header locationHeader = method.getResponseHeader("location");
if (locationHeader != null) {
redirectLocation = locationHeader.getValue();
} else {
// The response is invalid and did not provide the new location for
// the resource. Report an error or possibly handle the response
// like a 404 Not Found error.
}

特殊重定向：

300 多重选择. HttpStatus.SC_MULTIPLE_CHOICES
304 没有改动. HttpStatus.SC_NO T_MODIFIED
305 使用代理. HttpStatus.SC_USE_PROXY

7、字符编码(character encoding)

　　一个HTTP协议的请求或应答的头部(在http协议中，数据包分为两部分，一部分是头部，由一些名值对构成，一部分是主体(body)，是真正传办理的数据（如HTML页面等）），必须以US-ASCII编码，这是因为头部不传数据而只描述被要传输的数据的一些信息，一个例外是cookie，它是数据但是通过头部进行传输的，所以它也要用US-ASCII编码。
　　HTTP数据包的主体部分，可以用任何一种方式进行编码，默认是ISO-8859-1，具体可以用头部字段Content-Type指定。可以利用 addRequestHeader方法，设定编码方式；用 getResponseCharSet取得编码方式。对HTML或XML等类型的文档，它们的本身的Content-Type也可以指定编码方式，主要区分两者的作用范围以得到正确实的解码。
　　URL的编码标准，由RFC1738指定为，只能是由可打印8位/字节的us-ascii字符组成，80-ff不是us-ascii字符，而00-1F是控制字符，这两个区域中用的字符都须加以编码(encoded)。
　　

8、Cookies

　　 HttpClient能自动管理cookie,包括允许服务器设置cookie并在需要的时候自动将cookie返回服务器，它也支持手工设置cookie后发送到服务器端。不幸的是，对如何处理cookie，有几个规范互相冲突：Netscape Cookie 草案, RFC2109, RFC2965，而且还有很大数量的软件商的cookie实现不遵循任何规范. 为了处理这种状况，HttpClient提供了策略驱动的cookie管理方式。HttpClient支持的cookie规范有：

Netscape cookie草案，是最早的cookie规范，基于rfc2109。尽管这个规范与rc2109有较大的差别，这样做可以与一些服务器兼容。
rfc2109，是w3c发布的第一个官方cookie规范。理论上讲，所有的服务器在处理cookie(版本1)时，都要遵循此规范，正因如此，HttpClient将其设为默认的规范。遗憾的是，这个规范太严格了，以致很多服务器不正确的实施了该规范或仍在作用Netscape规范。在这种情况下，应使用兼容规范。
兼容性规范，设计用来兼容尽可能多的服务器，即使它们并没有遵循标准规范。当解析cookie出现问题时，应考虑采用兼容性规范。

　　 RFC2965规范暂时没有被HttpClient支持（在以后的版本为会加上），它定义了cookie版本2，并说明了版本1cookie的不足，RFC2965有意有久取代rfc2109.
　　在HttpClient中，有两种方法来指定cookie规范的使用，

HttpClient client = new HttpClient();
client.getState().setCookiePolicy(CookiePolicy.COMPATIBILITY);
这种方法设置的规范只对当前的HttpState有效，参数可取值CookiePolicy.COMPATIBILITY，CookiePolicy.NETSCAPE_DRAFT或CookiePolicy.RFC2109。
System.setProperty("apache.commons.httpclient.cookiespec", "COMPATIBILITY");
此法指的规范，对以后每个新建立的HttpState对象都有效，参数可取值"COMPATIBILITY","NETSCAPE_DRAFT"或"RFC2109"。
　　常有不能解析cookie的问题，但更换到兼容规范大都能解决。

9、使用HttpClient遇到问题怎么办?

用一个浏览器访问服务器，以确认服务器应答正常
如果在使代理，关掉代理试试
另找一个服务器来试试（如果运行着不同的服务器软件更好）
检查代码是否按教程中讲的思路编写
设置log级别为debug，找出问题出现的原因
打开wiretrace，来追踪客户端与服务器的通信，以确实问题出现在什么地方
用telnet或netcat手工将信息发送到服务器，适合于猜测已经找到了原因而进行试验时
将netcat以监听方式运行，用作服务器以检查httpclient如何处理应答的。
利用最新的httpclient试试，bug可能在最新的版本中修复了
向邮件列表求帮助
向bugzilla报告bug.

10、SSL

　　借助Java Secure Socket Extension (JSSE)，HttpClient全面支持Secure Sockets Layer (SSL)或IETF Transport Layer Security (TLS)协议上的HTTP。JSSE已经jre1.4及以后的版本中，以前的版本则需要手工安装设置，具体过程参见Sun网站或本学习笔记。
　　HttpClient中使用SSL非常简单，参考下面两个例子:

HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("https://www.verisign.com/");
httpclient.executeMethod(httpget);
System.out.println(httpget.getStatusLine().toString());

，如果通过需要授权的代理，则如下：

HttpClient httpclient = new HttpClient();
httpclient.getHostConfiguration().setProxy("myproxyhost", 8080);
httpclient.getState().setProxyCredentials("my-proxy-realm", " myproxyhost",
new UsernamePasswordCredentials("my-proxy-username", "my-proxy-password"));
GetMethod httpget = new GetMethod("https://www.verisign.com/");
httpclient.executeMethod(httpget);
System.out.println(httpget.getStatusLine().toString());

　　在HttpClient中定制SSL的步骤如下：

提供了一个实现了org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory接口的socket factory。这个 socket factory负责打一个到服务器的端口，使用标准的或第三方的SSL函数库，并进行象连接握手等初始化操作。通常情况下，这个初始化操作在端口被创建时自动进行的。
实例化一个org.apache.commons.httpclient.protocol.Protocol对象。创建这个实例时，需要一个合法的协议类型(如https)，一个定制的socket factory，和一个默认的端中号(如https的443端口).
Protocol myhttps = new Protocol("https", new MySSLSocketFactory(), 443);
然后，这个实例可被设置为协议的处理器。
HttpClient httpclient = new HttpClient();
httpclient.getHostConfiguration().setHost("www.whatever.com", 443, myhttps);
GetMethod httpget = new GetMethod("/");
httpclient.executeMethod(httpget);
通过调用Protocol.registerProtocol方法，将此定制的实例，注册为某一特定协议的默认的处理器。由此，可以很方便地定制自己的协议类型(如myhttps)。
Protocol.registerProtocol("myhttps",
new Protocol("https", new MySSLSocketFactory(), 9443));
...
HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("myhttps://www.whatever.com/");
httpclient.executeMethod(httpget);
如果想用自己定制的处理器取代https默认的处理器，只需要将其注册为"https"即可。
Protocol.registerProtocol("https",
new Protocol("https", new MySSLSocketFactory(), 443));
HttpClient httpclient = new HttpClient();
GetMethod httpget = new GetMethod("https://www.whatever.com/");
httpclient.executeMethod(httpget);

　　已知的限制和问题

持续的SSL连接在Sun的低于1.4JVM上不能工作，这是由于JVM的bug造成。
通过代理访问服务器时，非抢先认证（ Non-preemptive authentication）会失败，这是由于HttpClient的设计缺陷造成的，以后的版本中会修改。

　　遇到问题的处理
　　很多问题，特别是在jvm低于1.4时，是由jsse的安装造成的。
　　下面的代码，可作为最终的检测手段。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.Socket; import javax.net.ssl.SSLSocketFactory; public class Test {

public static final String TARGET_HTTPS_SERVER = "www.verisign.com";
public static final int TARGET_HTTPS_PORT = 443;

public static void main(String[] args) throws Exception {

Socket socket = SSLSocketFactory.getDefault().
createSocket(TARGET_HTTPS_SERVER, TARGET_HTTPS_PORT);
try {
Writer out = new OutputStreamWriter(
socket.getOutputStream(), "ISO-8859-1");
out.write("GET / HTTP/1.1\r\n");
out.write("Host: " + TARGET_HTTPS_SERVER + ":" +
TARGET_HTTPS_PORT + "\r\n");
out.write("Agent: SSL-TEST\r\n");
out.write("\r\n");
out.flush();
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream(), "ISO-8859-1"));
String line = null;
while ((line = in.readLine()) != null) {
System.out.println(line);
}
} finally {
socket.close();
}
}
}

1、httpclient的多线程处理

　　使用多线程的主要目的，是为了实现并行的下载。在httpclient运行的过程中，每个http协议的方法，使用一个HttpConnection实例。由于连接是一种有限的资源，每个连接在某一时刻只能供一个线程和方法使用，所以需要确保在需要时正确地分配连接。HttpClient采用了一种类似jdbc连接池的方法来管理连接，这个管理工作由 MultiThreadedHttpConnectionManager完成。

MultiThreadedHttpConnectionManager connectionManager =
new MultiThreadedHttpConnectionManager();
HttpClient client = new HttpClient(connectionManager);

此是，client可以在多个线程中被用来执行多个方法。每次调用HttpClient.executeMethod() 方法，都会去链接管理器申请一个连接实例，申请成功这个链接实例被签出(checkout)，随之在链接使用完后必须归还管理器。管理器支持两个设置：

maxConnectionsPerHost	每个主机的最大并行链接数，默认为2
maxTotalConnections	客户端总并行链接最大数，默认为20

　　管理器重新利用链接时，采取早归还者先重用的方式（least recently used approach）。
　　由于是使用HttpClient的程序而不是HttpClient本身来读取应答包的主体，所以HttpClient无法决定什么时间连接不再使用了，这也就要求在读完应答包的主体后必须手工显式地调用releaseConnection()来释放申请的链接。

MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
HttpClient client = new HttpClient(connectionManager);
...
// 在某个线程中。
GetMethod get = new GetMethod("http://jakarta.apache.org/");
try {
client.executeMethod(get);
// print response to stdout
System.out.println(get.getResponseBodyAsStream());
} finally {
// be sure the connection is released back to the connection
// manager
get.releaseConnection();
}

对每一个HttpClient.executeMethod须有一个method.releaseConnection()与之匹配.

12、HTTP方法

　　HttpClient支持的HTTP方法有8种，下面分述之。

　　1、Options

　　HTTP方法Options用来向服务器发送请求，希望获得针对由请求URL(request url)标志的资源在请求/应答的通信过程可以使用的功能选项。通过这个方法，客户端可以在采取具体行动之前，就可对某一资源决定采取什么动作和/或以及一些必要条件，或者了解服务器提供的功能。这个方法最典型的应用，就是用来获取服务器支持哪些HTTP方法。
　　HttpClient中有一个类叫OptionsMethod，来支持这个HTTP方法，利用这个类的getAllowedMethods方法，就可以很简单地实现上述的典型应用。

OptionsMethod options = new OptionsMethod("http://jakarta.apache.org");
// 执行方法并做相应的异常处理
...
Enumeration allowedMethods = options.getAllowedMethods();
options.releaseConnection();

　　2、Get

　　 HTTP方法GET用来取回请求URI（request-URI）标志的任何信息（以实体(entity)的形式），"get"这个单词本意就是”获取“的意思。如果请求URI指向的一个数据处理过程，那这个过程生成的数据，在应答中以实体的形式被返回，而不是将这个过程的代码的返回。
　　如果HTTP包中含有If-ModifiedSince, If-Unmodified-Since, If-Match, If-None-Match, 或 If-Range等头字段，则GET也就变成了”条件GET“，即只有满足上述字段描述的条件的实体才被取回，这样可以减少一些非必需的网络传输，或者减少为获取某一资源的多次请求（如第一次检查，第二次下载）。（一般的浏览器，都有一个临时目录，用来缓存一些网页信息，当再次浏览某个页面的时候，只下载那些修改过的内容，以加快浏览速度，就是这个道理。至于检查，则常用比GET更好的方法HEAD来实现。）如果HTTP包中含有Range头字段，那么请求URI指定的实体中，只有决定范围条件的那部分才被取回来。（用过多线程下载工具的朋友，可能比较容易理解这一点）
　　这个方法的典型应用，用来从web服务器下载文档。HttpClient定义了一个类叫GetMethod来支持这个方法，用GetMethod类中getResponseBody, getResponseBodyAsStream 或 getResponseBodyAsString函数就可以取到应答包包体中的文档（如HTML页面）信息。这这三个函数中，getResponseBodyAsStream通常是最好的方法，主要是因为它可以避免在处理下载的文档之前缓存所有的下载的数据。

GetMethod get = new GetMethod("http://jakarta.apache.org");
// 执行方法，并处理失败的请求.
...
InputStream in = get.getResponseBodyAsStream();
// 利用输入流来处理信息。
get.releaseConnection();

　　对GetMethod的最常见的不正确的使用，是没有将全部的应答主体的数据读出来。还有，必须注意要手工明确地将链接释放。

　　3、Head

　　HTTP的Head方法，与Get方法完全一致，唯一的差别是服务器不能在应答包中包含主体(message-body)，而且一定不能包含主体。使用这个方法，可以使得客户无需将资源下载回就可就以得到一些关于它的基本信息。这个方法常用来检查超链的可访问性以及资源最近有没有被修改。
　　HTTP的head方法最典型的应用，是获取资源的基本信息。HttpClient定义了HeadMethod类支持这个方法，HeadMethod类与其它*Method类一样，用 getResponseHeaders()取回头部信息，而没有自己的特殊方法。

HeadMethod head = new HeadMethod("http://jakarta.apache.org");
// 执行方法，并处理失败的请求.
...
// 取回应答包的头字段信息.
Header[] headers = head.getResponseHeaders(); // 只取回最后修改日期字段的信息.
String lastModified = head.getResponseHeader("last-modified").getValue();

　　4、Post

　　Post在英文有“派驻”的意思，HTTP方法POST就是要求服务器接受请求包中的实体，并将其作为请求URI的下属资源。从本质上说，这意味着服务器要保存这个实体信息，而且通常由服务器端的程序进行处理。Post方法的设计意图，是要以一种统一的方式实现下列功能：

对已有的资源做评注
将信息发布到BBS、新闻组、邮件列表，或类似的文章组中
将一块数据，提交给数据处理进程
通过追加操作，来扩展一个数据库

　　这些都操作期待着在服务器端产生一定的“副作用”，如修改了数据库等。
　　HttpClient定义PostMethod类以支持该HTTP方法，在httpclient中，使用post方法有两个基本的步骤：为请求包准备数据，然后读取服务器来的应答包的信息。通过调用 setRequestBody()函数，来为请求包提供数据，它可以接收三类参数：输入流、名值对数组或字符串。至于读取应答包需要调用 getResponseBody* 那一系列的方法，与GET方法处理应答包的方法相同。
　　常见问题是，没有将全部应答读取（无论它对程序是否有用），或没有释放链接资源。

Gavin.lee 2010-01-14 23:08 发表评论

java List 分页应用（二）

Gavin.lee — Sat, 09 Jan 2010 18:22:00 GMT

摘要: 应用类： package com.Gavin.tools.util; import java.util.*; /** *//** * 为List分页 * 样式比较简单，适合WAP使用，直接输出页码到页面 */ public class PagerUtil {... 阅读全文

Gavin.lee 2010-01-10 02:22 发表评论

java List 分页应用（一）

Gavin.lee — Sat, 09 Jan 2010 06:35:00 GMT

摘要: 应用类： package com.Gavin.tools.util; /** *//** * List分页 * 实现：利用List的获取子List方法，实现对List的分页 * @author 显武 * @date 2010-1-8... 阅读全文

Gavin.lee 2010-01-09 14:35 发表评论

java 有效的防止SQL注入

Gavin.lee — Thu, 31 Dec 2009 16:38:00 GMT

归纳一下，主要有以下几点：
1.永远不要信任用户的输入。对用户的输入进行校验，可以通过正则表达式，或限制长度；对单引号和双"-"进行转换等。
2.永远不要使用动态拼装sql，可以使用参数化的sql或者直接使用存储过程进行数据查询存取。
3.永远不要使用管理员权限的数据库连接，为每个应用使用单独的权限有限的数据库连接。
4.不要把机密信息直接存放，加密或者hash掉密码和敏感的信息。
5.应用的异常信息应该给出尽可能少的提示，最好使用自定义的错误信息对原始错误信息进行包装。

参考：
http://msdn.microsoft.com/en-us/magazine/cc163917.aspx
http://www.unixwiz.net/techtips/sql-injection.html
http://www.nextgenss.com/papers/more_advanced_sql_injection.pdf
http://www.securiteam.com/securityreviews/5DP0N1P76E.html
http://xkcd.com/327/
http://ferruh.mavituna.com/makale/sql-injection-cheatsheet/

http://bbs.xiakexing.com/cgi-bin/topic.cgi?forum=34&topic=18&show=0
http://www.cnblogs.com/iloveu/archive/2009/03/17/1414145.html
http://dang.javaeye.com/blog/338367

Gavin.lee 2010-01-01 00:38 发表评论

java clone

Gavin.lee — Wed, 30 Dec 2009 04:27:00 GMT

http://lavasoft.blog.51cto.com/62575/43480

Gavin.lee 2009-12-30 12:27 发表评论

Java 序列化与反序列化

Gavin.lee — Mon, 28 Dec 2009 16:39:00 GMT

http://blog.csdn.net/longronglin/archive/2009/02/09/3871682.aspx

Gavin.lee 2009-12-29 00:39 发表评论

Junit 单元测试

Gavin.lee — Mon, 28 Dec 2009 16:38:00 GMT

http://blog.csdn.net/longronglin/archive/2008/04/15/2295237.aspx

Gavin.lee 2009-12-29 00:38 发表评论

压缩 XML 文件以便有效地传输

Gavin.lee — Mon, 28 Dec 2009 13:32:00 GMT

http://www.ibm.com/developerworks/cn/xml/x-tipcomp.html

Gavin.lee 2009-12-28 21:32 发表评论

Java ClassLoader 类加载的学习

Gavin.lee — Sun, 27 Dec 2009 11:51:00 GMT

待续

Gavin.lee 2009-12-27 19:51 发表评论

使用 XStream 在 JavaBean 与 XML/JSON 之间相互转换（摘）

Gavin.lee — Sun, 27 Dec 2009 11:40:00 GMT

http://www.blogjava.net/Unmi/archive/2009/08/11/290710.html

Gavin.lee 2009-12-27 19:40 发表评论

利用java构建http服务器（摘）

Gavin.lee — Sat, 26 Dec 2009 16:12:00 GMT

摘要: web服务器大家都会用，可是它的实现原理是到底如何呢，其实只要读一下http协议，大家基本也能开发出一个简单的web服务器出来了。 web请求分为如下几步 1. 浏览器向服务建立TCP/IP连接，Java中通过java.net.Socket实现 2. Web浏览器向Web服务器发送请求命令。通过Socket的输出流向服务器写如下信息： GET /uri HTTP/1.1，很显... 阅读全文

Gavin.lee 2009-12-27 00:12 发表评论

java 实现URL重写

Gavin.lee — Fri, 25 Dec 2009 17:56:00 GMT

java 实现URL重写

Gavin.lee 2009-12-26 01:56 发表评论

HttpsURLConnection 安全传输（HTTPS--Secure Hypertext Transfer Protocol-安全超文本传输协议）

Gavin.lee — Fri, 25 Dec 2009 16:56:00 GMT

摘要: HttpsURLConnection 扩展 HttpURLConnection，支持各种特定于 https 功能。此类使用 HostnameVerifier 和 SSLSocketFactory。为这两个类都定义了默认实现。但是，可以根据每个类（静态的）或每个实例来替换该实现。所有新 HttpsURLConnection 实例在创建时将被分配“默认的”静态值，通过在连接前调... 阅读全文

Gavin.lee 2009-12-26 00:56 发表评论

Map 遍历

Gavin.lee — Tue, 22 Dec 2009 01:21:00 GMT

package com.Gavin.tools.util;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
* @author Gavin.lee
* @date 2009-05-04 11:45am
* @param
* @param
*/
public class MapUtil<K, V> {

    public void filter1(Map map) {
        Iterator it = map.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry me = (Map.Entry) it.next();
            System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
        }
        System.out.println("************************************filter1");
    }

    public void filter2(Map map) {
        Hashtable<String, String> ht = new Hashtable<String, String>();
        ht.put("Gavin", "Kathy");
        ht.put("杨过", "小龙女");

        for (Map.Entry<String, String> me : ht.entrySet()) {
            System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
        }
        System.out.println("************************************filter2");
    }

    public void filter3(Map map) {
        Iterator it = map.keySet().iterator();
        while (it.hasNext()) {
            String key;
            key = (String) it.next();
            System.out.println("key:" + key + ",value:" + map.get(key));
        }
        System.out.println("************************************filter3");
    }

    public void filter4(Map map) {
        for (Object o : map.keySet()) {
            System.out.println("key:" + o + ",value:" + map.get(o));
        }
        System.out.println("************************************filter4");
    }

    /**
     * 获得Map中特定value的key值
     * @param map
     * @param value
     * @return
     */
    public K getMapKeyFromValue(Map<K, V> map, V value) {
        Set set = map.keySet();
        K key = null;
        Iterator it = set.iterator();
        while (it.hasNext()) {
            key = (K) it.next();
            if (value.equals(map.get(key))) {
                return key;
            }
        }
        return null;
    }

}

Gavin.lee 2009-12-22 09:21 发表评论

Apache Common HttpClient的使用

Gavin.lee — Mon, 14 Dec 2009 14:38:00 GMT

摘要: HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已... 阅读全文

Gavin.lee 2009-12-14 22:38 发表评论

Apache commons 各种组件（摘）

Gavin.lee — Mon, 14 Dec 2009 14:36:00 GMT

原文：http://www.blogjava.net/fatbear/archive/2007/05/23/119346.html
Apache Commons 是一个非常有用的工具包，解决各种实际的通用问题，你会发现它们正是你冥思苦想所需要

的东西。它们不是绝世武功，但确是个随手可用的擒拿手，Commons一出，问题手到擒来。

下面是一个全面的简述表：

组件	说明
BeanUtils	Commons-BeanUtils 提供对 Java 反射和自省API的包装
Betwixt	Betwixt提供将 JavaBean 映射至 XML 文档，以及相反映射的服务.
Chain	Chain 提供实现组织复杂的处理流程的“责任链模式”.
CLI	CLI 提供针对命令行参数，选项，选项组，强制选项等的简单API.
Codec	Codec 包含一些通用的编码解码算法。包括一些语音编码器， Hex, Base64, 以及URL encoder.
Collections	Commons-Collections 提供一个类包来扩展和增加标准的 Java Collection框架
Configuration	Commons-Configuration 工具对各种各式的配置和参考文件提供读取帮助.
Daemon	一种 unix-daemon-like java 代码的替代机制
DBCP	Commons-DBCP 提供数据库连接池服务
DbUtils	DbUtils 是一个 JDBC helper 类库，完成数据库任务的简单的资源清除代码.
Digester	Commons-Digester 是一个 XML-Java对象的映射工具，用于解析 XML配置文件.
Discovery	Commons-Discovery 提供工具来定位资源 (包括类) ，通过使用各种模式来映射服务/引用名称和资源名称.
EL	Commons-EL 提供在JSP2.0规范中定义的EL表达式的解释器.
FileUpload	FileUpload 使得在你可以在应用和Servlet中容易的加入强大和高性能的文件上传能力.
HttpClient	Commons-HttpClient 提供了可以工作于HTTP协议客户端的一个框架.
IO	IO 是一个 I/O 工具集.
Jelly	Jelly是一个基于 XML 的脚本和处理引擎。 Jelly 借鉴了 JSP 定指标签，Velocity, Cocoon和Xdoclet中的脚本引擎的许多优点。Jelly 可以用在命令行， Ant 或者 Servlet之中.
Jexl	Jexl是一个表达式语言，通过借鉴来自于Velocity的经验扩展了JSTL定义的表达式语言.
JXPath	Commons-JXPath 提供了使用Xpath语法操纵符合Java类命名规范的 JavaBeans的工具。也支持 maps, DOM 和其他对象模型.
Lang	Commons-Lang 提供了许多许多通用的工具类集，提供了一些java.lang中类的扩展功能.
Latka	Commons-Latka 是一个HTTP 功能测试包，用于自动化的QA,验收和衰减测试.
Launcher	Launcher 组件是一个交叉平台的Java 应用载入器。 Commons-launcher 消除了需要批处理或者Shell脚本来载入Java 类。.原始的 Java 类来自于Jakarta Tomcat 4.0 项目.
Logging	Commons-Logging 是一个各种 logging API实现的包裹类.
Math	Math 是一个轻量的，自包含的数学和统计组件，解决了许多非常通用但没有及时出现在Java标准语言中的实践问题.
Modeler	Commons-Modeler 提供了建模兼容JMX规范的 Mbean的机制.
Net	Net 是一个网络工具集，基于 NetComponents 代码，包括 FTP 客户端等等.
Pool	Commons-Pool 提供了通用对象池接口，一个用于创建模块化对象池的工具包，以及通常的对象池实现.
Primitives	Commons-Primitives提供了一个更小，更快和更易使用的对Java基本类型的支持。当前主要是针对基本类型的 collection.
Validator	The commons-validator提供了一个简单的，可扩展的框架来在一个XML文件中定义校验器 (校验方法)和校验规则。支持校验规则的和错误消息的国际化.

详细信息位于：http://jakarta.apache.org/commons/index.html

以及Jakarta Commons:巧用类和组件

Gavin.lee 2009-12-14 22:36 发表评论

Java路径问题最终解决方案（可定位所有资源的相对路径寻址）

Gavin.lee — Sat, 12 Dec 2009 15:18:00 GMT

摘要: 摘自：http://www.matrix.org.cn/thread.shtml?topicId=6d0bbeed-9157-11db-ab77-2bbe780ebfbf&forumId=19 Java的路径问题，非常难搞。最近的工作涉及到创建和读取文件的工作，这里我就给大家彻底得解决Java路径问题。我编写了一个方法，比ClassLoader.getResource(String... 阅读全文

Gavin.lee 2009-12-12 23:18 发表评论

十四种Java开发工具 ---了解

Gavin.lee — Tue, 01 Dec 2009 14:54:00 GMT

原文：http://www.yesky.com/471/1825471.shtml

1、JDK （Java Development Kit）
2、Java Workshop
3、NetBeans 与Sun Java Studio 5
4、Borland 的JBuilder
5、Oracle 的JDeveloper
6、IBM的Visual Age for Java
7、BEA 的 WebLogic Workshop
8、WebGain 的Visual Cafe for Java
9、Macromedia的JRUN
10、JCreator
11、Microsoft VJ++
12、Eclipse
13、Ant Another Neat Tool(Ant)
14、IntelliJ

Gavin.lee 2009-12-01 22:54 发表评论

Java:线程堆---给自己系统中的线程命名，然后通过dump察看你的系统

Gavin.lee — Mon, 30 Nov 2009 15:41:00 GMT

集成开发环境（IDE）能给图形界面应用程序提供一个很好的调试工具，但是它却不能调试一个多线程的Java服务器程序。　　　
　　
　　幸运的是，有几种工具，例如logging应用程序接口（API）或者Java Debugger可以用来调试Java服务器程序。开发者还能使用一个系统的线程堆在任何时候观察系统的状态。　　
　　
　　运行服务器，然后按[ctrl] [/]，会运行一个系统线程堆，这样将输出当前运行的所有线程，例如：　　
　　　　
　　^\Full thread dump: 　　
　　
　　Thread-1" prio=5 tid=0x87fe0 nid=0x800013b8 waiting on monitor [0..0xbfffe9f8] 　　
　　
　　"Thread-0" prio=5 tid=0xafde0 nid=0x72a00 runnable [0x173f000..0x173fb48]
　　
　　at java.net.PlainSocketImpl.socketAccept(Native Method)
　　
　　at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:421)
　　
　　at java.net.ServerSocket.implAccept(ServerSocket.java:243)
　　
　　at java.net.ServerSocket.accept(ServerSocket.java:222)
　　
　　at com.generationjava.net.PortListener.run(PortListener.java:38)
　　
　　at java.lang.Thread.run(Thread.java:496) 　　　
　　
　　"Signal Dispatcher" daemon prio=10 tid=0xa5f80 nid=0x52af0 waiting on monitor [0..0] 　　　　
　　
　　"Finalizer" daemon prio=8 tid=0xa46c0 nid=0x4d930 waiting on monitor [0x10a8000..0x10a8b48]
　　
　　at java.lang.Object.wait(Native Method)
　　
　　at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:108)
　　
　　at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:123)
　　
　　at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:162) 　　　　
　　
　　"Reference Handler" daemon prio=10 tid=0xa3b70 nid=0x4cca0 waiting on monitor [0x1027000..0x1027b48]
　　
　　at java.lang.Object.wait(Native Method)
　　
　　at java.lang.Object.wait(Object.java:420)
　　
　　at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:110) 　　　　
　　
　　"VM Thread" prio=5 tid=0xa2de0 nid=0x4ca20 runnable 　　
　　
　　"VM Periodic Task Thread" prio=10 tid=0xa56b0 nid=0x52890 waiting on monitor 　　
　　
　　后面的四个线程是标准线程，而其他的则跟运行的服务器程序有关。这两个线程被命名为Thread-1和Thread-0，假如用Thread th = new Thread(runnable,"Server")代替Thread th = new Thread(runnable)去创建进程，你就可以命名自己要创建的线程。　　
　　
　　另外，假如你调用java.lang.Thread的setName(String)方法，你也能命名你的线程，并且可以很轻易从线程堆的输出中发现原来的Thread-0是服务器程序。　　
　　
　　"Server" prio=5 tid=0xafde0 nid=0x72a00 runnable [0x173f000..0x173fb48] 　　
　　
　　而原来的Thread-1线程现在变成了Thread-0。　　　　
　　
　　通过命名线程和取得线程堆，开发者就能看到Java虚拟机（JVM）的内部状态。假如想得到更多信息的话，你就得去研究Java Debugger了。
资料来源:学网(www.xue5.com),原文地址:http://www.xue5.com/itedu/200702/91976.html

Gavin.lee 2009-11-30 23:41 发表评论

Java代码触发生成ThreadDump

Gavin.lee — Mon, 30 Nov 2009 15:13:00 GMT

ThreadDump对于JVM诊断和调优是个好东西. 以前, 我们生成ThreadDump, 一般都需要另外连到服务器上的进程管理器才行, 不管是Ctrl+Break还是kill –3, 比较不方便. 有时候, 也许想远程直接生成并检查一下服务器的ThreadDump, 这个怎么办呢? 幸好我们有以下代码可以做到:

package yixun.wap.tools;

import java.util.Map;

/**
* 使用 Java 远程代码生成 ThreadDump. 适用于 JDK 1.5+.
* 参考: {@link ThreadgetStackTrace()}
* {@link ThrowablegetStackTrace()}
* @see StackTraceElement
*/
public class ThreadDumpBuilder {
    /**
     * 生成并返回 Thread Dump.
     * @return
     */
    public String build() {
        StringBuilder output = new StringBuilder(1000);
        for (Map.Entry stackTrace : Thread.getAllStackTraces().entrySet()) {
            appendThreadStackTrace(output, (Thread) stackTrace.getKey(),
                    (StackTraceElement[]) stackTrace.getValue());
        }
        return output.toString();
    }

    /**
     * 处理并输出堆栈信息.
     * @param output
     *            输出内容
     * @param thread
     *            线程
     * @param stack
     *            线程堆栈
     */
    private void appendThreadStackTrace(StringBuilder output, Thread thread,
            StackTraceElement[] stack) {
        // 忽略当前线程的堆栈信息
        if (thread.equals(Thread.currentThread())) {
            return;
        }

        output.append(thread).append("
");
        for (StackTraceElement element : stack) {
            output.append("\t").append(element).append("\n
");
        }
    }

}

然后在一个JSP里或者Servlet中任意调用即可:

<%=new ThreadDumpBuilder().build() %>

===== END OF THREAD DUMP ===============

参考资料:

1. Atlassian Confluence 3.0 管理控制台

2. JDK的DEMO

jdk1.5.0\demo\management\FullThreadDump

原文：http://ajava.org/course/java/13843.html

java.lang

类 StackTraceElement 方法：

 boolean  equals(Object obj)

          如果指定的对象是另一个 StackTraceElement 实例，并且该对象表示的执行点与该实例的相同，则返回 ture。

 String  getClassName()

          返回类的完全限定名，该类包含由该堆栈跟踪元素所表示的执行点。

 String  getFileName()

          返回源文件名，该文件包含由该堆栈跟踪元素所表示的执行点。

 int  getLineNumber()

          返回源行的行号，该行包含由该堆栈该跟踪元素所表示的执行点。

 String  getMethodName()

          返回方法名，此方法包含由该堆栈跟踪元素所表示的执行点。

 int  hashCode()

          返回此堆栈跟踪元素的哈希码值。

 boolean  isNativeMethod()

          如果包含由该堆栈跟踪元素所表示的执行点的方法是一个本机方法，则返回 true。

 String  toString()

          返回表示该堆栈跟踪元素的字符串。

Gavin.lee 2009-11-30 23:13 发表评论

JAVA线程dump的分析 --- jstack pid

Gavin.lee — Fri, 27 Nov 2009 14:02:00 GMT

Java 的线程

线程是指能独立于程序的其它部分运行的执行单元。 JAVA语言能够很好的实现多线程的程序。我们在调试程序，或者在开发后期需要做性能调优的时候，往往也需要了解当前程序正在运行的线程的状态，正在执行的操作，从而分析系统可能存在的问题。

在阅读本文之间，应对 Java线程的编程原理，同步机制有一定了解 .

产生 JAVA线程 dump

JAVA 的线程 DUMP，就象当前 JAVA进程的一个快照，打印出所有线程的状态和调用堆栈，以及 Monitor的状态。在不同的操作系统下，产生线程 DUMP的方式是不同的。

·在 windows环境中，

在启动程序的控制台里敲： Ctrl - Break，线程的 dump会产生在标准输出中（缺省标准输出就是控制台，如果对输出进行了重定向，则要查看输出文件）。

在 unix， linux和 MacOS 环境中，

在控制台中敲： Ctrl-\，或者，
用 “kill -3 ” ，或者 “kill – QUIT ”。 Pid是用所关注的 JAVA进程号，您可以用 “ps -ef | grep java” 找到，或者使用 JDK 5.0中的 “jps -v” 命令获得。

在各个操作系统平台，都可以用 JDK 5.0工具包中的 jstack

这里要注意的是：

1. 不同的 JAVA虚机的线程 DUMP的创建方法和文件格式是不一样的，不同的 JVM版本， dump信息也有差别。本文中，只以 SUN的 hotspot JVM 5.0_06 为例。

2. 在实际运行中，往往一次 dump的信息，还不足以确认问题。建议产生三次 dump信息，如果每次 dump都指向同一个问题，我们才确定问题的典型性。

线程分析：

1.     JVM 线程
在线程中，有一些 JVM内部的后台线程，来执行譬如垃圾回收，或者低内存的检测等等任务，这些线程往往在 JVM初始化的时候就存在，如下所示：

        "Low Memory Detector" daemon prio=10 tid=0x081465f8 nid=0x7 runnable [0x00000000..0x00000000]

        "CompilerThread0" daemon prio=10 tid=0x08143c58 nid=0x6 waiting on condition [0x00000000..0xfb5fd798]

        "Signal Dispatcher" daemon prio=10 tid=0x08142f08 nid=0x5 waiting on condition [0x00000000..0x00000000]

        "Finalizer" daemon prio=10 tid=0x08137ca0 nid=0x4 in Object.wait() [0xfbeed000..0xfbeeddb8]

        at java.lang.Object.wait(Native Method)

        - waiting on <0xef600848> (a java.lang.ref.ReferenceQueue$Lock)

        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:116)

        - locked <0xef600848> (a java.lang.ref.ReferenceQueue$Lock)

        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:132)

        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:159)

        "Reference Handler" daemon prio=10 tid=0x081370f0 nid=0x3 in Object.wait() [0xfbf4a000..0xfbf4aa38]

        at java.lang.Object.wait(Native Method)

        - waiting on <0xef600758> (a java.lang.ref.Reference$Lock)

        at java.lang.Object.wait(Object.java:474)

        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:116)

        - locked <0xef600758> (a java.lang.ref.Reference$Lock)

        "VM Thread" prio=10 tid=0x08134878 nid=0x2 runnable

        "VM Periodic Task Thread" prio=10 tid=0x08147768 nid=0x8 waiting on condition



                我们更多的是要观察用户级别的线程，如下所示：

        "Thread-1" prio=10 tid=0x08223860 nid=0xa waiting on condition [0xef47a000..0xef47ac38]

        at java.lang.Thread.sleep(Native Method)

        at testthread.MySleepingThread.method2(MySleepingThread.java:53)

        - locked <0xef63d600> (a testthread.MySleepingThread)

        at testthread.MySleepingThread.run(MySleepingThread.java:35)

        at java.lang.Thread.run(Thread.java:595)

        我们能看到：

线程的状态： waiting on condition

线程的调用栈

线程的当前锁住的资源： <0xef63d600>

        这些信息对我们随后的分析都有用处。

2.     线程的状态分析

正如我们刚看到的那样，线程的状态是一个重要的指标，它会显示在线程 Stacktrace的头一行结尾的地方。那么线程常见的有哪些状态呢？线程在什么样的情况下会进入这种状态呢？我们能从中发现什么线索？< /span>

1.1 Runnable

该状态表示线程具备所有运行条件，在运行队列中准备操作系统的调度，或者正在运行。

1.2 Wait on condition

该状态出现在线程等待某个条件的发生。具体是什么原因，可以结合 stacktrace来分析。最常见的情况是线程在等待网络的读写，比如当网络数据没有准备好读时，线程处于这种等待状态，而一旦有数据准备好读之后，线程会重新激活，读取并处理数据。在 Java引入 NewIO之前，对于每个网络连接，都有一个对应的线程来处理网络的读写操作，即使没有可读写的数据，线程仍然阻塞在读写操作上，这样有可能造成资源浪费，而且给操作系统的线程调度也带来压力。在 NewIO里采用了新的机制，编写的服务器程序的性能和可扩展性都得到提高。

如果发现有大量的线程都在处在 Wait on condition，从线程 stack看，正等待网络读写，这可能是一个网络瓶颈的征兆。因为网络阻塞导致线程无法执行。一种情况是网络非常忙，几乎消耗了所有的带宽，仍然有大量数据等待网络读写；另一种情况也可能是网络空闲，但由于路由等问题，导致包无法正常的到达。所以要结合系统的一些性能观察工具来综合分析，比如 netstat统计单位时间的发送包的数目，如果很明显超过了所在网络带宽的限制 ; 观察 cpu的利用率，如果系统态的 CPU时间，相对于用户态的 CPU时间比例较高；如果程序运行在 Solaris 10平台上，可以用 dtrace工具看系统调用的情况，如果观察到 read/write的系统调用的次数或者运行时间遥遥领先；这些都指向由于网络带宽所限导致的网络瓶颈。

另外一种出现 Wait on condition的常见情况是该线程在 sleep，等待 sleep的时间到了时候，将被唤醒。

1.3 Waiting for monitor entry 和 in Object.wait()

在多线程的 JAVA程序中，实现线程之间的同步，就要说说 Monitor。 Monitor是 Java中用以实现线程之间的互斥与协作的主要手段，它可以看成是对象或者 Class的锁。每一个对象都有，也仅有一个 monitor。下面这个图，描述了线程和 Monitor之间关系，以及线程的状态转换图：

从图中可以看出，每个 Monitor在某个时刻，只能被一个线程拥有，该线程就是 “Active Thread”，而其它线程都是 “Waiting Thread”，分别在两个队列 “ Entry Set”和 “Wait Set”里面等候。在 “Entry Set”中等待的线程状态是 “Waiting for monitor entry”，而在 “Wait Set”中等待的线程状态是 “in Object.wait()”。

先看 “Entry Set”里面的线程。我们称被 synchronized保护起来的代码段为临界区。当一个线程申请进入临界区时，它就进入了 “Entry Set”队列。对应的 code就像：

synchronized(obj) {
.........

}

这时有两种可能性：

·          该 monitor不被其它线程拥有， Entry Set里面也没有其它等待线程。本线程即成为相应类或者对象的 Monitor的 Owner，执行临界区的代码

·          该 monitor被其它线程拥有，本线程在 Entry Set队列中等待。

在第一种情况下，线程将处于 “Runnable”的状态，而第二种情况下，线程 DUMP会显示处于 “waiting for monitor entry”。如下所示：

"Thread-0" prio=10 tid=0x08222eb0 nid=0x9 waiting for monitor entry [0xf927b000..0xf927bdb8]

at testthread.WaitThread.run(WaitThread.java:39)

- waiting to lock <0xef63bf08> (a java.lang.Object)

- locked <0xef63beb8> (a java.util.ArrayList)

at java.lang.Thread.run(Thread.java:595)

临界区的设置，是为了保证其内部的代码执行的原子性和完整性。但是因为临界区在任何时间只允许线程串行通过，这和我们多线程的程序的初衷是相反的。如果在多线程的程序中，大量使用 synchronized，或者不适当的使用了它，会造成大量线程在临界区的入口等待，造成系统的性能大幅下降。如果在线程 DUMP中发现了这个情况，应该审查源码，改进程序。

现在我们再来看现在线程为什么会进入 “Wait Set”。当线程获得了 Monitor，进入了临界区之后，如果发现线程继续运行的条件没有满足，它则调用对象（一般就是被 synchronized 的对象）的 wait() 方法，放弃了 Monitor，进入 “Wait Set”队列。只有当别的线程在该对象上调用了 notify() 或者 notifyAll() ， “ Wait Set”队列中线程才得到机会去竞争，但是只有一个线程获得对象的 Monitor，恢复到运行态。在 “Wait Set”中的线程， DUMP中表现为： in Object.wait()，类似于：

        "Thread-1" prio=10 tid=0x08223250 nid=0xa in Object.wait() [0xef47a000..0xef47aa38]

        at java.lang.Object.wait(Native Method)

        - waiting on <0xef63beb8> (a java.util.ArrayList)

        at java.lang.Object.wait(Object.java:474)

        at testthread.MyWaitThread.run(MyWaitThread.java:40)

        - locked <0xef63beb8> (a java.util.ArrayList)

        at java.lang.Thread.run(Thread.java:595)

仔细观察上面的 DUMP信息，你会发现它有以下两行：

- locked <0xef63beb8> (a java.util.ArrayList)

- waiting on <0xef63beb8> (a java.util.ArrayList)

这里需要解释一下，为什么先 lock了这个对象，然后又 waiting on同一个对象呢？让我们看看这个线程对应的代码：

        synchronized(obj) {
               .........
               obj.wait();
               .........
        }

线程的执行中，先用 synchronized 获得了这个对象的 Monitor（对应于 locked <0xef63beb8> ）。当执行到 obj.wait(), 线程即放弃了 Monitor的所有权，进入 “wait set”队列（对应于 waiting on <0xef63beb8> ）。

往往在你的程序中，会出现多个类似的线程，他们都有相似的 DUMP信息。这也可能是正常的。比如，在程序中，有多个服务线程，设计成从一个队列里面读取请求数据。这个队列就是 lock以及 waiting on的对象。当队列为空的时候，这些线程都会在这个队列上等待，直到队列有了数据，这些线程被 Notify，当然只有一个线程获得了 lock，继续执行，而其它线程继续等待。

3.     JDK 5.0 的 lock

上面我们提到如果 synchronized和 monitor机制运用不当，可能会造成多线程程序的性能问题。在 JDK 5.0中，引入了 Lock机制，从而使开发者能更灵活的开发高性能的并发多线程程序，可以替代以往 JDK中的 synchronized和 Monitor的机制。但是，要注意的是，因为 Lock类只是一个普通类， JVM无从得知 Lock对象的占用情况，所以在线程 DUMP中，也不会包含关于 Lock的信息，关于死锁等问题，就不如用 synchronized的编程方式容易识别。

案例分析

1. 死锁

在多线程程序的编写中，如果不适当的运用同步机制，则有可能造成程序的死锁，经常表现为程序的停顿，或者不再响应用户的请求。

比如在下面这个示例中，是个较为典型的死锁情况：

"Thread-1" prio=5 tid=0x00acc490 nid=0xe50 waiting for monitor entry [0x02d3f000

..0x02d3fd68]

at deadlockthreads.TestThread.run(TestThread.java:31)

- waiting to lock <0x22c19f18> (a java.lang.Object)

- locked <0x22c19f20> (a java.lang.Object)

"Thread-0" prio=5 tid=0x00accdb0 nid=0xdec waiting for monitor entry [0x02cff000

..0x02cff9e8]

at deadlockthreads.TestThread.run(TestThread.java:31)

- waiting to lock <0x22c19f20> (a java.lang.Object)

- locked <0x22c19f18> (a java.lang.Object)

在 JAVA 5中加强了对死锁的检测。线程 Dump中可以直接报告出 Java级别的死锁，如下所示：

Found one Java-level deadlock:

=============================

"Thread-1":

waiting to lock monitor 0x0003f334 (object 0x22c19f18, a java.lang.Object),

which is held by "Thread-0"

"Thread-0":

waiting to lock monitor 0x0003f314 (object 0x22c19f20, a java.lang.Object),

which is held by "Thread-1"

2. 热锁

热锁，也往往是导致系统性能瓶颈的主要因素。其表现特征为，由于多个线程对临界区，或者锁的竞争，可能出现：& amp; lt; /span>

频繁的线程的上下文切换：从操作系统对线程的调度来看，当线程在等待资源而阻塞的时候，操作系统会将之切换出来，放到等待的队列，当线程获得资源之后，调度算法会将这个线程切换进去，放到执行队列中。& amp; amp; amp; lt; /li>

大量的系统调用：因为线程的上下文切换，以及热锁的竞争，或者临界区的频繁的进出，都可能导致大量的系统调用。M t < /span>

大部分 CPU开销用在 “系统态 ”：线程上下文切换，和系统调用，都会导致 CPU在 “系统态 ”运行，换而言之，虽然系统很忙碌，但是 CPU用在 “用户态 ”的比例较小，应用程序得不到充分的 CPU资源。

随着 CPU数目的增多，系统的性能反而下降。因为 CPU数目多，同时运行的线程就越多，可能就会造成更频繁的线程上下文切换和系统态的 CPU开销，从而导致更糟糕的性能。

上面的描述，都是一个 scalability（可扩展性）很差的系统的表现。从整体的性能指标看，由于线程热锁的存在，程序的响应时间会变长，吞吐量会降低。< /span>

那么，怎么去了解 “热锁 ”出现在什么地方呢？一个重要的方法还是结合操作系统的各种工具观察系统资源使用状况，以及收集 Java线程的 DUMP信息，看线程都阻塞在什么方法上，了解原因，才能找到对应的解决方法。

我们曾经遇到过这样的例子，程序运行时，出现了以上指出的各种现象，通过观察操作系统的资源使用统计信息，以及线程 DUMP信息，确定了程序中热锁的存在，并发现大多数的线程状态都是 Waiting for monitor entry或者 Wait on monitor，且是阻塞在压缩和解压缩的方法上。后来采用第三方的压缩包 javalib替代 JDK自带的压缩包后，系统的性能提高了几倍。

总结

本文就介绍了 Java线程 DUMP的基本知识和分析的基本方法，并且解释了如何利用线程的 DUMP信息，以及结合操作系统的各种资源使用情况，分析程序的性能问题，从而达到改进程序，提高性能的目的。

Gavin.lee 2009-11-27 22:02 发表评论

判断字符串是否是数字串

Gavin.lee — Mon, 23 Nov 2009 03:33:00 GMT

在我们日常开发过程中，为了安全考虑，会用到对传值进行限制，下面这段是先人用的4个方法，都是可行了，现贴如下

//    1.使用Character.isDigit(char)判断
    public boolean isNumeric(String str) {
        if (str == null || str.equals("")) {
            return false;
        }
        for (int i = str.length(); --i >= 0;) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }


//    2.使用类型转换判断
    public boolean isNumeric2 (String str) {
        try {
            Integer.valueOf(str);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

//    3.使用正则表达式判断
    public boolean isNumeric3(String str) {
        return str.matches("[0-9]+");
        //    +表示1个或多个（如"3"或"225"），*表示0个或多个（[0-9]*）（如""或"1"或"22"），?表示0个或1个([0-9]?)(如""或"7")
    }

//    4.使用Pattern类和Matcher
    public boolean isNumeric4(String str) {
        Pattern pattern = Pattern.compile("[0-9]+");
        Matcher matcher = pattern.matcher((CharSequence) str);
        return matcher.matches();
    }

Gavin.lee 2009-11-23 11:33 发表评论

BigDecimal --判断两数相除是否为无穷

Gavin.lee — Wed, 21 Oct 2009 08:27:00 GMT

摘要: import java.math.BigDecimal; public class Test { public static void main(String args[]) { &n... 阅读全文

Gavin.lee 2009-10-21 16:27 发表评论

Math 取整函数

Gavin.lee — Sat, 17 Oct 2009 05:42:00 GMT

/**
* 取整函数
*/
public class QuZheng {
    public static void main(String[] args) {
        //四舍五入
        System.out.println(Math.round(3.40d));   //3
        System.out.println(Math.round(3.60d));   //4
        //上取整
        System.out.println(Math.ceil(3.4));   //4.0
        //下取整
        System.out.println(Math.floor(3.40));   //3.0

        System.out.println((int)3.45);    //3
    }
}

Gavin.lee 2009-10-17 13:42 发表评论

DecimalFormat 数据格式化类的使用小结

Gavin.lee — Tue, 25 Aug 2009 16:06:00 GMT

api：DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。

import java.text.DecimalFormat;
import java.util.Random;
import java.util.Locale;
public class TestNumberFormat {
    public static void main(String[] args) {
        double pi = 3.1415927;// 圆周率

        // 取一位整数
        System.out.println(new DecimalFormat("0").format(pi)); // 3
        // 取一位整数和两位小数
        System.out.println(new DecimalFormat("0.00").format(pi)); // 3.14
        // 取两位整数和三位小数，整数不足部分以0填补。
        System.out.println(new DecimalFormat("00.000").format(pi)); // 03.142
        // 取所有整数部分
        System.out.println(new DecimalFormat("#").format(pi)); // 3
        // 以百分比方式计数，并取两位小数
        System.out.println(new DecimalFormat("#.##%").format(pi)); // 314.16%

        long c = 299792458;// 光速
        // 显示为科学计数法，并取五位小数
        System.out.println(new DecimalFormat("#.#####E0").format(c)); // 2.99792E8
        // 显示为两位整数的科学计数法，并取四位小数
        System.out.println(new DecimalFormat("00.####E0").format(c)); // 29.9792E7
        // 每三位以逗号进行分隔。
        System.out.println(new DecimalFormat(",###").format(c)); // 299,792,458
        // 将格式嵌入文本
        System.out.println(new DecimalFormat("光速大小为每秒,###米。").format(c));        //光速大小为每秒299,792,458米。

        //直接截取
        System.out.println(Math.floor(24.335*100)/100);            //24.33

        System.out.println((int)Math.floor(23.45));        //截取整数    23
        System.out.println((int)Math.ceil(23.2));        //凑整    24
        System.out.println((int)Math.rint(23.567));        //四舍五入取整    24
        System.out.println(new DecimalFormat("0").format(25.5));        //四舍五入取整    26

        System.out.println(Math.random());        //随机double 0.9786833725139645
        System.out.println(new Random().nextFloat());        //随机浮点数 0.5196178
        System.out.println(new Random().nextBoolean());        //随机boolean

//        Locale.setDefault(Locale.ENGLISH);
//        DecimalFormat df = new DecimalFormat();
//        df.applyPattern("00.00");
//        System.out.println(df.format(4.2355));
    }
}

Gavin.lee 2009-08-26 00:06 发表评论

多态总结

Gavin.lee — Sun, 23 Aug 2009 14:42:00 GMT

多态性是指“多种形式”
它使用不同的实例而执行不同操作
多态包括静态多态性和动态多态性

1).静态多态性---编译时多态
即用相同的方法名定义不同的方法内容。编译时根据它们的特征来进行编译. 即：方法重载

2).动态多态性---运行时多态
一种在运行时调用重写方法的机制。子类对象可以作为父类对象使用，这是因为子类通过继承具备了父类的所有属性。在程序中凡是可以使用父类对象的地方，都有可以用子类对象来代替。

Java提供了 instanceof 运算符，来判断一个对象属于哪个类的实例。

(重载是根据需要重写一个方法或在其中加功能
多态是根据需要传入不同参数构建不同的实例)

重写：动态多态性---运行时多态

package com.yixun.wap;

class Father {
    protected void showInfo() {
        System.out.println("Father");
    }
}

class Son extends Father {
    protected void showInfo() {
        System.out.println("Son");
    }

    protected void showSex() {
        System.out.println("男");
    }
}

class Daughter extends Father {
    protected void showInfo() {
        System.out.println("Daughter");
    }

    protected void showSex() {
        System.out.println("女");
    }
}
/**
* ******************************************
* @descripte 运行时多态，动态多态性
* 父类引用指向子类对象，实际对象为子类
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 是被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。
* @author Gavin.lee
* @date 2009-8-24下午05:21:49
* @version 1.0
*
********************************************
*/
public class TestSon {
    public static void main(String args[]) {
        Father fa;

        fa = new Son();     //向上转型，父类引用指向子类对象
        fa.showInfo();

//        fa.showSex();    //无法调用，父类无此方法
        Son son = (Son)fa;    //向下转型
        son.showSex();

        fa = new Daughter();
        fa.showInfo();
    }
}
/**
*    Son
*    男
*    Daughter
*同一个引用调用了相同名称的方法，结果却不一样---多态的体现
*/

Gavin.lee 2009-08-23 22:42 发表评论

java enum 类

Gavin.lee — Mon, 03 Aug 2009 14:49:00 GMT

http://zhangli-lisa.javaeye.com/blog/394951 关于enum的详细介绍了，

package com.Gavin.testenum;

public enum TestEnum {

one,two,three,middle,four,five;
}

package com.Gavin.testenum;

import org.apache.log4j.Logger;

public class Test {

    private static Logger logger = Logger.getLogger(Test.class);

    public static void main(String[] args) {
        Test t = new Test();
        logger.debug(TestEnum.one);        //one

        logger.debug(TestEnum.values().length);        //5

        t.enumvalues();        //依次打印

        logger.debug(t.getRandomEnum());
    }

    public void enumvalues() {
        for(TestEnum te: TestEnum.values()) {
            logger.debug(te);
        }
    }

    private static int number = TestEnum.values().length ; //枚举类的数目

    public TestEnum getRandomEnum(){
        long random = System.currentTimeMillis() % number;
        switch ((int) random){
        case 0:
            return TestEnum.one;
        case 1:
            return TestEnum.two;
        case 2:
            return TestEnum.three;
        default:
            return    TestEnum.middle;
        }
    }

}

Gavin.lee 2009-08-03 22:49 发表评论

BlogJava-java 友人帮-文章分类-java SE

commons-lang-2.4.jar 包常用方法集锦

String&InputStream的相互转化

java 堆与栈的详细介绍

HttpClient 一文通 （摘）

1、HttpClient的功能

2、预备工作

3、取得源码

4、使用HttpClient编程的基本步聚

5、认证

6、重定向

7、字符编码(character encoding)

8、Cookies

9、使用HttpClient遇到问题怎么办?

10、SSL

12、HTTP方法

java List 分页应用（二）

java List 分页应用（一）

java 有效的防止SQL注入

java clone

Java 序列化与反序列化

Junit 单元测试

压缩 XML 文件以便有效地传输

Java ClassLoader 类加载的学习

使用 XStream 在 JavaBean 与 XML/JSON 之间相互转换（摘）

利用java构建http服务器（摘）

java 实现URL重写

HttpsURLConnection 安全传输（HTTPS--Secure Hypertext Transfer Protocol-安全超文本传输协议）

Map 遍历

Apache Common HttpClient的使用

Apache commons 各种组件（摘）

Java路径问题最终解决方案（可定位所有资源的相对路径寻址）

十四种Java开发工具 ---了解

Java:线程堆---给自己系统中的线程命名，然后通过dump察看你的系统

Java代码触发生成ThreadDump

JAVA线程dump的分析 --- jstack pid

Java 的线程

产生 JAVA线程 dump

线程分析 ：

案例分析

总结

判断字符串是否是数字串

BigDecimal --判断两数相除是否为无穷

Math 取整函数

DecimalFormat 数据格式化类的使用小结

多态总结

java enum 类

HttpClient 一文通（摘）

线程分析：