BlogJava-The NoteBook of EricKong-随笔分类-Java

JDK内置工具使用

Eric_jiang — Fri, 15 May 2015 14:34:00 GMT

JDK内置工具使用

一、javah命令(C Header and Stub File Generator)

二、jps命令(Java Virtual Machine Process Status Tool)

三、jstack命令(Java Stack Trace)

四、jstat命令(Java Virtual Machine Statistics Monitoring Tool)

五、jmap命令(Java Memory Map)

六、jinfo命令(Java Configuration Info)

七、jconsole命令(Java Monitoring and Management Console)

八、jvisualvm命令(Java Virtual Machine Monitoring, Troubleshooting, and Profiling Tool)

九、jhat命令(Java Heap Analyse Tool)

十、Jdb命令(The Java Debugger)

十一、Jstatd命令(Java Statistics Monitoring Daemon)

Eric_jiang 2015-05-15 22:34 发表评论

Java线程Dump分析工具--jstack

Eric_jiang — Fri, 15 May 2015 14:24:00 GMT

jstack用于打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息，如果是在64位机器上，需要指定选项"-J-d64"，Windows的jstack使用方式只支持以下的这种方式：
jstack [-l][F] pid
如果java程序崩溃生成core文件，jstack工具可以用来获得core文件的java stack和native stack的信息，从而可以轻松地知道java程序是如何崩溃和在程序何处发生问题。另外，jstack工具还可以附属到正在运行的java程序中，看到当时运行的java程序的java stack和native stack的信息, 如果现在运行的java程序呈现hung的状态，jstack是非常有用的。进程处于hung死状态可以用-F强制打出stack。
dump 文件里，值得关注的线程状态有：
死锁，Deadlock（重点关注）
执行中，Runnable
等待资源，Waiting on condition（重点关注）
等待获取监视器，Waiting on monitor entry（重点关注）
暂停，Suspended
对象等待中，Object.wait() 或 TIMED_WAITING
阻塞，Blocked（重点关注）
停止，Parked

在摘了另一篇博客的三种场景：

实例一：Waiting to lock 和 Blocked

"RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd4f8684000]    java.lang.Thread.State: BLOCKED (on object monitor) at org.apache.log4j.Category.callAppenders(Category.java:201) - waiting to lock <0x00000000acf4d0c0> (a org.apache.log4j.Logger) at org.apache.log4j.Category.forcedLog(Category.java:388) at org.apache.log4j.Category.log(Category.java:853) at org.apache.commons.logging.impl.Log4JLogger.warn(Log4JLogger.java:234) at com.tuan.core.common.lang.cache.remote.SpyMemcachedClient.get(SpyMemcachedClient.java:110)

说明：
1）线程状态是 Blocked，阻塞状态。说明线程等待资源超时！
2）“ waiting to lock <0x00000000acf4d0c0>”指，线程在等待给这个 0x00000000acf4d0c0 地址上锁（英文可描述为：trying to obtain 0x00000000acf4d0c0 lock）。
3）在 dump 日志里查找字符串 0x00000000acf4d0c0，发现有大量线程都在等待给这个地址上锁。如果能在日志里找到谁获得了这个锁（如locked < 0x00000000acf4d0c0 >），就可以顺藤摸瓜了。
4）“waiting for monitor entry”说明此线程通过 synchronized(obj) {……} 申请进入了临界区，从而进入了下图1中的“Entry Set”队列，但该 obj 对应的 monitor 被其他线程拥有，所以本线程在 Entry Set 队列中等待。
5）第一行里，"RMI TCP Connection(267865)-172.16.5.25"是 Thread Name 。tid指Java Thread id。nid指native线程的id。prio是线程优先级。[0x00007fd4f8684000]是线程栈起始地址。

实例二：Waiting on condition 和 TIMED_WAITING

"RMI TCP Connection(idle)" daemon prio=10 tid=0x00007fd50834e800 nid=0x56b2 waiting on condition [0x00007fd4f1a59000]    java.lang.Thread.State: TIMED_WAITING (parking) at sun.misc.Unsafe.park(Native Method) - parking to wait for  <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack) at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:198) at java.util.concurrent.SynchronousQueue$TransferStack.awaitFulfill(SynchronousQueue.java:424) at java.util.concurrent.SynchronousQueue$TransferStack.transfer(SynchronousQueue.java:323) at java.util.concurrent.SynchronousQueue.poll(SynchronousQueue.java:874) at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:945) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907) at java.lang.Thread.run(Thread.java:662)

说明：

1）“TIMED_WAITING (parking)”中的 timed_waiting 指等待状态，但这里指定了时间，到达指定的时间后自动退出等待状态；parking指线程处于挂起中。

2）“waiting on condition”需要与堆栈中的“parking to wait for <0x00000000acd84de8> (a java.util.concurrent.SynchronousQueue$TransferStack)”结合来看。首先，本线程肯定是在等待某个条件的发生，来把自己唤醒。其次，SynchronousQueue 并不是一个队列，只是线程之间移交信息的机制，当我们把一个元素放入到 SynchronousQueue 中时必须有另一个线程正在等待接受移交的任务，因此这就是本线程在等待的条件。
3）别的就看不出来了。

实例三：in Obejct.wait() 和 TIMED_WAITING

"RMI RenewClean-[172.16.5.19:28475]" daemon prio=10 tid=0x0000000041428800 nid=0xb09 in Object.wait() [0x00007f34f4bd0000]    java.lang.Thread.State: TIMED_WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000000aa672478> (a java.lang.ref.ReferenceQueue$Lock) at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:118) - locked <0x00000000aa672478> (a java.lang.ref.ReferenceQueue$Lock) at sun.rmi.transport.DGCClient$EndpointEntry$RenewCleanThread.run(DGCClient.java:516) at java.lang.Thread.run(Thread.java:662)

说明：

1）“TIMED_WAITING (on object monitor)”，对于本例而言，是因为本线程调用了 java.lang.Object.wait(long timeout) 而进入等待状态。

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

3）RMI RenewClean 是 DGCClient 的一部分。DGC 指的是 Distributed GC，即分布式垃圾回收。

4）请注意，是先 locked <0x00000000aa672478>，后 waiting on <0x00000000aa672478>，之所以先锁再等同一个对象，请看下面它的代码实现：
static private class Lock { };
private Lock lock = new Lock();
public Reference remove(long timeout)
{
    synchronized (lock) {
        Reference r = reallyPoll();
        if (r != null) return r;
        for (;;) {
            lock.wait(timeout);
            r = reallyPoll();
            ……
       }
}
即，线程的执行中，先用 synchronized 获得了这个对象的 Monitor（对应于 locked <0x00000000aa672478> ）；当执行到 lock.wait(timeout);，线程就放弃了 Monitor 的所有权，进入“Wait Set”队列（对应于 waiting on <0x00000000aa672478> ）。
5）从堆栈信息看，是正在清理 remote references to remote objects ，引用的租约到了，分布式垃圾回收在逐一清理呢。

参考：

命令汇总：http://blog.csdn.net/fenglibing/article/details/6411940
三种实例：http://www.cnblogs.com/zhengyun_ustc/archive/2013/01/06/dumpanalysis.html

Eric_jiang 2015-05-15 22:24 发表评论

JVM性能调优监控工具jps、jstack、jmap、jhat、jstat使用详解

Eric_jiang — Fri, 20 Mar 2015 01:46:00 GMT

摘要: JDK本身提供了很多方便的JVM性能调优监控工具，除了集成式的VisualVM和jConsole外，还有jps、jstack、jmap、jhat、jstat等小巧的工具，本博客希望能起抛砖引玉之用，让大家能开始对JVM性能调优的常用工具有所了解。现实企业级Java开发中，有时候我们会碰到下面这些问题：OutOfMemoryError，内存不足内存泄露线程死锁锁争用（Lo... 阅读全文

Eric_jiang 2015-03-20 09:46 发表评论

AVAMAIL发送邮件给多个收件人

Eric_jiang — Mon, 09 Feb 2015 05:05:00 GMT

String[] str = {};

InternetAddress[] address=new InternetAddress[amount];

for (int i=0;i

address[i]=new InternetAddress(str[i]]);

}

msg.setRecipients(Message.RecipientType.TO,address);

Eric_jiang 2015-02-09 13:05 发表评论

Java安全通信：HTTPS与SSL

Eric_jiang — Tue, 27 Jan 2015 02:28:00 GMT

1. HTTPS概念

1）简介

HTTPS（全称：Hypertext Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。这个系统的最初研发由网景公司进行，提供了身份验证与加密通讯方法，现在它被广泛用于万维网上安全敏感的通讯，例如交易支付方面。

2）HTTPS和HTTP的区别

　　a. https协议需要到ca申请证书，一般免费证书很少，需要交费。

　　b. http是超文本传输协议，信息是明文传输；https 则是具有安全性的ssl加密传输协议。

　　c. http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

d. http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。

3）HTTPS的作用

它的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。

　　a．一般意义上的https，就是服务器有一个证书。主要目的是保证服务器就是他声称的服务器，这个跟第一点一样；服务端和客户端之间的所有通讯，都是加密的。

　　b. 具体讲，是客户端产生一个对称的密钥，通过服务器的证书来交换密钥，即一般意义上的握手过程。

　　c. 接下来所有的信息往来就都是加密的。第三方即使截获，也没有任何意义，因为他没有密钥，当然篡改也就没有什么意义了。

　　d．少许对客户端有要求的情况下，会要求客户端也必须有一个证书。

这里客户端证书，其实就类似表示个人信息的时候，除了用户名/密码，还有一个CA 认证过的身份。因为个人证书一般来说是别人无法模拟的，所有这样能够更深的确认自己的身份。目前少数个人银行的专业版是这种做法，具体证书可能是拿U盘（即U盾）作为一个备份的载体。

2.SSL简介

　　1）简介

　　SSL (Secure Socket Layer)为Netscape所研发，用以保障在Internet上数据传输之安全，利用数据加密(Encryption)技术，可确保数据在网络上之传输过程中不会被截取及窃听。它已被广泛地用于Web浏览器与服务器之间的身份认证和加密数据传输。SSL协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持。

　　2）SSL提供的服务

　　a.认证用户和服务器，确保数据发送到正确的客户机和服务器

　　b.加密数据以防止数据中途被窃取

　　c.维护数据的完整性，确保数据在传输过程中不被改变。

　　3) SSL协议的握手过程

　　SSL 协议既用到了公钥加密技术又用到了对称加密技术，对称加密技术虽然比公钥加密技术的速度快，可是公钥加密技术提供了更好的身份认证技术。SSL 的握手协议非常有效的让客户和服务器之间完成相互之间的身份认证，其主要过程如下：

　　①客户端的浏览器向服务器传送客户端SSL 协议的版本号，加密算法的种类，产生的随机数，以及其他服务器和客户端之间通讯所需要的各种信息。

　　②服务器向客户端传送SSL 协议的版本号，加密算法的种类，随机数以及其他相关信息，同时服务器还将向客户端传送自己的证书。

　　③客户利用服务器传过来的信息验证服务器的合法性，服务器的合法性包括：证书是否过期，发行服务器证书的CA 是否可靠，发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”，服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过，通讯将断开；如果合法性验证通过，将继续进行第四步。

　　④用户端随机产生一个用于后面通讯的“对称密码”，然后用服务器的公钥（服务器的公钥从步骤②中的服务器的证书中获得）对其加密，然后传给服务器。

　　⑤服务器用私钥解密“对称密码”(此处的公钥和私钥是相互关联的，公钥加密的数据只能用私钥解密，私钥只在服务器端保留。详细请参看： http://zh.wikipedia.org/wiki/RSA%E7%AE%97%E6%B3%95)，然后用其作为服务器和客户端的“通话密码”加解密通讯。同时在SSL 通讯过程中还要完成数据通讯的完整性，防止数据通讯中的任何变化。

　　⑥客户端向服务器端发出信息，指明后面的数据通讯将使用的步骤⑤中的主密码为对称密钥，同时通知服务器客户端的握手过程结束。

　　⑦服务器向客户端发出信息，指明后面的数据通讯将使用的步骤⑤中的主密码为对称密钥，同时通知客户端服务器端的握手过程结束。

　　⑧SSL 的握手部分结束，SSL 安全通道的数据通讯开始，客户和服务器开始使用相同的对称密钥进行数据通讯，同时进行通讯完整性的检验。

3.配置服务器端证书

　　为了能实施SSL，一个web服务器对每个接受安全连接的外部接口(IP 地址)必须要有相应的证书(Certificate)。关于这个设计的理论是一个服务器必须提供某种合理的保证以证明这个服务器的主人就是你所认为的那个人。这个证书要陈述与这个网站相关联的公司，以及这个网站的所有者或系统管理员的一些基本联系信息。

　　这个证书由所有人以密码方式签字，其他人非常难伪造。对于进行电子商务(e-commerce)的网站，或其他身份认证至关重要的任何商业交易，认证书要向大家所熟知的认证权威(Certificate Authority (CA))如VeriSign或Thawte来购买。这样的证书可用电子技术证明属实。实际上，认证权威单位会担保它发出的认证书的真实性，如果你信任发出认证书的认证权威单位的话，你就可以相信这个认证书是有效的。

　　关于权威证书的申请，请参考：http://www.cnblogs.com/mikespook/archive/2004/12/22/80591.aspx

　　在许多情况下，认证并不是真正使人担忧的事。系统管理员或许只想要保证被服务器传送和接收的数据是秘密的，不会被连接线上的偷窃者盗窃到。庆幸的是，Java提供相对简单的被称为keytool的命令行工具，可以简单地产生“自己签名”的证书。自己签名的证书只是用户产生的证书，没有正式在大家所熟知的认证权威那里注册过，因此不能确保它的真实性。但却能保证数据传输的安全性。

　　用Tomcat来配置SSL主要有下面这么两大步骤：

　　1)生成证书

　　a. 在命令行下执行：

　　%Java_home%\bin\keytool -genkey -alias tomcat -keyalg RSA

　　在此命令中，keytool是JDK自带的产生证书的工具。把RSA运算法则作为主要安全运算法则，这保证了与其它服务器和组件的兼容性。

这个命令会在用户的home directory产生一个叫做" .keystore " 的新文件。在执行后，你首先被要求出示keystore密码。Tomcat使用的默认密码是" changeit "(全都是小写字母)，如果你愿意，你可以指定你自己的密码。你还需要在server.xml配置文件里指定自己的密码，这在以后会有描述。

　　b .你会被要求出示关于这个认证书的一般性信息，如公司，联系人名称，等等。这些信息会显示给那些试图访问你程序里安全网页的用户，以确保这里提供的信息与他们期望的相对应。

　　c.你会被要求出示密钥(key)密码，也就是这个认证书所特有的密码(与其它的储存在同一个keystore文件里的认证书不同)。你必须在这里使用与keystore密码相同的密码。(目前，keytool会提示你按ENTER键会自动帮你做这些)。

　　如果一切顺利，你现在就拥有了一个可以被你的服务器使用的有认证书的keystore文件。

　　2) 配置tomcat

　　第二个大步骤是把secure socket配置在$CATALINA_HOME/conf/server.xml文件里。$CATALINA_HOME代表安装Tomcat的目录。一个例子是SSL连接器的元素被包括在和Tomcat一起安装的缺省server.xml文件里。它看起来象是这样：

$CATALINA_HOME/conf/server.xml

< -- Define a SSL Coyote HTTP/1.1 Connector on port 8443 -->

< !--

< Connector

port="8443" minProcessors="5" maxProcessors="75"

enableLookups="true" disableUploadTimeout="true"

acceptCount="100" debug="0" scheme="https" secure="true";

clientAuth="false" sslProtocol="TLS"/>

-->

　　Connector元素本身，其默认形式是被注释掉的(commented out)，所以需要把它周围的注释标志删除掉。然后，可以根据需要客户化(自己设置)特定的属性。一般需要增加一下keystoreFile和keystorePass两个属性，指定你存放证书的路径（如：keystoreFile="C:/.keystore"）和刚才设置的密码（如：keystorePass="123456"）。关于其它各种选项的详细信息，可查阅Server Configuration Reference。

　　在完成这些配置更改后，必须象重新启动Tomcat，然后你就可以通过SSL访问Tomcat支持的任何web应用程序。只不过指令需要像下面这样：https://localhost:8443

4.客户端代码实现

　　在Java中要访问Https链接时，会用到一个关键类HttpsURLConnection；参见如下实现代码：

        // 创建URL对象
        URL myURL = new URL("https://www.sun.com");
 
        // 创建HttpsURLConnection对象，并设置其SSLSocketFactory对象
        HttpsURLConnection httpsConn = (HttpsURLConnection) myURL.openConnection();
 
        // 取得该连接的输入流，以读取响应内容
        InputStreamReader insr = new InputStreamReader(httpsConn.getInputStream());
 
        // 读取服务器的响应内容并显示
        int respInt = insr.read();
        while (respInt != -1) {
            System.out.print((char) respInt);
            respInt = insr.read();
        }

　　在取得connection的时候和正常浏览器访问一样，仍然会验证服务端的证书是否被信任（权威机构发行或者被权威机构签名）；如果服务端证书不被信任，则默认的实现就会有问题，一般来说，用SunJSSE会抛如下异常信息：

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building

failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

　　上面提到SunJSSE，JSSE（Java Secure Socket Extension）是实现Internet安全通信的一系列包的集合。它是一个SSL和TLS的纯Java实现，可以透明地提供数据加密、服务器认证、信息完整性等功能，可以使我们像使用普通的套接字一样使用JSSE建立的安全套接字。JSSE是一个开放的标准，不只是Sun公司才能实现一个SunJSSE，事实上其他公司有自己实现的JSSE，然后通过JCA就可以在JVM中使用。

　　关于JSSE的详细信息参考官网Reference：http://java.sun.com/j2se/1.5.0/docs/guide/security/jsse/JSSERefGuide.html；
　　以及Java Security Guide：http://java.sun.com/j2se/1.5.0/docs/guide/security/；

　　在深入了解JSSE之前，需要了解一个有关Java安全的概念：客户端的TrustStore文件。客户端的TrustStore文件中保存着被客户端所信任的服务器的证书信息。客户端在进行SSL连接时，JSSE将根据这个文件中的证书决定是否信任服务器端的证书。在SunJSSE中，有一个信任管理器类负责决定是否信任远端的证书，这个类有如下的处理规则：
1)若系统属性javax.net.sll.trustStore指定了TrustStore文件，那么信任管理器就去jre安装路径下的lib/security/目录中寻找并使用这个文件来检查证书。
2)若该系统属性没有指定TrustStore文件，它就会去jre安装路径下寻找默认的TrustStore文件，这个文件的相对路径为：lib/security/jssecacerts。
3)若jssecacerts不存在，但是cacerts存在（它随J2SDK一起发行，含有数量有限的可信任的基本证书），那么这个默认的TrustStore文件就是lib/security/cacerts。

　　那遇到这种情况，怎么处理呢？有以下两种方案：
　　1)按照以上信任管理器的规则，将服务端的公钥导入到jssecacerts，或者是在系统属性中设置要加载的trustStore文件的路径；证书导入可以用如下命令：keytool -import -file src_cer_file –keystore dest_cer_store；至于证书可以通过浏览器导出获得；
　　2)、实现自己的证书信任管理器类，比如MyX509TrustManager，该类必须实现X509TrustManager接口中的三个method；然后在HttpsURLConnection中加载自定义的类，可以参见如下两个代码片段，其一为自定义证书信任管理器，其二为connect时的代码：

package test;
import java.io.FileInputStream;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
public class MyX509TrustManager implements X509TrustManager {
    /*
     * The default X509TrustManager returned by SunX509.  We'll delegate
     * decisions to it, and fall back to the logic in this class if the
     * default X509TrustManager doesn't trust it.
     */
    X509TrustManager sunJSSEX509TrustManager;
    MyX509TrustManager() throws Exception {
        // create a "default" JSSE X509TrustManager.
        KeyStore ks = KeyStore.getInstance("JKS");
        ks.load(new FileInputStream("trustedCerts"),
            "passphrase".toCharArray());
        TrustManagerFactory tmf =
        TrustManagerFactory.getInstance("SunX509", "SunJSSE");
        tmf.init(ks);
        TrustManager tms [] = tmf.getTrustManagers();
        /*
         * Iterate over the returned trustmanagers, look
         * for an instance of X509TrustManager.  If found,
         * use that as our "default" trust manager.
         */
        for (int i = 0; i < tms.length; i++) {
            if (tms[i] instanceof X509TrustManager) {
                sunJSSEX509TrustManager = (X509TrustManager) tms[i];
                return;
            }
        }
        /*
         * Find some other way to initialize, or else we have to fail the
         * constructor.
         */
        throw new Exception("Couldn't initialize");
    }
    /*
     * Delegate to the default trust manager.
     */
    public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        try {
            sunJSSEX509TrustManager.checkClientTrusted(chain, authType);
        } catch (CertificateException excep) {
            // do any special handling here, or rethrow exception.
        }
    }
    /*
     * Delegate to the default trust manager.
     */
    public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
        try {
            sunJSSEX509TrustManager.checkServerTrusted(chain, authType);
        } catch (CertificateException excep) {
            /*
             * Possibly pop up a dialog box asking whether to trust the
             * cert chain.
             */
        }
    }
    /*
     * Merely pass this through.
     */
    public X509Certificate[] getAcceptedIssuers() {
        return sunJSSEX509TrustManager.getAcceptedIssuers();
    }
}
        // 创建SSLContext对象，并使用我们指定的信任管理器初始化
        TrustManager[] tm = { new MyX509TrustManager() };
        SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
        sslContext.init(null, tm, new java.security.SecureRandom());
        // 从上述SSLContext对象中得到SSLSocketFactory对象
        SSLSocketFactory ssf = sslContext.getSocketFactory();
        // 创建URL对象
        URL myURL = new URL("https://ebanks.gdb.com.cn/sperbank/perbankLogin.jsp");
        // 创建HttpsURLConnection对象，并设置其SSLSocketFactory对象
        HttpsURLConnection httpsConn = (HttpsURLConnection) myURL.openConnection();
        httpsConn.setSSLSocketFactory(ssf);
        // 取得该连接的输入流，以读取响应内容
        InputStreamReader insr = new InputStreamReader(httpsConn.getInputStream());
        // 读取服务器的响应内容并显示
        int respInt = insr.read();
        while (respInt != -1) {
            System.out.print((char) respInt);
            respInt = insr.read();
        }

　　对于以上两种实现方式，各有各的优点，第一种方式不会破坏JSSE的安全性，但是要手工导入证书，如果服务器很多，那每台服务器的JRE都必须做相同的操作；第二种方式灵活性更高，但是要小心实现，否则可能会留下安全隐患；

　　参考文献：　　　　　　

　　http://baike.baidu.com/view/14121.htm

　　http://zh.wikipedia.org/wiki/RSA%E7%AE%97%E6%B3%95

　　http://blog.csdn.net/sfdev/article/details/2957240

　　http://blog.csdn.net/cyberexp2008/article/details/6695691

Eric_jiang 2015-01-27 10:28 发表评论

Servlet作为代理实现跨域访问

Eric_jiang — Mon, 26 Jan 2015 09:32:00 GMT

就是在前台中调用proxy程序的servlet，设置参数servletName和其它参数。代理程序会将该请求发送到目的地址的名称为servletName的servlet中去，并将其它参数作为请求的参数，在得到结果后，将内容原样输出到请求页面。

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLEncoder;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class ProxyServlet extends HttpServlet {

private String url;

/**

* 对servlet进行请求处理，并将结果在指定输出流中输出

* @param os

* @param servletName

* @param parm

* @throws IOException

* @throws MalformedURLException

private void process(HttpServletRequest req, HttpServletResponse resp,

String[] target) throws MalformedURLException, IOException {

// 取得连接

HttpURLConnection huc = (HttpURLConnection) new URL(url + target[0])

.openConnection();

// 设置连接属性

huc.setDoOutput(true);

huc.setRequestMethod("POST");

huc.setUseCaches(false);

huc.setInstanceFollowRedirects(true);

huc.setRequestProperty("Content-Type",

"application/x-www-form-urlencoded");

huc.connect();

// 往目标servlet中提供参数

OutputStream targetOS = huc.getOutputStream();

targetOS.write(target[1].getBytes());

targetOS.flush();

targetOS.close();

// 取得页面输出,并设置页面编码及缓存设置

resp.setContentType(huc.getContentType());

resp.setHeader("Cache-Control", huc.getHeaderField("Cache-Control"));

resp.setHeader("Pragma", huc.getHeaderField("Pragma"));

resp.setHeader("Expires", huc.getHeaderField("Expires"));

OutputStream os = resp.getOutputStream();

// 将目标servlet的输入流直接往页面输出

InputStream targetIS = huc.getInputStream();

int r;

while ((r = targetIS.read()) != -1) {

os.write(r);

}

targetIS.close();

os.flush();

os.close();

huc.disconnect();

}

/**

* 将参数中的目标分离成由目标servlet名称和参数组成的数组

* @param queryString

* @return

* @throws UnsupportedEncodingException

private String[] parse(Map map) throws UnsupportedEncodingException {

String[] arr = { "", "" };

Iterator iter = map.entrySet().iterator();

while (iter.hasNext()) {

Map.Entry me = (Entry) iter.next();

String[] varr = (String[]) me.getValue();

if ("servletName".equals(me.getKey())) {

// 取出servlet名称

arr[0] = varr[0];

} else {

// 重新组装参数字符串

for (int i = 0; i < varr.length; i++) {

// 参数需要进行转码，实现字符集的统一

arr[1] += "&" + me.getKey() + "="

+ URLEncoder.encode(varr[i], "utf-8");

}

arr[1] = arr[1].replaceAll("^&", "");

return arr;

}

@Override

public void init() throws ServletException {

// 设置目标服务器地址

url = this.getInitParameter("url");

if (!url.endsWith("/"))

url = url + "/";

}

@Override

protected void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

this.doPost(req, resp);

}

@Override

protected void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

String[] target = parse(req.getParameterMap());

process(req, resp, target);

}

Eric_jiang 2015-01-26 17:32 发表评论

java中的xml解析时jaxp.properties文件问题

Eric_jiang — Thu, 15 Jan 2015 04:42:00 GMT

工作中，使用JAVA的JAXP读取解析XML文件中，就碰到了一件奇件的事。在Web工程中，调试发现JAXP实际使用的是Xerces解析器，
可是，当将工程中的一个小Swing工具，与Web使用一样的jar包，打成一个可执行的jar包时，调试却发现JAXP实际使用的是Crimson
解析器，还会发现解析XML文件时出现错误，经过分析，发现Crimson解析器是Sun公司开发的(实际使用发现Crimson没有Xerces解析器稳定)，
打包在JAVA_HOME/lib/dt.jar包中，这个dt.jar被设置在环境变量CLASSPATH中了，当运行可执行的jar包是，JAXP会使用CLASSPATH的解析器，
在Web工程中的War包则不会。
通过阅读JDK源码javax.xml.parsers.FactoryFinder，javax.xml.parsers.SAXParserFactory以及DocumentBuilderFactory发现JDK按照如下顺序：

1 系统属性javax.xml.parsers.DocumentBuilderFactory或javax.xml.parsers.SAXParserFactory

2 在jdk-dir/lib/jaxp.properties中设定的javax.xml.parsers.DocumentBuilderFactory或javax.xml.parsers.SAXParserFactory属性

3 运行时jar包中META-INF/services/javax.xml.parsers.DocumentBuilderFactory或javax.xml.parsers.SAXParserFactory文件中设定的值

4. 如果上面的解析器都没有找到，则使用Crimson。如果还没有。。。。。。那报ClassNotFound异常了。

通过JAXP查找解析器的顺序，我们可以使用下面方式来决定，我们使用的实际解析器，
1 在程序中写死实际的解析器
如
javax.xml.parsers.DocumentBuilderFactory factory＝ new org.apache.crimson.jaxp.DocumentBuilderFactoryImpl();
2 使用JAXP的 DocumentBuilderFactory 工厂类，如
javax.xml.parsers.DocumentBuilderFactory factory＝ javax.xml.parsers.DocumentBuilderFactory.newInstance();
再通过下面的方式来指定实际的解析器类
方法一:在运行java时，通过设置java -D javax.xml.parsers.DocumentBuilderFactory=new org.apache.crimson.jaxp.DocumentBuilderFactoryImpl
方法二:在程序中调用System.setProperty(“javax.xml.parsers.DocumentBuilderFactory”,” org.apache.crimson.jaxp.DocumentBuilderFactoryImpl”)
来设定实际的XML解析器.
方法三:编写一个jaxp.properties文件，在其中加入如下内容
javax.xml.parsers.DocumentBuilderFactory=org.apache.crimson.jaxp.DocumentBuilderFactoryImpl
再将此文件放入JAVA_HOME/lib/下
方法四:在打jar包下，在目录META-INF/下新建一个services目录，在此目录新建一个文件名为javax.xml.parsers.DocumentBuilderFactory的文件，
文件内容写上实际使用的解析器类，如写org.apache.crimson.jaxp.DocumentBuilderFactoryImpl
通过，上面，我们就可以对JAXP有一个比较深的了解。其实，JAVA中有许多这种思想的做法，这种思想，指的是什么的，就是平台无关性，发展到不依赖于具体的实现。
如我们熟悉的JNDI，JDBC，JAXP等。JNDI是抽像各种目录服务操作的类库，因为目录服务器厂商太多了，如SUN公司的ldapsdk,还有novell公司等等。JDBC是抽像各种数据库
操作的类库，因为数据库厂商也太多了，如ORACLE，SQLSERVER，MYSQL，INFORMIX等等，JAXP就是抽像各种XML解析器和转换器产品的类库，因为XML解析器和转换器产品够多
的了。

访问AIX系统中部署在OC4J中的web 模块的页面时遇到这个错误：
javax.xml.parsers.FactoryConfigurationError: Provider null could not be instantiated:
java.lang.NullPointerException
at javax.xml.parsers.SAXParserFactory.newInstance(Unknown Source)
at org.apache.commons.digester.Digester.getFactory(Digester.java:478)
at org.apache.commons.digester.Digester.getParser(Digester.java:683)
at org.apache.commons.digester.Digester.getXMLReader(Digester.java:891)
at org.apache.commons.digester.Digester.parse(Digester.java:1591)
at org.apache.struts.action.ActionServlet.initServlet(ActionServlet.java:1433)
at org.apache.struts.action.ActionServlet.init(ActionServlet.java:466)
at javax.servlet.GenericServlet.init(GenericServlet.java:256)
at com.evermind[Oracle Containers for J2EE 10g (10.1.3.0.0) ].server.http.HttpApplication.loadServlet(HttpApplication.java:2231)
at com.evermind[Oracle Containers for J2EE 10g (10.1.3.0.0) ].server.http.HttpApplication.findServlet(HttpApplication.java:4617)
……
或者这样的异常：
javax.servlet.jsp.JspException: Can't get definitions factory from context.
at org.apache.struts.taglib.tiles.InsertTag.processDefinitionName(InsertTag.java:583)
at org.apache.struts.taglib.tiles.InsertTag.createTagHandler(InsertTag.java:487)
at org.apache.struts.taglib.tiles.InsertTag.doStartTag(InsertTag.java:451)
at _welcome._jspService(_welcome.java:54)
[SRC:/welcome.jsp:4]

……
而当在Windows环境下部署时就没有问题。

这里是因为IBM的AIX系统使用的是IBM的JDK。而出现这个问题正是因为IBM和SUN的JDK的差异。具体是因为$JAVA_HOME/jre/lib/jaxp.properties 这个文件。

这个文件以key=value的形式配置和指定实际使用的XML解析器实现类(譬如：javax.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl)。在XML解析器初始化之前，JDK首先会搜索System的properties寻找解析器的配置项，如果没有则会搜索 $JAVA_HOME/jre/lib 路径下的 jaxp.properties 文件，如果还没有，接下来会在classpath上的.jar包中寻找，仍然没有的话就会使用默认的解析器。

实际上这个文件在SUN的JDK中是不存在的。在找不到文件的情况下，最终将使用默认解析器。在IBM的JDK中存在 jaxp.properties这个文件。但是这个文件中默认所有的配置项是注释掉的，所以在搜索到此处时，不再继续向下搜索，但是由于读取不到配置项，所以会返回null ，于是出现了上文的第一个错误。第二个异常大概是因为访问使用tiles框架的页面时，由于XML解析器初始化出错，所以tiles框架的配置文件也就读取不了了。

Eric_jiang 2015-01-15 12:42 发表评论

Java /Jsp 执行操作系统命令 windows/Linux

Eric_jiang — Wed, 24 Dec 2014 04:01:00 GMT

1.Windows 很简单，写出来时为了和linux对比

   public void execWindowsCmd(String cmd) throws Exception {
      Runtime rt = Runtime.getRuntime();
      Process ppp = rt.exec(cmd);
      //input
      InputStreamReader ir = new InputStreamReader(ppp.getInputStream());
      LineNumberReader input = new LineNumberReader(ir);

      String line;
      while ((line = input.readLine()) != null)
         com.pub.Log.logger.debug(this.getClass().getClass() + " " +
                                           line);

      //error
      ir = new InputStreamReader(ppp.getErrorStream());
      input = new LineNumberReader(ir);
      while ((line = input.readLine()) != null)
         com.pub.Log.logger.debug(this.getClass().getClass() + " " +
                                           line);

ppp.waitFor();
}

2. Linux ：首先要确保对于命令，允许Web服务器的用户是否有权限，普通命令和windows没什么区别。Linux管道命令不能这样直接执行，下面是具体实现fang

   public void execLinuxCmd(String cmd) throws Exception {
      Runtime rt = Runtime.getRuntime();
      File f = new File(this.fileName + PDU_SHELL);
      BufferedWriter bw = new BufferedWriter(new FileWriter(f));
      bw.write("#!/bin/bash");
      bw.newLine();
      bw.write(cmd); //把命令写入一个文本shell文件
      bw.flush();
      bw.close();
      cmd = f.getAbsolutePath();

Process ppp = rt.exec("chmod a+x " + cmd); //授权该shell文件可以执行
ppp.waitFor();

ppp = rt.exec(cmd); //执行shell

      //input
      InputStreamReader ir = new InputStreamReader(ppp.getInputStream());
      LineNumberReader input = new LineNumberReader(ir);

      String line;
      while ((line = input.readLine()) != null)
         com.pub.Log.logger.debug(this.getClass().getClass() + " " +
                                           line);

ppp.waitFor();

}

Eric_jiang 2014-12-24 12:01 发表评论

10个基于Java的CMS网站内容管理系统

Eric_jiang — Tue, 11 Nov 2014 07:50:00 GMT

在开始研究 java CMS之前，我们先要了解什么是CMS。CMS — Content Management Systems，内容管理系统，简单的说，就是一个帮助进行网站内容管理的系统。CMS通常包含两部分：内容管理程序(Content Management Application ,CMA)和内容发布程序(Content Delivery Application ,CDA)，内容管理程序可以帮助网站管理员轻松的实现网站文章的创建、编辑和删除操作，内容发布程序则可以编辑文章并在网站上发布它们。

一个完整的CMS通常包含一个在线的发布、排版、版本控制，以及列表、搜索、恢复等功能模块。近年来大量涌现的企业网站管理系统，则增加了新闻管理、使用手册、在线帮助、销售手册等功能。难以避免的，功能强大的CMS往往有着高昂的售价，预算不足的用户很希望找到一款好用且免费的管理系统。现在已经出现了许多基于java的开源CMS系统，本文挑选了10个最强大、最易用的CMS，向大家做一个简要介绍。1. Alfresco

Alfresco是一个开源的企业网站内容管理系统，它提供了文档管理、多人协作、记录管理、知识管理网页内容和图像管理等功能。它使用Spring、 Hibernate、 Lucene 和JSF等最新java技术构建了模块化的系统架构。Alfresco官方网站:http://www.alfresco.com/中文教程:http://blog.csdn.net/alfresco/2. DotCMS

DotCMS 是一个开源的企业级内容管理系统，它融入了电子商务、个性化设置、客户关系管理工具等功能，它可以方便的建立基于各种关系的数据结构和数据库，它可以使用模板快速创建页面，并且提供了一个强大的所见即所得(WYSIWYG)编辑器。用户可以使用加载外部模块的功能快速的建立Ajax应用、搜索、MP3播放器、幻灯片和相册等功能。DotCMS官方网站http://dotcms.org/中文安装教程http://www.javaeye.com/wiki/topic/2777943. Magnolia

Magnolia 是一个老牌的java内容管理系统，目前已经发布了第四版。它的独特之处在于可以定制内容模型，以返回数组形式来搞定各种不确定的功能。它遵循W3C标准并且在搜索引擎优化上有许多优势。同时它支持java内容仓库( java content repositories , JCR) 的API。Magnolia官方网站http://www.magnolia-cms.com/home.html4. OpenCms

它提供了一套建立和维护网站的方便的工具。在内容建设方面，它拥有一个易于使用的界面和所见即所得编辑器，在网页生成上它使用了一个先进的页面模板。OpenCMS官方网站http://www.opencms.org/opencms/en/index.html中文网站http://www.opencms.cn/6. AtLeap

Blandware AtLeap是一个多语种的免费Java内容管理系统，它包含了全文搜索引擎，可以算是一个能让你方便的编写应用的网站框架。Atleap官方网站https://atleap.dev.java.net/7. Fedora

Fedora 是“Flexible Extensible Digital Object Repository Architecture”的缩写，并不是Linux发行版Fedora，是一个数字资源管理系统，它可以创建很多类型的数字图书馆、资料库、档案馆系统等。Fedora官方网站http://www.fedora-commons.org/8. Apache Lenya

这是一个开源的 Java/XML 内容管理系统，提供了版本控制、多站点管理、调度、搜索、所见即所得编辑以及工作流程等功能。Apache Lyenya使用基于模块的Cocoom开源程序框架。Apache Lyenya官方网站http://lenya.apache.org/9. OpenEdit

OpenEdit是一个开源的内容管理系统，它旨在建设基于在线数字资产的多媒体网站。它提供在线编辑，动态布局，拼写检查，用户管理器，文件管理器，版本控制和通知工具。同时包含企业级的插件，如电子商务，内容管理，博客，活动日程表，社交网络工具等。OpenEdit官方网站http://www.openedit.org/10. Contelligent这个基于Java的开源解决方案有助于创建和管理个性化网站。它完全遵循J2EE，具有先进的模式，可以方便的添加第三方应用。Contelligent官方网站http://www.contelligent.com/

Eric_jiang 2014-11-11 15:50 发表评论

Java读取properties配置文件时，中文乱码解决方法 .

Eric_jiang — Fri, 10 Oct 2014 01:39:00 GMT

碰到了用java.util.Properties读取中文内容（UTF-8格式）的配置文件，发生中文乱码的现象，

Java代码  
Properties prop=new Properties();         
prop.load(Client.class.getClassLoader().getResourceAsStream("config.properties"));  

习惯性google了一下，网上大多数文章都是让大家用native2ascii.exe转换这样的解决方案，一开始还差点被懵住了，以为只能使用这样的绕弯子方法。。。

但关键是，太绕了！如果每次都用native2ascii.exe将中文转换成\uXXXX\uXXXX这样的，麻烦先不说，转换完后的文件完全不可读！！！这基本上是不可忍受的！
（虽然也能用native2ascii.exe转换回来，但同样，麻烦！）

冷静下来后，突然想起来，还是初学java时看过，java.io包中 Reader/Writer和Stream的区别。
（年代久远，具体细节忘记了，大概是：Reader/Write是处理编码文本的，而InputStream/OutputStream只把数据当作2进制流）

正确解决方案

Java代码  
Properties prop=new Properties();         
prop.load(new InputStreamReader(Client.class.getClassLoader().getResourceAsStream("config.properties"), "UTF-8"));         

其中“UTF-8”，用于明确指定.properties文件的编码格式（不指定则默认使用OS的，这会造成同一份配置文件同一份代码，在linux和windows上、英文windows和中文windows之间的表现都不一致），这个参数应该和具体读取的properties文件的格式匹配。

Eric_jiang 2014-10-10 09:39 发表评论

httpclient 实现自动登录NTLM 域验证（sso） .

Eric_jiang — Thu, 09 Oct 2014 03:53:00 GMT

最近一个项目拿到客户那运行不了。原来我的这个项目要和另一个系统通过http的接口进行通讯。但在客户的生产环境中，那套系统将web应用的登录和Windows Domain的登录结合，做了一个sso单点登录（jcifs实现）。那么我必须要修改我的程序，好自动登录Windows Domain。

通过抓包分析，局域网使用的是NTLM 协议。

当通过浏览器访问被NTLM协议保护的资源的时候，NTLM的认证方式和流程如下：

    1: C  --> S   GET ...
    
    2: C <--  S   401 Unauthorized
                  WWW-Authenticate: NTLM
    
    3: C  --> S   GET ...
                  Authorization: NTLM 
    
    4: C <--  S   401 Unauthorized
                  WWW-Authenticate: NTLM 
    
    5: C  --> S   GET ...
                  Authorization: NTLM 
    
    6: C <--  S   200 Ok

Type-1消息包括机器名、Domain等

Type-2消息包括server发出的NTLM challenge

Type-3消息包括用户名、机器名、Domain、以及两个根据server发出的challenge计算出的response，这里response是基于challenge和当前用户的登录密码计算而得

PS：在第二步时，当浏览器接收到一个401 Unauthorized 的response，会弹出该对话框让用户输入用户名、密码。（ie有可能会自动登录）

我的程序（client）要和另个程序走http接口通讯（server），server再去ad验证域登录

httpclient 实现NTLM验证（当然你也可以自己实现协议）

HttpClient从version 4.1 开始完全支持NTLM authentication protocol（NTLMv1, NTLMv2, and NTLM2 ），文档的原话是“The NTLM authentication scheme is significantly more expensive in terms of computational overhead
and performance impact than the standard Basic and Digest schemes.”

但是使用起来还是非常的方便的。因为 NTLM 连接是有状态的，通常建议使用相对简单的方法触发NTLM 认证，比如GET或 HEAD，而重用相同的连接来执行代价更大的方法，特别是它们包含请求实体，比如 POST或 PUT。

DefaultHttpClient httpclient = new DefaultHttpClient(); 
NTCredentials creds = new NTCredentials("user", "pwd", 
"myworkstation", "microsoft.com"); 
httpclient.getCredentialsProvider().setCredentials(AuthScop
.ANY, creds); 
HttpHost target = new HttpHost("www.microsoft.com", 80, 
"http"); 
// 保证相同的内容来用于执行逻辑相关的请求 
HttpContext localContext = new BasicHttpContext(); 
// 首先执行简便的方法。这会触发NTLM认证 
HttpGet httpget = new HttpGet("/ntlm-protected/info"); 
HttpResponse response1 = httpclient.execute(target, httpget
localContext); 
HttpEntity entity1 = response1.getEntity(); 
if (entity1 != null) { 
entity1.consumeContent(); 
} 
//之后使用相同的内容（和连接）执行开销大的方法。 
HttpPost httppost = new HttpPost("/ntlm-protected/form"); 
httppost.setEntity(new StringEntity("lots and lots of data"))
HttpResponse response2 = httpclient.execute(target, httppost,
localContext); 
HttpEntity entity2 = response2.getEntity(); 
if (entity2 != null) { 
entity2.consumeContent(); 
}

import org.apache.commons.httpclient.ProxyHost;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

      private HttpClient getHttpClient() {

       DefaultHttpClient httpClient = new DefaultHttpClient();
       String proxyHost = "";
       int proxyPort = 8080;
       String userName = "";
       String password = "";
       httpClient.getCredentialsProvider().setCredentials(
               new AuthScope(proxyHost, proxyPort),
               new UsernamePasswordCredentials(userName, password));
       HttpHost proxy = new HttpHost(proxyHost, proxyPort);
       httpClient.getParams().setParameter(ConnRouteParams.DEFAULT_PROXY,
               proxy);
       return httpClient;
   }

Eric_jiang 2014-10-09 11:53 发表评论

SSL-用Keytool和OpenSSL生成和签发数字证书

Eric_jiang — Tue, 22 Jul 2014 06:42:00 GMT

J2SDK在目录%JAVA_HOME%/bin提供了密钥库管理工具Keytool，用于管理密钥、证书和证书链。Keytool工具的命令在JavaSE6中已经改变，不过以前的命令仍然支持。Keytool也可以用来管理对称加密算法中的密钥。

最简单的命令是生成一个自签名的证书，并把它放到指定的keystore文件中：

keytool -genkey -alias tomcat -keyalg RSA -keystore c:/mykey

如果c:/mykey文件不存在，keytool会生成这个文件。按照命令的提示，回答一系列问题，就生成了数字证书。注意，公共名称(cn)应该是服务器的域名。这样keystore中就存在一个别名为tomcat的实体，它包括公钥、私钥和证书。这个证书是自签名的。

Keytool工具可以从keystore中导出证书，但是不能导出私钥。对于配置apache这样的服务器，就不太方便。这种情况下就完全用OpenSSL吧，上一篇文章《SSL-用OpenSSL生成证书文件》中已经做了介绍。不过keytool对于J2EE　AppServer是很有用的，它们就是用keystore存储证书链的。keystore的作用类似于windows存放证书的方式，不过跨平台了，^_^下面用Keytool生成CSR（Certificate Signing Request），并用OpenSSL生成CA签名的证书。

1.    准备
1)    在bin目录下新建目录 demoCA、demoCA/certs、demoCA/certs 、 demoCA/newcerts
2)    在demoCA建立一个空文件 index.txt
3)    在demoCA建立一个文本文件 serial, 没有扩展名，内容是一个合法的16进制数字，例如 0000
4)    配置环境变量PATH，加入%JAVA_HOME%/bin，本文用的JavaSDK1.6

2.    生成CA的自签名证书
openssl req -new -x509 -keyout ca.key -out ca.crt -config openssl.cnf

3.    生成server端证书
1)    生成KeyPair生成密钥对
keytool -genkey -alias tomcat_server -validity 365 -keyalg RSA -keysize 1024 -keypass 123456 -storepass 123456 -keystore server_keystore
输入common name时，要和服务器的域名保持一致。
2)    生成证书签名请求
keytool -certreq -alias tomcat_server -sigalg MD5withRSA -file tomcat_server.csr -keypass 123456 -storepass 123456 -keystore server_keystore
3)    用CA私钥进行签名，也可以到权威机构申请CA签名。
   openssl ca -in tomcat_server.csr -out tomcat_server.crt -cert ca.crt -keyfile ca.key -notext -config openssl.cnf
其中-notext表示不要把证书文件的明文内容输出到文件中去，否则在后面用keytool导入到keystore时会出错。
4)    导入信任的CA根证书到keystore
   keytool -import -v -trustcacerts -alias my_ca_root -file ca.crt -storepass 123456 -keystore server_keystore
5)    把CA签名后的server端证书导入keystore
keytool -import -v -alias tomcat_server -file tomcat_server.crt -storepass 123456 -keystore server_keystore
6)    查看server端证书
   keytool -list -v -keystore server_keystore
可以看到tomcat_server的证书链长度是2

4.    生成client端证书
1)    生成客户端CSR
   openssl genrsa -des3 -out tomcat_client.key 1024
openssl req -new -key tomcat_client.key -out tomcat_client.csr -config openssl.cnf
2)    用CA私钥进行签名，也可以到权威机构申请CA签名
openssl ca -in tomcat_client.csr -out tomcat_client.crt -cert ca.crt -keyfile ca.key -notext -config openssl.cnf
3)    生成PKCS12格式证书
openssl pkcs12 -export -inkey tomcat_client.key -in tomcat_client.crt -out tomcat_client.p12
4)    使用Keytool列出pkcs12证书的内容：
   keytool -rfc -list -keystore tomcat_client.p12 -storetype pkcs12

Eric_jiang 2014-07-22 14:42 发表评论

Java中的软引用，弱引用和虚引用

Eric_jiang — Fri, 21 Mar 2014 09:01:00 GMT

SoftReference、Weak Reference和PhantomRefrence分析和比较

　　本文将谈一下对SoftReference（软引用）、WeakReference（弱引用）和PhantomRefrence（虚引用）的理解，这三个类是对heap中java对象的应用，通过这个三个类可以和gc做简单的交互。

　　强引用：

　　除了上面提到的三个引用之外，还有一个引用，也就是最长用到的那就是强引用。例如：

Object o=new Object();
Object o1=o;

　　上面代码中第一句是在heap堆中创建新的Object对象通过o引用这个对象，第二句是通过o建立o1到new Object()这个heap堆中的对象的引用，这两个引用都是强引用.只要存在对heap中对象的引用，gc就不会收集该对象.如果通过如下代码：

o=null;
o1=null;

　　如果显式地设置o和o1为null，或超出范围，则gc认为该对象不存在引用，这时就可以收集它了。可以收集并不等于就一会被收集，什么时候收集这要取决于gc的算法，这要就带来很多不确定性。例如你就想指定一个对象，希望下次gc运行时把它收集了，那就没办法了，有了其他的三种引用就可以做到了。其他三种引用在不妨碍gc收集的情况下，可以做简单的交互。

　　heap中对象有强可及对象、软可及对象、弱可及对象、虚可及对象和不可到达对象。应用的强弱顺序是强、软、弱、和虚。对于对象是属于哪种可及的对象，由他的最强的引用决定。如下：

String abc=new String("abc"); //1
SoftReference abcSoftRef=new SoftReference(abc); //2
WeakReference abcWeakRef = new WeakReference(abc); //3
abc=null; //4
abcSoftRef.clear();//5

　　第一行在heap对中创建内容为“abc”的对象，并建立abc到该对象的强引用,该对象是强可及的。

　　第二行和第三行分别建立对heap中对象的软引用和弱引用，此时heap中的对象仍是强可及的。

　　第四行之后heap中对象不再是强可及的，变成软可及的。同样第五行执行之后变成弱可及的。

　　SoftReference（软引用）

　　软引用是主要用于内存敏感的高速缓存。在jvm报告内存不足之前会清除所有的软引用，这样以来gc就有可能收集软可及的对象，可能解决内存吃紧问题，避免内存溢出。什么时候会被收集取决于gc的算法和gc运行时可用内存的大小。当gc决定要收集软引用是执行以下过程,以上面的abcSoftRef为例：

　　1、首先将abcSoftRef的referent设置为null，不再引用heap中的new String("abc")对象。

　　2、将heap中的new String("abc")对象设置为可结束的(finalizable)。

　　3、当heap中的new String("abc")对象的finalize()方法被运行而且该对象占用的内存被释放， abcSoftRef被添加到它的ReferenceQueue中。

　　注:对ReferenceQueue软引用和弱引用可以有可无，但是虚引用必须有，参见：

Reference(T paramT, ReferenceQueueparamReferenceQueue)

　　被 Soft Reference 指到的对象，即使没有任何 Direct Reference，也不会被清除。一直要到 JVM 内存不足且没有 Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之用的。如此一来 SoftReference 不但可以把对象 cache 起来，也不会造成内存不足的错误（OutOfMemoryError）。我觉得 Soft Reference 也适合拿来实作 pooling 的技巧。

A obj = new A();
SoftRefenrence sr = new SoftReference(obj);

    //引用时
    if(sr!=null){
        obj = sr.get();
    }else{
        obj = new A();
        sr = new SoftReference(obj);
    }

　弱引用

　　当gc碰到弱可及对象，并释放abcWeakRef的引用，收集该对象。但是gc可能需要对此运用才能找到该弱可及对象。通过如下代码可以了明了的看出它的作用：

String abc=new String("abc");
WeakReference abcWeakRef = new WeakReference(abc);
abc=null;
System.out.println("before gc: "+abcWeakRef.get());
System.gc();
System.out.println("after gc: "+abcWeakRef.get());

　　运行结果：

　　before gc: abc
　　after gc: null

　　gc收集弱可及对象的执行过程和软可及一样，只是gc不会根据内存情况来决定是不是收集该对象。

　　如果你希望能随时取得某对象的信息，但又不想影响此对象的垃圾收集，那么你应该用 Weak Reference 来记住此对象，而不是用一般的 reference。

A obj = new A();

WeakReference wr = new WeakReference(obj);

obj = null;

//等待一段时间，obj对象就会被垃圾回收
　　...

　　if (wr.get()==null) {
　　System.out.println("obj 已经被清除了 ");
　　} else {
　　System.out.println("obj 尚未被清除，其信息是 "+obj.toString());
　　}
　　...
}

　　在此例中，透过 get() 可以取得此 Reference 的所指到的对象，如果返回值为 null 的话，代表此对象已经被清除。

　　这类的技巧，在设计 Optimizer 或 Debugger 这类的程序时常会用到，因为这类程序需要取得某对象的信息，但是不可以影响此对象的垃圾收集。

　　PhantomRefrence（虚引用）

　　虚顾名思义就是没有的意思，建立虚引用之后通过get方法返回结果始终为null，通过源代码你会发现，虚引用通向会把引用的对象写进referent，只是get方法返回结果为null。先看一下和gc交互的过程在说一下他的作用。

　　1 不把referent设置为null，直接把heap中的new String("abc")对象设置为可结束的(finalizable).

　　2 与软引用和弱引用不同，先把PhantomRefrence对象添加到它的ReferenceQueue中，然后在释放虚可及的对象。

　　你会发现在收集heap中的new String("abc")对象之前，你就可以做一些其他的事情。通过以下代码可以了解他的作用。

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;

public class Test {
    public static boolean isRun = true;

    public static void main(String[] args) throws Exception {
        String abc = new String("abc");
        System.out.println(abc.getClass() + "@" + abc.hashCode());
        final ReferenceQueue referenceQueue = new ReferenceQueue();
        new Thread() {
            public void run() {
                while (isRun) {
                    Object o = referenceQueue.poll();
                    if (o != null) {
                        try {
                            Field rereferent = Reference.class
                                    .getDeclaredField("referent");
                            rereferent.setAccessible(true);
                            Object result = rereferent.get(o);
                            System.out.println("gc will collect:"
                                    + result.getClass() + "@"
                                    + result.hashCode());
                        } catch (Exception e) {

                            e.printStackTrace();
                        }
                    }
                }
            }
        }.start();
        PhantomReference abcWeakRef = new PhantomReference(abc,
                referenceQueue);
        abc = null;
        Thread.currentThread().sleep(3000);
        System.gc();
        Thread.currentThread().sleep(3000);
        isRun = false;
    }

}

　　结果为：

　　class java.lang.String@96354
　　gc will collect:class java.lang.String@96354

Eric_jiang 2014-03-21 17:01 发表评论

Log4j每天生成日志文件和按文件大小生成日志文件

Eric_jiang — Wed, 12 Mar 2014 03:27:00 GMT

保存成日志文件形式的时候，大家经常会遇到一个问题：日志文件过大。上百兆的日志文件对查阅日志信息来说也是一个问题。所以我希望能够每天或每个月产生一个日志文件，这样文件不至于过大。或者根据日志文件大小来判断，超过规定大小，日志自动增加新文件。

在log4j中这两种方式的实现都很简单，只要在配置文件中设置即可。

一、按照一定时间产生日志文件,配置文件如下：

# Set root logger level to ERROR and its only appender to A1.

log4j.rootLogger=ERROR,R

# R is set to be a DailyRollingFileAppender.

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender

log4j.appender.R.File=backup.log

log4j.appender.R.DatePattern = '.'yyyy-MM-dd

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

以上配置是每天产生一个备份文件。其中备份文件的名字叫backup.log。

具体的效果是这样：当天的日志信息记录在backup.log文件中，前一天的记录在名称为 backup.log.yyyy-mm-dd 的文件中。

类似的，如果需要每月产生一个文件可以修改上面的配置：

将

log4j.appender.R.DatePattern = '.'yyyy-MM-dd

改为

log4j.appender.R.DatePattern = '.'yyyy-MM

二、根据日志文件大小自动产生新日志文件

配置文件内容如下：

# Set root logger level to ERROR and its only appender to A1.

log4j.rootLogger=ERROR,R

# R is set to be a RollingFileAppender.

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=backup.log

#log4j.appender.R.MaxFileSize=100KB

# Keep one backup file

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

其中：

#日志文件的大小

log4j.appender.R.MaxFileSize=100KB

# 保存一个备份文件

log4j.appender.R.MaxBackupIndex=1

Eric_jiang 2014-03-12 11:27 发表评论

通过GC输出分析内存泄露问题

Eric_jiang — Wed, 05 Mar 2014 09:09:00 GMT

SIP5.0以后服务的请求量爆发性增长，因此也暴露了原来没有暴露出来的问题。由于过去一般一个新版本发布周期在一个月左右，因此如果是小的内存泄露，在一个月之内重新发布以后也就看不出任何问题。

因此这阵子除了优化Memcache客户端和SIP框架逻辑以外其他依赖部分以外，对于内存泄露的压力测试也开始实实在在的做起来。经过这次问题的定位和解决以后，大致觉得对于一个大用户量应用要放心的话，那么需要做这么几步。

1.       在GC输出的环境下，大压力下做多天的测试。（可以在 JAVA_OPTS增加-verbose:gc -XX:+PrintGCDetails -XX:+HeapDumpOnOutOfMemoryError）

2.       检查GC输出日志来判断是否有内存泄露。（这部分后面有详细的实例说明）

3.       如果出现内存泄露问题，则使用jprofiler等工具来排查内存泄露点（之所以不一开始使用，因为jprofiler等工具对于压力测试有影响，使得大压力无法上去，也使问题不那么容易暴露）

4.       解决问题，并在重复2步骤。

这里对SIP在jdk1.5和jdk1.6下做压力测试的GC 日志来做一个实际的分析对比，通过对比来大致描述一下如何根据输出情况能够了解应用是否存在内存泄露问题。（这里的内存泄露问题就是在以前blog写过的jdk的concurrent包内LinkedBlockingQueue的poll方法存在比较严重的内存泄露，调用频率越高，内存泄露的越厉害）

两次压力测试都差不多都是两天，测试方案如下：

开始50个并发，每个并发每次请求完毕后休息0.1秒，10分钟后增长50个并发，按此规律增长到500并发。

旧版本SIP是在JDK1.5环境下完成的压力测试，

新版本SIP的JDK版本是1.6，

压力机和以前一样，是10.2.226.40，DELL1950，8CPU，8G内存。

压力机模拟发出对一个需要签名的API不断的调用请求。

看看两个Log的具体内容（内容很多截取部分做分析）

先说一下日志输出的结构：(1.6和1.5略微有一些不同，只是1.6对于时间统计更加细致)

[GC [: -> , secs] -> , secs]

GC收集器的名称

新生代在GC前占用的内存

新生代在GC后占用的内存

新生代局部收集时jvm暂停处理的时间

JVM Heap 在GC前占用的内存

JVM Heap 在GC后占用的内存

GC过程中jvm暂停处理的总时间

Jdk1.5 log：

启动时GC输出：

[GC [DefNew: 209792K->4417K(235968K), 0.0201630 secs] 246722K->41347K(498112K), 0.0204050 secs]

[GC [DefNew: 214209K->4381K(235968K), 0.0139200 secs] 251139K->41312K(498112K), 0.0141190 secs]

一句输出：

新生代回收前209792K，回收后4417K，回收数量205375K，Heap总量回收前246722K回收后41347K，回收总量205375K。这就表示100%的收回，没有任何新生代的对象被提升到中生代或者永久区（名字说的不一定准确，只是表达意思）。

第二句输出：

按照分析也就只是有1K内容被提升到中生代。

运行一段时间后：

[GC [DefNew: 210686K->979K(235968K), 0.0257140 secs] 278070K->68379K(498244K), 0.0261820 secs]

[GC [DefNew: 210771K->1129K(235968K), 0.0275160 secs] 278171K->68544K(498244K), 0.0280050 secs]

第一句输出：

         新生代回收前210686K，回收后979K，回收数量209707K，Heap总量回收前278070K回收后68379K，回收总量209691K。这就表示有16k没有被回收。

第二句输出：

         新生代回收前210771K，回收后1129K，回收数量209642K，Heap总量回收前278171K回收后68544K，回收总量209627K。这就表示有15k没有被回收。

比较一下启动时与现在的新生代占用内存情况和Heap使用情况发现Heap的使用增长很明显，新生代没有增长，而Heap使用总量增长了27M，这就表明可能存在内存泄露，虽然每一次泄露的字节数很少，但是频率很高，大部分泄露的对象都被升级到了中生代或者持久代。

又一段时间后：

[GC [DefNew: 211554K->1913K(235968K), 0.0461130 secs] 350102K->140481K(648160K), 0.0469790 secs]

[GC [DefNew: 211707K->2327K(235968K), 0.0546170 secs] 350275K->140921K(648160K), 0.0555070 secs]

第一句输出：

         新生代回收前211554K，回收后1913K，回收数量209641K，Heap总量回收前350102K回收后140481K，回收总量209621K。这就表示有20k没有被回收。

         分析到这里就可以看出每一次泄露的内存只有10几K，但是在大压力长时间的测试下，内存泄露还是很明显的，此时Heap已经增长到了140M，较启动时已经增长了100M。同时GC占用的时间越来越长。

后续的现象：

         后续观察日志会发现，Full GC的频率越来越高，收集所花费时间也是越来越长。（Full GC定期会执行，同时局部回收不能满足分配需求的情况下也会执行）。

[Full GC [Tenured: 786431K->786431K(786432K), 3.4882390 secs] 1022399K->1022399K(1022400K), [Perm : 36711K->36711K(98304K)], 3.4887920 secs]

java.lang.OutOfMemoryError: Java heap space

Dumping heap to java_pid7720.hprof ...

         出现这个语句表示内存真的被消耗完了。

Jdk1.6 log：

启动时GC的输出：

[GC [PSYoungGen: 221697K->31960K(229376K)] 225788K->36051K(491520K), 0.0521830 secs] [Times: user=0.26 sys=0.05, real=0.05 secs]

[GC [PSYoungGen: 228568K->32752K(229376K)] 232659K->37036K(491520K), 0.0408620 secs] [Times: user=0.21 sys=0.02, real=0.04 secs]

第一句输出：

         新生代回收前221697K，回收后31960K，回收数量189737K，Heap总量回收前225788K回收后36051K，回收总量189737K。100%被回收。

运行一段时间后输出：

[GC [PSYoungGen: 258944K->2536K(259328K)] 853863K->598135K(997888K), 0.0471620 secs] [Times: user=0.15 sys=0.00, real=0.05 secs]

[GC [PSYoungGen: 259048K->2624K(259328K)] 854647K->598907K(997888K), 0.0462980 secs] [Times: user=0.16 sys=0.02, real=0.04 secs]

第一句输出：

         新生代回收前258944K，回收后2536K，回收数量256408K，Heap总量回收前853863K回收后598135K，回收总量255728K。680K没有被回收，但这并不意味着就会产生内存泄露。同时可以看出GC回收时间并没有增加。

在运行一段时间后输出：

[GC [PSYoungGen: 258904K->2488K(259264K)] 969663K->713923K(1045696K), 0.0485140 secs] [Times: user=0.16 sys=0.01, real=0.04 secs]

[GC [PSYoungGen: 258872K->2448K(259328K)] 970307K->714563K(1045760K), 0.0473770 secs] [Times: user=0.16 sys=0.01, real=0.05 secs]

第一句输出：

         新生代回收前258904K，回收后2488K，回收数量256416K，Heap总量回收前969663K回收后713923K，回收总量255740K。676K没有被回收，同时总的Heap也有所增加。

         此时看起来好像和1.5的状况一样。但是查看了一下Full GC的执行还是400-500次GC执行一次，因此继续观察。

运行一天多以后输出：

[GC [PSYoungGen: 257016K->3304K(257984K)] 1019358K->766310K(1044416K), 0.0567120 secs] [Times: user=0.18 sys=0.01, real=0.06 secs]

[GC [PSYoungGen: 257128K->2920K(258112K)] 1020134K->766622K(1044544K), 0.0549570 secs] [Times: user=0.19 sys=0.00, real=0.05 secs]

可以发现Heap增长趋缓。

运行两天以后输出：

[GC [PSYoungGen: 256936K->3584K(257792K)] 859561K->606969K(1044224K), 0.0565910 secs] [Times: user=0.18 sys=0.01, real=0.06 secs]

[GC [PSYoungGen: 256960K->3368K(257728K)] 860345K->607445K(1044160K), 0.0553780 secs] [Times: user=0.18 sys=0.01, real=0.06 secs]

发现Heap反而减少了，此时可以对内存泄露问题作初步排除了。（其实在jdk1.6环境下用jprofiler来观察，对于concurrent那个内存泄露点的跟踪发现，内存的确还是会不断增长的，不过在一段时间后还是有回收，因此也就可以部分解释前面出现的情况）

总结：

         对于GC输出的观察需要分两个维度来看。一个是纵向比较，也就是一次回收对于内存变化的观察。一个是横向比较，对于长时间内存分配占用情况的比较，这部分比较需要较长时间的观察，不能仅仅凭短时间的几个抽样比较，因为对于抽样来说，Full GC前后的区别，运行时长的区别，资源瞬时占用的区别都会影响判断。同时要结合Full GC发生的时间周期，每一次GC收集所耗费的时间作为辅助判断标准。

         顺便说一下，Heap的 YoungGen,OldGen,PermGen的设置也是需要注意的，并不是越大越好，越大执行收集的时间越久，但是可能执行Full GC的频率会比较低，因此需要权衡。这些仔细的去了解一下GC的基础设计思想会更有帮助，不过一般用默认的也不错。还有就是可以配置一些特殊的GC，并行，同步等等，充分利用多CPU的资源。

         对于GC的优化可以通过现在很多图形工具来做，也可以类似于我这样采用最原始的分析方式，好处就是任何时间任何地点只要知道原理就可以分析无需借助外部工具。原始的总是最好的^_^。

Eric_jiang 2014-03-05 17:09 发表评论

探秘Java虚拟机 gc的监控

Eric_jiang — Wed, 05 Mar 2014 09:03:00 GMT

摘要: 1、Java虚拟机运行时的数据区2、常用的内存区域调节参数-Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制-Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制-Xmn：新生代的内存空间... 阅读全文

Eric_jiang 2014-03-05 17:03 发表评论

gc日志分析工具

Eric_jiang — Wed, 05 Mar 2014 08:58:00 GMT

性能测试排查定位问题，分析调优过程中，会遇到要分析gc日志，人肉分析gc日志有时比较困难，相关图形化或命令行工具可以有效地帮助辅助分析。

Gc日志参数

通过在tomcat启动脚本中添加相关参数生成gc日志

-verbose.gc开关可显示GC的操作内容。打开它，可以显示最忙和最空闲收集行为发生的时间、收集前后的内存大小、收集需要的时间等。

打开-xx:+ printGCdetails开关，可以详细了解GC中的变化。

打开-XX: + PrintGCTimeStamps开关，可以了解这些垃圾收集发生的时间，自JVM启动以后以秒计量。

最后，通过-xx: + PrintHeapAtGC开关了解堆的更详细的信息。

为了了解新域的情况，可以通过-XX:=PrintTenuringDistribution开关了解获得使用期的对象权。

-Xloggc:$CATALINA_BASE/logs/gc.log gc日志产生的路径

XX:+PrintGCApplicationStoppedTime // 输出GC造成应用暂停的时间

-XX:+PrintGCDateStamps // GC发生的时间信息

Gc日志

日志中显示了gc发生的时间，young区回收情况，整体回收情况，fullGC情况，回收所消耗时间等

常用JVM参数

分析gc日志后，经常需要调整jvm内存相关参数，常用参数如下

-Xms：初始堆大小，默认为物理内存的1/64(<1GB)；默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制

-Xmx：最大堆大小，默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制

-Xmn：新生代的内存空间大小，注意：此处的大小是（eden+ 2 survivor space)。与jmap -heap中显示的New gen是不同的。整个堆大小=新生代大小 + 老生代大小 + 永久代大小。
在保证堆大小不变的情况下，增大新生代后,将会减小老生代大小。此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8。

-XX:SurvivorRatio：新生代中Eden区域与Survivor区域的容量比值，默认值为8。两个Survivor区与一个Eden区的比值为2:8,一个Survivor区占整个年轻代的1/10。

-Xss：每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。应根据应用的线程所需内存大小进行适当调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。一般小的应用，如果栈不是很深，应该是128k够用的，大的应用建议使用256k。这个选项对性能影响比较大，需要严格的测试。和threadstacksize选项解释很类似,官方文档似乎没有解释,在论坛中有这样一句话:"-Xss is translated in a VM flag named ThreadStackSize”一般设置这个值就可以了。

-XX:PermSize：设置永久代(perm gen)初始值。默认值为物理内存的1/64。

-XX:MaxPermSize：设置持久代最大值。物理内存的1/4。

Gc日志分析工具

(1)GCHisto

http://java.net/projects/gchisto

直接点击gchisto.jar就可以运行，点add载入gc.log

统计了总共gc次数，youngGC次数，FullGC次数，次数的百分比，GC消耗的时间，百分比，平均消耗时间，消耗时间最小最大值等

统计的图形化表示

YoungGC,FullGC不同消耗时间上次数的分布图，勾选可以显示youngGC或fullGC单独的分布情况

整个时间过程详细的gc情况，可以对整个过程进行剖析

(2)GCLogViewer

http://code.google.com/p/gclogviewer/

点击run.bat运行

整个过程gc情况的趋势图，还显示了gc类型，吞吐量，平均gc频率，内存变化趋势等

Tools里还能比较不同gc日志

(3)HPjmeter

获取地址 http://www.hp.com/go/java
参考文档 http://www.javaperformancetuning.com/tools/hpjtune/index.shtml

工具很强大，但只能打开由以下参数生成的GC log， -verbose:gc -Xloggc:gc.log,添加其他参数生成的gc.log无法打开。

(4)GCViewer

http://www.tagtraum.com/gcviewer.html

这个工具用的挺多的，但只能在JDK1.5以下的版本中运行，1.6以后没有对应。

(5)garbagecat

http://code.google.com/a/eclipselabs.org/p/garbagecat/wiki/Documentation

其它监控方法

Jvisualvm动态分析jvm内存情况和gc情况，插件：visualGC

jvisualvm还可以heapdump出对应hprof文件（默认存放路径：监控的服务器 /tmp下），利用相关工具，比如HPjmeter可以对其进行分析

grep Full gc.log粗略观察FullGC发生频率

jstat –gcutil [pid] [intervel] [count]

jmap -histo pid可以观测对象的个数和占用空间
jmap -heap pid可以观测jvm配置参数，堆内存各区使用情况

jprofiler,jmap dump出来用MAT分析

如果要分析的dump文件很大的话，就需要很多内存，很容易crash。

所以在启动时，我们应该加上一些参数： Java –Xms512M –Xmx1024M –Xss8M

Eric_jiang 2014-03-05 16:58 发表评论

查看JVM所有可用的Java security provider

Eric_jiang — Thu, 27 Feb 2014 06:26:00 GMT

<%@ page import="java.security.Provider"%>

<%@ page import="java.security.Security"%>

<%@ page import="java.util.Set"%>

<%@ page import="java.util.Iterator"%>

Provider[] providers = Security.getProviders();

for (int i = 0; i < providers.length; i++) {

Provider provider = providers[i];

Provider name: <%=provider.getName()%>

Provider information: <%=provider.getInfo()%>

Provider version: <%=provider.getVersion()%>

Set entries = provider.entrySet();

Iterator iterator = entries.iterator();

while (iterator.hasNext()) {

Property entry:<%=iterator.next()%>

}

Eric_jiang 2014-02-27 14:26 发表评论

Java 中switch-case的注意地方

Eric_jiang — Mon, 06 Jan 2014 06:59:00 GMT

下面是switch的简单写法：

switch（A）{

case B;

}

A部分中的值必须是int型的，或者是能够自动进行饮试转换成int型的表达式。也就是说A部分可以是byte/short/char/int型的。

其次要强调的是该程序中B部分的值必须是单个byte/short/char/int型的值，或者是final型的变量。

但是final型的变量也是有要求的，也即是它必须是编译时的常量，怎么讲呢，看下面的程序段：

final int a = 0;

final int b;

第二个语句就是在编译时不能够被识别出值的变量，因为它没有初始化，当然，这条语句也是错误的。

所以总结case后的值可以是常数值或final型的值。

再看下面的程序段：

public class TestSwitch {

public static void main(String[] args){

byte a = 11;

switch(a){// C

case 11 : System.out.println(" 11 "); break;

case 225 : System.out.println(" 11 "); break;// D

}

该代码正确吗？答案是否定的。虽然在 C 处是合法的也即是byte型的a值可以出现在switch中，但是 D处的语句也即是第二个case后的值是225大小超过了byte的范围，所以是错误的。再就是case后的值不能出现重复。因此在使用中要注意。

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

再就是在使用switch-case中最容易忽视的就是忘记在每个case后处理完后忘记写上break；语句。那它带来的后果是什么呢，下面小程序段会告诉你：

public class TestSwitchCase {

public static void main(String[] args){

byte a = 2;

switch(a){

case 1 : System.out.println(" A ");

case 2 : System.out.println(" B ");

case 3 : System.out.println(" C ");

case 4 : System.out.println(" D ");

default : System.out.println(" default ");

}

=========输出结果为:

default

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

看到了吗？连default都执行，注意结束符break;就OK了。

Eric_jiang 2014-01-06 14:59 发表评论

java中的数组长度问题

Eric_jiang — Mon, 06 Jan 2014 03:40:00 GMT

摘要: 之前对java中的数组一直是一知半解，特别是数组中的长度问题。今天对这个问题也算是小有理解，算是对java数组的有了更进一步的了解吧。不说了，先来例子再说： [java] view plaincopypackage com.test; public class Test {&nbs... 阅读全文

Eric_jiang 2014-01-06 11:40 发表评论

Checked Exception与Runtime Exception 的区别

Eric_jiang — Mon, 06 Jan 2014 03:33:00 GMT

java里有个很重要的特色是Exception ，也就是说答应程序产生例外状况。而在学Java 的时候，我们也只知道Exception 的写法，却未必真能了解不同种类的Exception 的区别。

　　首先，您应该知道的是Java 提供了两种Exception 的模式，一种是执行的时候所产生的Exception (Runtime Exception)，另外一种则是受控制的Exception (Checked Exception)。

　　所有的Checked Exception 均从java.lang.Exception 继续而来，而Runtime Exception 则继续java.lang.RuntimeException 或java.lang.Error (实际上java.lang.RuntimeException 的上一层也是java.lang.Exception)。

　　当我们撰写程序的时候，我们很可能会对选择某种形式的Exception 感到困扰，到底我应该选择Runtime Exception 还是Checked Exception ？

　　其实，在运作上，我们可以通过Class 的Method 如何产生某个Exception以及某个程序如何处理这个被产生来的Exception 来了解它们之间的差异。

首先我们先建立一个Exception

public class CException extends Exception

{

public CException() {}

public CException(String message)

{

super(message);

}

然后我们撰写一个可能产生 CException 的 Class

public class testException

{

public void method1() throws CException

{

throw new CException("Test Exception");

}

public void method2(String msg)

{

if(msg == null)

{

throw new NullPointerException("Message is null");

}

public void method3() throws CException

{

method1();

}

// 以下省略

// ...

}

　　在这三个method 中，我们看到了method1 和method2 的程序码内都会产生Exception，但method3 的程序码中(大括号内)，并没产生Exception，但在method3 的定义中，暗示了这个method 可能产生CException。

呼叫method1() 的程序，必须将method1() 包含在try 与catch 中，如：

public class runtest

{

// ....

public static void main(String argv[])

{

testException te = new testException();

try

{

te.method1();

}

catch(CException ce)

{

// ....

}

// ...

}

　　虽然包含在try 与catch 中，并不表示这段程序码一定会收到CException，但它的用意在于提醒呼叫者，执行这个method 可能产生的意外，而使用者也必须要能针对这个意外做出相对应的处理方式。

　　当使用者呼叫method2() 时，并不需要使用try 和catch 将程序码包起来，因为method2 的定义中，并没有throws 任何的Exception ，如：

public class runtest

{

// ....

public static void main(String argv[])

{

testException te = new testException();

// 不会产生 Exception

te.method2("Hello");

// 会产生 Exception

te.method2(null);

}

// ...

}

　　程序在执行的时候，也不见得会真的产生NullPointerException ，这种Exception 叫做runtime exception 也有人称为unchecked exception ，产生Runtime Exception 的method (在这个范例中是method2) 并不需要在宣告method 的时候定义它将会产生哪一种Exception 。

在testException 的method3() 中，我们看到了另外一种状况，也就是method3里呼叫了method1() ，但却没有将method1 包在try 和catch 之间。相反，在method3() 的定义中，它定义了CException，实际上就是假如method3 收到了CException ，它将不处理这个CException ，而将它往外丢。当然，由于method3 的定义中有throws CException ，因此呼叫method3 的程序码也需要有try catch 才行。

　　因此从程序的运作机制上看，Runtime Exception与Checked Exception 不一样，然而从逻辑上看，Runtime Exception 与Checked Exception 在使用的目的上也不一样。

　　一般而言，Checked Exception 表示这个Exception 必须要被处理，也就是说程序设计者应该已经知道可能会收到某个Exception(因为要try catch住) ，所以程序设计者应该能针对这些不同的Checked Exception 做出不同的处理。

Eric_jiang 2014-01-06 11:33 发表评论

Java定义二维数组的几种写法

Eric_jiang — Fri, 03 Jan 2014 03:16:00 GMT

Java定义二维数组的几种写法

//写法1：先声明，然后new申请空间，最后赋值

　　class numthree

　　{

　　public static void main(String[] args)

　　{

　　float[][] numthree; //定义一个float类型的2维数组

　　numthree=new float[5][5]; //为它分配5行5列的空间大小

　　numthree[0][0]=1.1f; //通过下标索引去访问 1行1列=1.1

　　numthree[1][0]=1.2f; // 2行1列=1.2

　　numthree[2][0]=1.3f; // 3行1列=1.3

　　numthree[3][0]=1.4f; // 4行1列=1.4

　　numthree[4][0]=1.5f; // 5行1列=1.5

　　System.out.println(numthree[0][0]); //打印换行输出喽

　　System.out.println(numthree[1][0]);

　　System.out.println(numthree[2][0]);

　　System.out.println(numthree[3][0]);

　　System.out.println(numthree[4][0]);

　　}

//写法2：定义的同时分配空间大小

　　class numfour

　　{

　　public static void main(String[] args)

　　{

　　short[][] numfour=new short[5][8]; //定义一个short类型的数组同时为它分配5行8列的空间大小

　　numfour[0][7]=10;

　　numfour[1][6]=20;

　　numfour[2][5]=30;

　　numfour[3][4]=40;

　　numfour[4][3]=50;

　　System.out.println(numfour[0][7]);

　　System.out.println(numfour[1][6]);

　　System.out.println(numfour[2][5]);

　　System.out.println(numfour[3][4]);

　　System.out.println(numfour[4][3]);

　　}

//写法3：不规则数组

　　class numfive

　　{

　　public static void main(String[] args)

　　{

　　long[][] numfive=new long[5][]; //定义一个long类型的不规则数组

　　numfive[0]=new long[5]; //为第1行分配5列

　　numfive[1]=new long[6]; //为第2行分配6列

　　numfive[2]=new long[7]; //为第3行分配7列

　　numfive[3]=new long[8]; //为第4行分配8列

　　numfive[4]=new long[9]; //为第5行分配9列

　　numfive[0][4]=10000000000L; //1行5列=10000000000

　　numfive[1][5]=20000000000L; //2行6列=20000000000

　　numfive[2][6]=30000000000L; //3行7列=30000000000

　　numfive[3][7]=40000000000L; //4行8列=40000000000

　　numfive[4][8]=50000000000L; //5行9列=50000000000

　　System.out.println(numfive[0][4]); //打印换行输出喽

　　System.out.println(numfive[1][5]);

　　System.out.println(numfive[2][6]);

　　System.out.println(numfive[3][7]);

　　System.out.println(numfive[4][8]);

　　System.out.println(numfive[4][7]); //打印输出一个没有定义数组元素的数组 java会自动将他初始化值为0

　　}

//写法4：定义的同时赋初始值

　　class numsix

　　{

　　public static void main(String[] args)

　　{

　　double[][] numsix={{1.111D,2.222D,3.333D},{4.444D,5.555D,6.666D}}; //定义double型的数组分配3行3列的空间同时赋值

　　System.out.println(numsix[0][0]); //打印换行输出1行1列=1.111

　　System.out.println(numsix[1][1]); //打印换行输出2行2列=5.555

　　}

//写法5：定义不规则的2维数组同时赋初始值

　　class numseven

　　{

　　public static void main(String[] args)

　　{

　　int[][] numseven=new int[][]{{10,20,30},{40,50},{60}}; //没什么好说的如果你在看不懂那就别学了！

　　System.out.println(numseven[0][2]);

　　System.out.println(numseven[1][1]);

　　System.out.println(numseven[0][0]);

　　}

//写法6：定义不规则的2维数组同时赋初始值

　　class numeight

　　{

　　public static void main(String[] args)

　　{

　　int[][] numeight={{100,200,300,400},{500,600,700,800},{900,1000,1100,1200,1300}};

　　System.out.println(numeight[0][2]);

　　System.out.println(numeight[1][2]);

　　System.out.println(numeight[2][1]);

　　}

Eric_jiang 2014-01-03 11:16 发表评论

谈java的import

Eric_jiang — Fri, 03 Jan 2014 02:25:00 GMT

程序员可以使用两种import语句：

　　单类型导入(single-type-import)，例如import java.io.File;

　　按需类型导入(type-import-on-demand)，例如 import java.io.*;

　　关于这两种导入类型大家各有所爱，众说纷纭。这里分析一下这两种导入类型的大致工作原理供大家参考。

　　单类型导入比较好理解，仅仅导入一个public类或者接口。而对于按需类型导入，有人误解为导入一个包下的所有类，其实不然，看名字就知道，他只会按需导入，也就是说它并非导入整个包，而仅仅导入当前类需要使用的类。

　　既然如此是不是就可以放心的使用按需类型导入呢?非也，非也。因为单类型导入和按需类型导入对类文件的定位算法是不一样的。

　　java编译器会从启动目录(bootstrap)，扩展目录(extension)和用户类路径下去定位需要导入的类，而这些目录仅仅是给出了类的顶层目录。编译器的类文件定位方法大致可以理解为如下公式：

　　顶层路径名 \ 包名 \ 文件名.class = 绝对路径

　　对于单类型导入很简单，因为包明和文件名都已经确定，所以可以一次性查找定位。

　　对于按需类型导入则比较复杂，编译器会把包名和文件名进行排列组合，然后对所有的可能性进行类文件查找定位。例如：

　　package com;

　　import java.io.*;

　　import java.util.*;

　　当你的类文件中用到了File类，那么可能出现File类的地方如下:

　　1、File \ File类属于无名包，就是说File类没有package语句，编译器会首先搜索无名包

　　2、com.File \ File类属于当前包

　　3、java.lang.File \编译器会自动导入java.lang包

　　4、java.io.File

　　5、java.util.File

　　需要注意的地方就是，编译器找到java.io.File类之后并不会停止下一步的寻找，而要把所有的可能性都查找完以确定是否有类导入冲突。假设此时的顶层路径有三个，那么编译器就会进行3*5=15次查找。

　　了解以上原理之后，我们可以得出这样的结论：按需类型导入是绝对不会降低Java代码的执行效率的，但会影响到Java代码的编译速度。

　　查看JDK的源代码就知道SUN的软件工程师一般不会使用按需类型导入。因为使用单类型导入至少有以下两点好处：

　　1。提高编译速度。

　　2。避免命名冲突。(例如：当你import java.awt.*;import java.util.*后，使用List的时候编译器将会出编译错误)

　　当然，使用单类型导入会使用你的import语句看起来很长。

Eric_jiang 2014-01-03 10:25 发表评论

Thread.start()与Thread.run()有什么区别？

Eric_jiang — Fri, 03 Jan 2014 02:18:00 GMT

Thread.start()与Thread.run()有什么区别？

run()方法，用于封装线程运行的任务代码。直接用创建的线程对象调用，并没有产生新的线程，仅仅是当前正在运行的线程(如，主线程)在执行run方法.

start()方法，共有两个作用，1，开启了当前线程，也就是说，当前程序又多了一条执行路径和当前线程(主线程)并发执行。而run()方法会被新开启的线程运行。2，调用线程的run（）方法。

Eric_jiang 2014-01-03 10:18 发表评论

Java中ArrayList和LinkedList区别

Eric_jiang — Fri, 03 Jan 2014 02:12:00 GMT

一般大家都知道ArrayList和LinkedList的大致区别：
     1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
     2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
     3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

ArrayList和LinkedList是两个集合类，用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么ArrayList和LinkedList在性能上有什么差别呢？什么时候应该用ArrayList什么时候又该用LinkedList呢？

一．时间复杂度
首先一点关键的是，ArrayList的内部实现是基于基础的对象数组的，因此，它使用get方法访问列表中的任意一个元素时(random access)，它的速度要比LinkedList快。LinkedList中的get方法是按照顺序从列表的一端开始检查，直到另外一端。对LinkedList而言，访问列表中的某个指定元素没有更快的方法了。
假设我们有一个很大的列表，它里面的元素已经排好序了，这个列表可能是ArrayList类型的也可能是LinkedList类型的，现在我们对这个列表来进行二分查找(binary search)，比较列表是ArrayList和LinkedList时的查询速度，看下面的程序：

package com.mangocity.test;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class TestList ...{
public static final int N=50000;
public static List values;
static...{
Integer vals[]=new Integer[N];
Random r=new Random();
for(int i=0,currval=0;i
vals=new Integer(currval);
currval+=r.nextInt(100)+1;
}
values=Arrays.asList(vals);
}
static long timeList(List lst)...{
long start=System.currentTimeMillis();
for(int i=0;i
int index=Collections.binarySearch(lst, values.get(i));
if(index!=i)
System.out.println("***错误***");
}
return System.currentTimeMillis()-start;
}
public static void main(String args[])...{
System.out.println("ArrayList消耗时间："+timeList(new ArrayList(values)));
System.out.println("LinkedList消耗时间："+timeList(new LinkedList(values)));
}
}

我得到的输出是：ArrayList消耗时间：15
LinkedList消耗时间：2596
这个结果不是固定的，但是基本上ArrayList的时间要明显小于LinkedList的时间。因此在这种情况下不宜用LinkedList。二分查找法使用的随机访问(random access)策略，而LinkedList是不支持快速的随机访问的。对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的。而相应的，在ArrayList中进行随机访问所消耗的时间是固定的。
这是否表明ArrayList总是比LinkedList性能要好呢？这并不一定，在某些情况下LinkedList的表现要优于ArrayList，有些算法在LinkedList中实现时效率更高。比方说，利用Collections.reverse方法对列表进行反转时，其性能就要好些。
看这样一个例子，加入我们有一个列表，要对其进行大量的插入和删除操作，在这种情况下LinkedList就是一个较好的选择。请看如下一个极端的例子，我们重复的在一个列表的开端插入一个元素：

Java代码  
package com.mangocity.test;   
  
import java.util.*;   
public class ListDemo {   
     static final int N=50000;   
     static long timeList(List list){   
     long start=System.currentTimeMillis();   
     Object o = new Object();   
     for(int i=0;i
         list.add(0, o);   
     return System.currentTimeMillis()-start;   
     }   
     public static void main(String[] args) {   
         System.out.println("ArrayList耗时："+timeList(new ArrayList()));   
         System.out.println("LinkedList耗时："+timeList(new LinkedList()));   
     }   
}   

这时我的输出结果是：ArrayList耗时：2463

LinkedList耗时：15
这和前面一个例子的结果截然相反，当一个元素被加到ArrayList的最开端时，所有已经存在的元素都会后移，这就意味着数据移动和复制上的开销。相反的，将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录，然后调整两个连接。在LinkedList的开端增加一个元素的开销是固定的，而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。

二．空间复杂度
在LinkedList中有一个私有的内部类，定义如下：

Java代码  
private static class Entry {   
         Object element;   
         Entry next;   
         Entry previous;   
     }   

每个Entry对象reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。
ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。

三．总结
ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下：
1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

Eric_jiang 2014-01-03 10:12 发表评论

Java 默认访问权限

Eric_jiang — Fri, 03 Jan 2014 01:56:00 GMT

如果一个类的成员没有任何权限修饰，那么它门就是缺省包访问权限，用friendly来表示，注意friendly不是Java中的关键字，这里是个人喜欢的方式用它表示而已，有人喜欢说是default或者是pacakge，只是帮助理解。同一个包内其它类可以访问，但包外就不可以。对于同一个文件夹下的、没有用package的classes，Java会自动将这些classes初见为隶属于该目录的default package，可以相互调用class中的friendly成员。如以下两个class分别在同一个文件夹的两个文件中，虽然没有引入package，但隶属于相同的default package。

　　 class Sundae{

　　 //以下两个方法缺省为friendly

　　 Sundae(){}

　　 Void f() {System.out.println(“Sundae.f()”);

　　 }

　　 public class IceCream{

　　 public static void main(String[] args){

　　 Sundae x = new Sundae();

　　 x.f();

　　 }

对于类来说：同一个包中的类可以用。总之，类只可以声明为public或者friendly。

Eric_jiang 2014-01-03 09:56 发表评论

XML解析器SAX，DOM，JDOM，JAXP的优缺点

Eric_jiang — Thu, 02 Jan 2014 08:12:00 GMT

DOM 构建整个文档驻留内存的树。如果文档很大，就会要求有极大的内存。

DOM 创建表示原始文档中每个东西的对象，包括元素、文本、属性和空格。如果您只需关注原始文档的一小部分，那么创建那些永远不被使用的对象是极其浪费的。

DOM 解析器必须在您的代码取得控制权之前读取整个文档。对于非常大的文档，这会引起显著的延迟。

SAX 解析器向您的代码发送事件。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，它会告诉您。您可以决定什么事件对您重要，而且可以决定要创建什么类型的数据结构以保存来自这些事件的数据。如果您没有显式地保存来自某个事件的数据，它就被丢弃。

SAX 解析器根本不创建任何对象，它只是将事件传递给您的应用程序。如果希望基于那些事件创建对象，这将由您来完成。

SAX 解析器在解析开始的时候就开始发送事件。当解析器发现文档开始、元素开始和文本等时，代码会收到一个事件。您的应用程序可以立即开始生成结果；您不必一直等到整个文档被解析完毕。更妙的是，如果您只查找文档中某些内容，代码一旦找到所要找的东西就可以抛出一个异常。该异常会停止 SAX 解析器，然后代码用它找到的数据做它需要做的任何事。

SAX 事件是无状态的。当 SAX 解析器在 XML 文档中发现文本时，它就向您的代码发送一个事件。该事件仅仅给您发现的文本；它不告诉您什么元素包含那个文本。如果您想知道这一点，则必须自己编写状态管理代码。

SAX 事件不是持久的。如果应用程序需要一个数据结构来对 XML 文档建模，则必须自己编写那样的代码。如果您需要从 SAX 事件访问数据，并且没有把那个数据存储在代码中，那么您不得不再次解析该文档。

SAX 不是由一个集中管理的组织控制的。尽管到目前为止这还没有引起什么问题，但如果 SAX 是由象 W3C 这样的一个组织控制的话，有些开发人员会感觉更自在。

JDOM 的主要特性是它极大地减少了您必须编写的代码数量。JDOM 应用程序的长度通常是 DOM 应用程序的三分之一，大约是 SAX 应用程序的一半。

JAXP为使用 DOM、SAX 和 XSLT 处理 XML 文档提供公共接口

综述：SAX在对速度要求特别快，或机器内存不足的情况下使用；DOM在对解析速度要求不高，或xml文档不是很大的情况下使用；对于频繁修改xml文件内容的情况，建议用dom，因为sax每次都要从头到尾遍历节点，而且不易实现。虽然SAX表现较好，这要依赖于它特定的解析方式，一个 SAX 检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

Eric_jiang 2014-01-02 16:12 发表评论

ARRAYLIST VECTOR LINKEDLIST 区别与用法

Eric_jiang — Thu, 02 Jan 2014 08:03:00 GMT

ArrayList 和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

Eric_jiang 2014-01-02 16:03 发表评论

Java中HashMap,LinkedHashMap,TreeMap的区别

Eric_jiang — Thu, 02 Jan 2014 07:56:00 GMT

java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap

Map主要用于存储健值对，根据键得到值，因此不允许键重复(重复了覆盖了),但允许值重复。

Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。

Hashtable与 HashMap类似,它继承自Dictionary类，不同的是:它不允许记录的键或者值为空;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢。

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。

TreeMap实现SortMap接口，能够把它保存的记录根据键排序,默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。

一般情况下，我们用的最多的是HashMap,HashMap里面存入的键值对在取出的时候是随机的,它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。

TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。

LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现,它还可以按读取顺序来排列，像连接池中可以应用。

Eric_jiang 2014-01-02 15:56 发表评论

String,StringBuffer与StringBuilder的区别??

Eric_jiang — Thu, 02 Jan 2014 07:48:00 GMT

String 字符串常量

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

简要的说， String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffer 类则结果就不一样了，每次结果都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer 快的：

String S1 = “This is only a” + “ simple” + “ test”;

StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个

String S1 = “This is only a” + “ simple” + “test”; 其实就是：

String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

String S2 = “This is only a”;

String S3 = “ simple”;

String S4 = “ test”;

String S1 = S2 +S3 + S4;

这时候 JVM 会规规矩矩的按照原来的方式去做

在大部分情况下 StringBuffer > String

StringBuffer

Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容是“start”的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含“starlet”。

在大部分情况下 StringBuilder > StringBuffer

java.lang.StringBuilde

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

Eric_jiang 2014-01-02 15:48 发表评论