package testPackage;

class Test {

public static void main(String[] args) {

String hello = "Hello", lo = "lo";

System.out.print((hello == "Hello") + " ");

System.out.print((Other.hello == hello) + " ");

System.out.print((other.Other.hello == hello) + " ");

System.out.print((hello == ("Hel"+"lo")) + " ");

System.out.print((hello == ("Hel"+lo)) + " ");

System.out.println(hello == ("Hel"+lo).intern());

}

}

class Other { static String hello = "Hello"; }

        and the compilation unit:

package other;

public class Other { static String hello = "Hello"; }

 正确答案：true true true true false true

This example illustrates six points:

• Literal strings within the same class (§8) in the same package (§7) represent references to the same String object (§4.3.1).
• Literal strings within different classes in the same package represent references to the same String object.
• Literal strings within different classes in different packages likewise represent references to the same String object.
• Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
• Strings computed at run time are newly created and therefore distinct.
• The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

呵呵，我是没有能够全部答对

另外一篇关于String intern的文章：

http://laiseeme.javaeye.com/blog/102442

作者：来自ITPUB论坛  2008-01-24

向大家介绍一种很不错，也是Linux中的权限管理算法。

　　定义a^b为：a的b次方

　　假如，我们为每一个操作设定一个唯一的整数值，比如：

　　删除A---0

　　修改A---1

　　添加A---2

　　删除B---3

　　修改B---4

　　添加B---5

　　。。。

　　理论上可以有N个操作，这取决于你用于储存用户权限值的数据类型了。

　　这样，如果用户有权限：添加A---2;删除B---3;修改B---4

　　那用户的权限值 purview =2^2+2^3+2^4=28，也就是2的权的和了

　　化成二进制可以表示为11100

　　如果要验证用户是否有删除B的权限，就可以通过位与运算来实现。

　　在Java里，位与运算运算符号为&

　　即是：int value = purview &((int)Math.pow(2,3));

　　你会发现，当用户有操作权限时，运算出来的结果都会等于这个操作需要的权限值!

　　原理：

　　位与运算，顾名思义就是对位进行与运算：

　　以上面的式子为例：purview & 2^3 也就是　28&8

　　将它们化成二进制有

　　11100

　　& 01000

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

　　01000 == 8(十进制)　==　2^3

　　同理，如果要验证是否有删除A---0的权限

　　可以用：purview &((int)Math.pow(2,0));

　　即：

　　11100

　　& 00001

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

　　00000 == 0(十进制)　　!=　2^0

　　这种算法的一个优点是速度快。可以同时处理N个权限，设置N种角色.

　　如果想验证是否同时有删除A---0和删除B---3的权限

　　可以用purview&(2^0+2^3)==(2^0+2^3)?true:false;

　　设置多角色用户。根据权限值判断用户的角色。。。

　　下面提供一个java的单操作权限判断的代码：

　　//userPurview是用户具有的总权限

//optPurview是一个操作要求的权限为一个整数(没有经过权的!)



public static boolean checkPower(int userPurview, int optPurview){

int purviewValue = (int)Math.pow(2, optPurview);

return (userPurview & purviewValue) == purviewValue;

}

　　当然，多权限的验证只要扩展一下就可以了。

　　几点注意事项：首先，一个系统可能有很多的操作，因此，请建立数据字典，以便查阅，修改时使用。其次，如果用数据库储存用户权限，请注意数值的 有效范围。操作权限值请用唯一的整数!Java的int类型最多可以储存11个权限和.如果超过，可以选择其它数据类型，而且建议不同模块，使用多个权限 变量.

• byte uses 1 byte while int uses 4 bytes.
• integer literals like "45" are of int not byte.If you want a literal to be a byte, you have to cast it: "(byte)45".
• When values are promoted as part of an expression or as parameters to a method call, they may be promoted to int, but never to byte.
• Many parts of the Java language used int, but none of them use byte. For example, the length of an array is an int.

byte类型的使用场合：

由于不同的机器对于多字节数据(int 就是采用4个byte保存数据）的存储方式不同,可能是 低字节向高字节存储,也可能是从高字节向低字节存储,这样,在 分析网络协议或文件格时,为了解决不同机器上的字节存储顺序问题,用byte类型来表示数据是合适的。而通常情况下,由于其表示的数据范围很小,容易造成溢出,应避免使用。

/**
     * Convert  an int to a byte array
     *
     * @param value int
     * @return byte[]
     */
public static byte[] intToByteArray(int value) {
        byte[] b = new byte[4];

     // 使用4个byte表示int
        for (int i = 0; i < 4; i++) {
            int offset = (b.length - 1 - i) * 8;  // 偏移量
            b[i] = (byte) ((value >> offset) & 0xFF); //每次取8bit
        }
        return b;
    }

    /**
     * Convert the byte array to an int starting from the given offset.
     *
     * @param b The byte array
     * @param offset The array offset,如果byte数组长度就是4，则该值为0
     * @return The integer
     */  

public static int byteArrayToInt(byte[] b, int offset) {
        int value = 0;
        for (int i = 0; i < b.length; i++) {
            int shift = (b.length - 1 - i) * 8;
            value += (b[i + offset] & 0xFF) << shift;
        }
        return value;
    }

public static void main(String[] args) {
        byte[] bb=intToByteArray(255);
        for(int i=0;i<bb.length;i++){
            System.out.println(bb[i]);
        }       
    }

输出结果：

0
0
0
-1

这是补码的形式（10000001），取反加1可以得到源码（11111111）

• byte: The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.
• short: The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.
• int: The int data type is a 32-bit signed two's complement integer. It has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive). For integral values, this data type is generally the default choice unless there is a reason (like the above) to choose something else. This data type will most likely be large enough for the numbers your program will use, but if you need a wider range of values, use long instead.
• long: The long data type is a 64-bit signed two's complement integer. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive). Use this data type when you need a range of values wider than those provided by int.
• float: The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.
• double: The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.
• boolean: The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.
• char: The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

java 位操作符：

取反：~x
- flips each bit to the opposite value.

与操作：AND

x & y
- AND operation between the corresponding bits in x and y.

或操作：OR
x | y
- OR operation between the corresponding bits in x and y.

异或操作：XOR
x ^ y
- XOR operation between the corresponding bits in x and y.

左移操作：Shift left
x << y
- shifts x to the left by y bits. The high order bits are lost while zeros fill the right bits.

将x左移y位，移动过程中，高位会丢失

有符号数右移操作：Shift Right - Signed
x >> y
- shifts x to the right by y bits. The low order bits are lost while the sign bit value (0 for positive numbers, 1 for negative) fills in the left bits.

无符号数右移：Shift Right - Unsigned
x >>> y
- shifts x to the right by y bits. The low order bits are lost while zeros fill in the left bits regardless of the sign.

例子：

下面的例子显示如何将一个int数组通过移位操作压缩到一个int内保存，其原理是在java语言中，int类型使用4 bytes来保存，因此对于需要压缩的int数组，其中的每一个int值的大小不能超过255（2的8次方-1），因此这只是一个实例：

  int [] aRGB = {0x56, 0x78, 0x9A, 0xBC};   // 是用16进制保存的4种颜色值
  int color_val = aRGB[3];   
  color_val = color_val | (aRGB[2] << 8);  // 为了压缩，需要放置到color_val值的第二个字节位置上：将aRGB[2] 左移到第二个byte，同时与color_val进行或操作，下面同理
  color_val = color_val | (aRGB[1] << 16);  
  color_val = color_val | (aRBG[0] << 24);

操作完的结果是56 78 9A BC

如果要从colorVal 还原为int数组，或者得到数组中的某个值，只需要对colorVal 进行相应的右移操作即可：

  int alpha_val = (colorVal >>> 24) & 0xFF;
  int red_val   = (colorVal >>> 16) & 0xFF;
  int green_val = (colorVal >>>  8) & 0xFF;
  int blue_val  =  colorVal & 0xFF;

参考资料：

Bits in Java

http://tech.it168.com/j/n/2007-03-05/200703051354348.shtml

PA作为一项对象持久化的标准，不但可以获得Java EE应用服务器的支持，还可以直接在Java SE中使用。

介绍得很清楚的文章

JPA概述

JPA(Java Persistence API)作为Java EE 5.0平台标准的ORM规范，将得到所有Java EE服务器的支持。Sun这次吸取了之前EJB规范惨痛失败的经历，在充分吸收现有ORM框架的基础上，得到了一个易于使用、伸缩性强的ORM规范。从目前的开发社区的反应上看，JPA受到了极大的支持和赞扬，JPA作为ORM领域标准化整合者的目标应该不难实现。 

JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中，图 1很好地描述了JPA的结构：

Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用的对象持久化的开发工作；其二，Sun希望整合对ORM技术，实现天下归一。 

JPA由EJB 3.0软件专家组开发，作为JSR-220实现的一部分。但它不囿于EJB 3.0，你可以在Web应用、甚至桌面应用中使用。JPA的宗旨是为POJO提供持久化标准规范，由此可见，经过这几年的实践探索，能够脱离容器独立运行，方便开发和测试的理念已经深入人心了。目前Hibernate 3.2、TopLink 10.1.3以及OpenJpa都提供了JPA的实现。

JPA的总体思想和现有Hibernate、TopLink，JDO等ORM框架大体一致。总的来说，JPA包括以下3方面的技术： 

• ORM映射元数据，JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中； 
• JPA 的API，用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。 
• 查询语言，这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。 

为了备份blog，简单写了一个适用于blogjava等metaWeblog的blog备份工具，功能：

（1）备份post的正文到本地

（2）备份正文中的图片、css文件到本地

（3）基于以上两的步骤，修改相关的链接，实现本地脱机浏览

想到了但是未实现的功能：

（1）评论无法保存

（2）合适的话可以考虑以Eclipes RCP形式包装

一、实现原理

（1）获取post的方法：使用MetaWeblog提供的API接口

metaWeblog.getRecentPosts (blogid, username, password, numberOfPosts) returns array of structs,

Each struct represents a recent weblog post, containing the same information that a call to metaWeblog.getPost would return.

If numberOfPosts is 1, you get the most recent post. If it's 2 you also get the second most recent post, as the second array element. If numberOfPosts is greater than the number of posts in the weblog you get all the posts in the weblog.

(2) 使用正则表达式分析获取下来的post，解析出post中包含的css和图片文件的地址，执行两步操作

• 根据地址，抓取图片保存到本地
• 修改post中的地址为本地保存地址

(3) 使用xml-rpc来简化远程调用过程的编程

二、主要的代码

Java's java.util.regex 包包括：Pattern类、Matcher类、MatchResult接口和PatternSyntaxException异常：

• Pattern 对象代表了编译了的正则表达式（A compiled representation of a regular expression.）。
• Matcher ，An engine that performs match operations on a character sequence by interpreting a Pattern.
• MatchResult接口：The result of a match operation.
• PatternSyntaxException对象，描述非法的regex patterns，Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

 同时还需要了解是CharSequence，JDK 1.4定义的新的接口，它提供了String和StringBuffer这两个类的字符序列的抽象

interface CharSequence {



charAt(int i);



length();



subSequence(int start, int end);



toString();



}

为了实现这个新的CharSequence接口，String，StringBuffer以及CharBuffer都作了修改，很多的正则表达式的操作都要拿CharSequence作参数。

Matcher类的几个重要的方法：

• boolean matches()：Pattern匹配整个字符串
• boolean lookingAt()：Pattern匹配字符串的开头
• boolean find()：发现CharSequence里的，与pattern相匹配的多个字符序列
  boolean find(int start)：告诉方法从参数start位置开始查找

group的概念

Group是指里用括号括起来的，能被后面的表达式调用的正则表达式。

Group 0 表示整个表达式，group 1表示第一个被括起来的group，以此类推。所以；

A(B(C))D

里面有三个group：group 0是ABCD， group 1是BC，group 2是C。

你可以用下述Matcher方法来使用group：

• public int groupCount( )返回matcher对象中的group的数目。不包括group0。
• public String group( ) 返回上次匹配操作(比方说find( ))的group 0(整个匹配)
• public String group(int i)返回上次匹配操作的某个group。如果匹配成功，但是没能找到group，则返回null。
• public int start(int group)返回上次匹配所找到的group的开始位置。
• public int end(int group)返回上次匹配所找到的group的结束位置，最后一个字符的下标加一。
• split( ) 是指将以正则表达式为界，将字符串分割成String数组,如果带有limit参数，split( )会限定分割的次数。
• replaceFirst(String replacement)将字符串里，第一个与模式相匹配的子串替换成replacement。
• replaceAll(String replacement)，将输入字符串里所有与模式相匹配的子串全部替换成replacement。
• appendReplacement(StringBuffer sbuf, String replacement)对sbuf进行逐次替换，而不是像replaceFirst( )或replaceAll( )那样，只替换第一个或全部子串。这是个非常重要的方法，因为replacement(replaceFirst( )和replaceAll( )只允许用固定的字符串来充当replacement)。有了这个方法，你就可以编程区分group，从而实现更强大的替换功能。
• 调用完appendReplacement( )之后，为了把剩余的字符串拷贝回去，必须调用appendTail(StringBuffer sbuf, String replacement)。

使用group可以做到逐步缩小匹配的范围，直至精确匹配的目的。

start( )和end( )：如果匹配成功，start( )会返回此次匹配的开始位置，end( )会返回此次匹配的结束位置，即最后一个字符的下标加一。如果之前的匹配不成功(或者没匹配)，那么无论是调用start( )还是end( )，都会引发一个IllegalStateException。

二、4大使用方法：

查询

String str="abc efg ABC";

提取

String regEx=".+\\\\(.+)$";

分割

替换或者删除

String regEx="a+"; //表示一个或多个a

三、一个实际的例子

下面的函数是一个实际应用的例子，需求是需要将抓取的网页中的<img src=''http://aa.bb.cc.com/images/**.jpg"> 中的地址，保存到一个地址列表中（以供抓取图片使用），并将绝对地址替换成本地的相对地址，即<img src="images/**.jpg">。

public static Map<String, String> getImagesURL(String description) {

      Map<String, String> map = new HashMap<String, String>();
        // img 的正则表达式:匹配<img>标签       
        String imgPattern = "<\\s*img\\s+([^>]+)\\s*>";
        Pattern pattern1 = Pattern.compile(imgPattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern1.matcher(description);

        // img src元素的正则表达式：匹配img标签内的src属性
        String srcPattern = "\\s*src\\s*=\\s*\"([^\"]+)\\s*\"";
        Pattern pattern2 = Pattern.compile(srcPattern, Pattern.CASE_INSENSITIVE);

        while (matcher.find()) {

           //group()返回符合表达式的内容
            Matcher matcher2 = pattern2 .matcher(matcher.group());
            // 一定要find(),这是实际的匹配动作
            if (matcher2.find()) {
                String src = matcher2.group();
                log.info(src);
                int i2 = src.lastIndexOf('/');
                int i1 = src.indexOf("http");
                if (i1 != -1) {
                    map.put(src.substring(i2 + 1, src.length() - 1), src
                            .substring(i1, src.length() - 1));
                }
            }
        }
        log.debug("图片：" + map);
        return map;
    }

整体思路是先匹配到img标签，然后匹配src属性，并修改src的属性

"<\\s*img\\s+([^>]+)\\s*>" 的解释：

\\s* :0 或多个空格   \\s+: 至少一个空格

([^>]+)：指的是非>的所有的字符，至少一个

常用的正则表达式（参考jdk的regex文档）

字符集类

.                            表示任意一个字符

[abc]                     表示字符a，b，c中的任意一个(与a|b|c相同)

[^abc]                   除a，b，c之外的任意一个字符(否定)

[a-zA-Z]                从a到z或A到Z当中的任意一个字符(范围)

[abc[hij]]              a,b,c,h,i,j中的任意一个字符(与a|b|c|h|i|j相同)(并集)

[a-z&&[hij]]          h,i,j中的一个(交集)

\s                          空格字符(空格键, tab, 换行, 换页, 回车)

\S                         非空格字符([^\s])

\d                         一个数字，也就是[0-9]

\D                         一个非数字的字符，也就是[^0-9]

\w                        一个单词字符(word character)，即[a-zA-Z_0-9]

\W                       一个非单词的字符，[^\w]

字符类：

B                         字符B

\xhh                    16进制值0xhh所表示的字符

\uhhhh                16进制值0xhhhh所表示的Unicode字符

\t                         Tab

\n                        换行符

\r                         回车符

\f                        换页符

\e                       Escape

逻辑运算符

XY                      X 后面跟着 Y

X|Y                    X或Y

(X)                     一个"要匹配的组(capturing group)". 以后可以用\i来表示第i个被匹配的组。

边界匹配符

^                      一行的开始

$                      一行的结尾

\b                    一个单词的边界

\B                    一个非单词的边界

\G                   前一个匹配的结束

数量表示符

"数量表示符(quantifier)"的作用是定义模式应该匹配多少个字符。

• Greedy(贪婪的)： 除非另有表示，否则数量表示符都是greedy的。Greedy的表达式会一直匹配下去，直到匹配不下去为止。(如果你发现表达式匹配的结果与预期的不符)，很有可能是因为，你以为表达式会只匹配前面几个字符，而实际上它是greedy的，因此会一直匹配下去。
• Reluctant(勉强的)： 用问号表示，它会匹配最少的字符。也称为lazy, minimal matching, non-greedy, 或ungreedy。
• Possessive(占有的)： 目前只有Java支持(其它语言都不支持)。它更加先进，所以你可能还不太会用。用正则表达式匹配字符串的时候会产生很多中间状态，(一般的匹配引擎会保存这种中间状态，)这样匹配失败的时候就能原路返回了。占有型的表达式不保存这种中间状态，因此也就不会回头重来了。它能防止正则表达式的失控，同时也能提高运行的效率。

Greedy                    Reluctant                           Possessive                      匹配

X?                            X??                                      X?+                                  匹配一个或零个X

X*                            X*?                                      X*+                                  匹配零或多个X

X+                           X+?                                      X++                                 匹配一个或多个X

X{n}                        X{n}?                                   X{n}+                               匹配正好n个X

X{n,}                       X{n,}?                                 X{n,}+                              匹配至少n个X

X{n,m}                   X{n,m}?                                X{n,m}+                           匹配至少n个，至多m个X

参考资料

要想进一步学习正则表达式，建议看Mastering Regular Expression, 2nd Edition，作者Jeffrey E. F. Friedl (O’Reilly, 2002)。

"Regular Expressions and the Java Programming Language," Dana Nourie and Mike McCloskey (Sun Microsystems, August 2002) presents a brief overview of java.util.regex, including five illustrative regex-based applications:
http://developer.java.sun.com/developer/technicalArticles/releases/1.4regex/

http://www.blogjava.net/beike/archive/2006/04/28/43832.html 

http://wcjok.bokee.com/4293762.html

http://www.xd-tech.com.cn/blog/article.asp?id=34

作者:jaddy0302 日期:2006-12-21

      一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器，用来浏览页面查看信息或者提交一些数据等等。所访问的这些页面有的仅仅是一些普通的页面，有的需要用户登录后方可使用，或者需要认证以及是一些通过加密方式传输，例如HTTPS。目前我们使用的浏览器处理这些情况都不会构成问题。不过你可能在某些时候需要通过程序来访问这样的一些页面，比如从别人的网页中“偷”一些数据；利用某些站点提供的页面来完成某种功能，例如说我们想知道某个手机号码的归属地而我们自己又没有这样的数据，因此只好借助其他公司已有的网站来完成这个功能，这个时候我们需要向网页提交手机号码并从返回的页面中解析出我们想要的数据来。如果对方仅仅是一个很简单的页面，那我们的程序会很简单，本文也就没有必要大张旗鼓的在这里浪费口舌。但是考虑到一些服务授权的问题，很多公司提供的页面往往并不是可以通过一个简单的URL就可以访问的，而必须经过注册然后登录后方可使用提供服务的页面，这个时候就涉及到 COOKIE问题的处理。我们知道目前流行的***页技术例如ASP、JSP无不是通过COOKIE来处理会话信息的。为了使我们的程序能使用别人所提供的服务页面，就要求程序首先登录后再访问服务页面，这过程就需要自行处理cookie，想想当你用java.net.HttpURLConnection 来完成这些功能时是多么恐怖的事情啊！况且这仅仅是我们所说的顽固的WEB服务器中的一个很常见的“顽固”！再有如通过HTTP来上传文件呢？不需要头疼，这些问题有了“它”就很容易解决了！

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用 java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是 Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给 httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所形侍狻?/font>

1． 读取网页(HTTP/HTTPS)内容

下面是我们给出的一个简单的例子用来访问某个页面

/*

 * Created on 2003-12-14 by Liudong

 */

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

 * 最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面

 * @author Liudong

 */

public class SimpleClient {

    public static void main(String[] args) throws IOException

    {

        HttpClient client = new HttpClient();   

        //设置代理服务器地址和端口    

        //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);

        //使用GET方法，如果服务器需要通过HTTPS连接，那只需要将下面URL中的http换成https

        HttpMethod method = new GetMethod("http://java.sun.com");

        //使用POST方法

        //HttpMethod method = new PostMethod("http://java.sun.com");

        client.executeMethod(method);

        //打印服务器返回的状态

        System.out.println(method.getStatusLine());

        //打印返回的信息

        System.out.println(method.getResponseBodyAsString());

        //释放连接

        method.releaseConnection();

    }
}

在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者 POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！

2． 以GET或者POST方式向网页提交参数

其实前面一个最简单的示例中我们已经介绍了如何使用GET或者POST方式来请求一个页面，本小节与之不同的是多了提交时设定页面所需的参数，我们知道如果是GET的请求方式，那么所有参数都直接放到页面的URL后面用问号与页面地址隔开，每个参数用&隔开，例如：http://java.sun.com?name=liudong&mobile=123456，但是当使用POST方法时就会稍微有一点点麻烦。本小节的例子演示向如何查询手机号码所在的城市，代码如下：

/*

 * Created on 2003-12-7 by Liudong

 */

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

 * 提交参数演示

 * 该程序连接到一个用于查询手机号码所属地的页面

 * 以便查询号码段1330227所在的省份以及城市

 * @author Liudong

 */

public class SimpleHttpClient {

    public static void main(String[] args) throws IOException

    {

        HttpClient client = new HttpClient();

        client.getHostConfiguration().setHost("www.imobile.com.cn", 80, "http");

        HttpMethod method = getPostMethod();//使用POST方式提交数据

        client.executeMethod(method);

       //打印服务器返回的状态

        System.out.println(method.getStatusLine());

        //打印结果页面

        String response =  new String(method.getResponseBodyAsString().getBytes("8859_1"));

       //打印返回的信息

        System.out.println(response);

        method.releaseConnection();

    }

    /**

     * 使用GET方式提交数据

     * @return

     */

    private static HttpMethod getGetMethod(){

        return new GetMethod("/simcard.php?simcard=1330227");

    }

    /**

     * 使用POST方式提交数据

     * @return

     */

    private static HttpMethod getPostMethod(){

        PostMethod post = new PostMethod("/simcard.php");

        NameValuePair simcard = new NameValuePair("simcard","1330227");

        post.setRequestBody(new NameValuePair[] { simcard});

        return post;

    }

}

在上面的例子中页面http://www.imobile.com.cn/simcard.php需要一个参数是simcard，这个参数值为手机号码段，即手机号码的前七位，服务器会返回提交的手机号码对应的省份、城市以及其他详细信息。GET的提交方法只需要在URL后加入参数信息，而POST则需要通过NameValuePair类来设置参数名称和它所对应的值

3． 处理页面重定向

在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的<jsp:forward …>的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端读取需要跳转到的页面的URL并重新加载新的页面。就是这样一个过程，所以我们编程的时候就要通过 HttpMethod.getStatusCode()方法判断返回值是否为下表中的某个值来判断是否需要跳转。如果已经确认需要进行页面跳转了，那么可以通过读取HTTP头中的location属性来获取新的地址。

状态码
 对应HttpServletResponse的常量
 详细描述
301　 SC_MOVED_PERMANENTLY
 页面已经永久移到另外一个新地址
302　 SC_MOVED_TEMPORARILY
 页面暂时移动到另外一个新的地址
303　 SC_SEE_OTHER
 客户端请求的地址必须通过另外的URL来访问
307　 SC_TEMPORARY_REDIRECT　 同SC_MOVED_TEMPORARILY

下面的代码片段演示如何处理页面的重定向

client.executeMethod(post);

        System.out.println(post.getStatusLine().toString());

        post.releaseConnection();

        //检查是否重定向

        int statuscode = post.getStatusCode();

        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||

            (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||

            (statuscode == HttpStatus.SC_SEE_OTHER) ||

(statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {

//读取新的URL地址

            Header header = post.getResponseHeader("location");

            if (header != null) {

                String newuri = header.getValue();

                if ((newuri == null) || (newuri.equals("")))

                    newuri = "/";

                GetMethod redirect = new GetMethod(newuri);

                client.executeMethod(redirect);

                System.out.println("Redirect:"+ redirect.getStatusLine().toString());

                redirect.releaseConnection();

            } else

                System.out.println("Invalid redirect");

        }

我们可以自行编写两个JSP页面，其中一个页面用response.sendRedirect方法重定向到另外一个页面用来测试上面的例子。

4． 模拟输入用户名和口令进行登录

本小节应该说是HTTP客户端编程中最常碰见的问题，很多网站的内容都只是对注册用户可见的，这种情况下就必须要求使用正确的用户名和口令登录成功后，方可浏览到想要的页面。因为HTTP协议是无状态的，也就是连接的有效期只限于当前请求，请求内容结束后连接就关闭了。在这种情况下为了保存用户的登录信息必须使用到Cookie机制。以JSP/Servlet为例，当浏览器请求一个JSP或者是Servlet的页面时，应用服务器会返回一个参数，名为jsessionid（因不同应用服务器而异），值是一个较长的唯一字符串的Cookie，这个字符串值也就是当前访问该站点的会话标识。浏览器在每访问该站点的其他页面时候都要带上jsessionid这样的Cookie信息，应用服务器根据读取这个会话标识来获取对应的会话信息。

对于需要用户登录的网站，一般在用户登录成功后会将用户资料保存在服务器的会话中，这样当访问到其他的页面时候，应用服务器根据浏览器送上的Cookie中读取当前请求对应的会话标识以获得对应的会话信息，然后就可以判断用户资料是否存在于会话信息中，如果存在则允许访问页面，否则跳转到登录页面中要求用户输入帐号和口令进行登录。这就是一般使用JSP开发网站在处理用户登录的比较通用的方法。

这样一来，对于HTTP的客户端来讲，如果要访问一个受保护的页面时就必须模拟浏览器所做的工作，首先就是请求登录页面，然后读取Cookie值；再次请求登录页面并加入登录页所需的每个参数；最后就是请求最终所需的页面。当然在除第一次请求外其他的请求都需要附带上 Cookie信息以便服务器能判断当前请求是否已经通过验证。说了这么多，可是如果你使用httpclient的话，你甚至连一行代码都无需增加，你只需要先传递登录信息执行登录过程，然后直接访问想要的页面，跟访问一个普通的页面没有任何区别，因为类HttpClient已经帮你做了所有该做的事情了，太棒了！下面的例子实现了这样一个访问的过程。

/*

 * Created on 2003-12-7 by Liudong

 */

package http.demo;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.cookie.*;

import org.apache.commons.httpclient.methods.*;

/**

 * 用来演示登录表单的示例

 * @author Liudong

 */

public class FormLoginDemo {

    static final String LOGON_SITE = "localhost";

    static final int    LOGON_PORT = 8080;

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

        HttpClient client = new HttpClient();

        client.getHostConfiguration().setHost(LOGON_SITE, LOGON_PORT);

       //模拟登录页面login.jsp->main.jsp

        PostMethod post = new PostMethod("/main.jsp");

        NameValuePair name = new NameValuePair("name", "ld");    

        NameValuePair pass = new NameValuePair("password", "ld");    

        post.setRequestBody(new NameValuePair[]{name,pass});

       int status = client.executeMethod(post);

        System.out.println(post.getResponseBodyAsString());

        post.releaseConnection(); 

       //查看cookie信息

        CookieSpec cookiespec = CookiePolicy.getDefaultSpec();

        Cookie[] cookies = cookiespec.match(LOGON_SITE, LOGON_PORT, "/", false, client.getState().getCookies());

       if (cookies.length == 0) {

           System.out.println("None");   

       } else {

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

               System.out.println(cookies[i].toString());   

           }

       }

       //访问所需的页面main2.jsp

        GetMethod get = new GetMethod("/main2.jsp");

        client.executeMethod(get);

        System.out.println(get.getResponseBodyAsString());

        get.releaseConnection();

    }

}

5． 提交XML格式参数

提交XML格式的参数很简单，仅仅是一个提交时候的ContentType问题，下面的例子演示从文件文件中读取XML信息并提交给服务器的过程，该过程可以用来测试Web服务。

import java.io.File;

import java.io.FileInputStream;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.methods.EntityEnclosingMethod;

import org.apache.commons.httpclient.methods.PostMethod;

/**

 * 用来演示提交XML格式数据的例子

 */

public class PostXMLClient {

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

        File input = new File(“test.xml”);

        PostMethod post = new PostMethod(“http://localhost:8080/httpclient/xml.jsp”);

        // 设置请求的内容直接从文件中读取

        post.setRequestBody(new FileInputStream(input));

        if (input.length() < Integer.MAX_VALUE)

            post.setRequestContentLength(input.length());

        else           

post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);

        // 指定请求内容的类型

        post.setRequestHeader("Content-type", "text/xml; charset=GBK");

        HttpClient httpclient = new HttpClient();

        int result = httpclient.executeMethod(post);

        System.out.println("Response status code: " + result);

        System.out.println("Response body: ");

        System.out.println(post.getResponseBodyAsString());

        post.releaseConnection();

    }

}

6． 通过HTTP上传文件

httpclient使用了单独的一个HttpMethod子类来处理文件的上传，这个类就是MultipartPostMethod，该类已经封装了文件上传的细节，我们要做的仅仅是告诉它我们要上传文件的全路径即可，下面的代码片段演示如何使用这个类。

MultipartPostMethod filePost = new MultipartPostMethod(targetURL);

filePost.addParameter("fileName", targetFilePath);

HttpClient client = new HttpClient();

//由于要上传的文件可能比较大,因此在此设置最大的连接超时时间

client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);

int status = client.executeMethod(filePost);

上面代码中，targetFilePath即为要上传的文件所在的路径。

7． 访问启用认证的页面

我们经常会碰到这样的页面，当访问它的时候会弹出一个浏览器的对话框要求输入用户名和密码后方可，这种用户认证的方式不同于我们在前面介绍的基于表单的用户身份验证。这是HTTP的认证策略，httpclient支持三种认证方式包括：基本、摘要以及NTLM认证。其中基本认证最简单、通用但也最不安全；摘要认证是在HTTP 1.1中加入的认证方式，而NTLM则是微软公司定义的而不是通用的规范，最新版本的NTLM是比摘要认证还要安全的一种方式。

下面例子是从httpclient的CVS服务器中下载的，它简单演示如何访问一个认证保护的页面：

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.UsernamePasswordCredentials;

import org.apache.commons.httpclient.methods.GetMethod;

public class BasicAuthenticationExample {

    public BasicAuthenticationExample() {

    }

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

        HttpClient client = new HttpClient();

        client.getState().setCredentials(

            "www.verisign.com",

            "realm",

            new UsernamePasswordCredentials("username", "password")

        );

        GetMethod get = new GetMethod("https://www.verisign.com/products/index.html");

        get.setDoAuthentication( true );

        int status = client.executeMethod( get );

        System.out.println(status+""+ get.getResponseBodyAsString());

        get.releaseConnection();

    }

}

8． 多线程模式下使用httpclient

多线程同时访问httpclient，例如同时从一个站点上下载多个文件。对于同一个HttpConnection 同一个时间只能有一个线程访问，为了保证多线程工作环境下不产生冲突，httpclient使用了一个多线程连接管理器的类： MultiThreadedHttpConnectionManager，要使用这个类很简单，只需要在构造HttpClient实例的时候传入即可，代码如下：

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

以后尽管访问client实例即可。

参考资料：

httpclient首页：    http://jakarta.apache.org/commons/httpclient/
关于NTLM是如何工作：  http://davenport.sourceforge.net/ntlm.html

一、底层的还是装饰的

1、底层的直接与文件系统或者硬件打交道的类(充当数据源的类)：

包括InputStream和OutPutStream两大类，分别用于输入和输出，数据源可以是bytes array，String对象，file文件，stream序列等：

• FileInputStream/FileOutputStream
• ByteArrayInputStream/ByteArrayOutputStream
• StringBufferInputStream/StringBufferOutputStream

等，具体参看下面的java io类图

2、充当装饰功能的io类,通过装饰底层的类来实现更高级的功能，继承自FilterOutputStream/FilterOutputStream，包括：

• BufferedOutputStream/BufferedInputStream
• Datainputstream/Dataoutputstream

等，具体参看下面的java io类图

使用FilterOutputStream/FilterOutputStream时，首先创建一个数据源IO，然后根据需要的功能创建装饰类io，其构造函数的参数为已创建的数据源io。

二、面向字符还是面向字节

同时，java的IO体系又可以分成：inputStream/outputStream和reader/writer两类：

（1） Reader/Writer是面向Unicode字符的（Characters）

（2） InputStream/OutputStream是直接面向字节的（bytes）。

Reader/Writer继承体系之所以存在，最重要的原因是为了国际化，旧式I/O stream 的继承体系仅仅支持8-bit byte stream，而且无法处理16-bit unicode 字符。由于unicode被用于字符国际化，所以加入Reader/Writer以便在所有的io动作上提供对unicode的支持。

几乎所有的java io stream classes都有相应的Reader和Writer来提供对unicode的支持，但是在某些场合，使用byte-oriented InputStream和OutPutStream才是正取的方法，最合理的方式是尽可能先尝试使用Read和Writer，其次才使用byte-oriented库。

三、从InputStream/OutPutStream到Reader/Writer的转换

InputStreamReader和OutputStreamWriter，可以把一个以字节为导向的stream转换成一个以字符为导向的stream。

Java 1.0 class（byte oriented）      Java 1.1 class(unicode character oriented)

装饰前的行为

InputStream                                                       Reader  转换器：InputStreamReader

OutputStreamReader                                          Writer  转换器：OutputStreamWriter

FileInputSream                                                   FileOutputStream

FileReader                                                          FileWriter

StringBufferInputStream                                    StringReader/StringWriter                                    

ByteArrayInputStream                                        ByteArrayOutputStream                 

CharArrayReader                                                CharArrayWriter

装饰后的行为

BufferedInputStream                                          BufferedOutputStream

BufferedReader                                                  BufferedWriter

PrintStream                                                        PrintWriter

四、示例

DataInputStream和DataOutputStream

Java中除了二进制文件和使用文本文件外还有基于Data的数据操作，这里的Data指的是Java的基本数据类型和String。基本数据类型包括byte、int、char、long、float、double、boolean和short。

例子：

protected void connect (Socket socket)

throws IOException, SocketException

{

this.socket = socket;

applyTimeout();

serverIn = new DataInputStream (

new BufferedInputStream (socket.getInputStream ())

);

serverOut = new DataOutputStream(

new BufferedOutputStream(socket.getOutputStream(), 2048)

);

usable = true;

cnt[CONNECT]++;

setChanged();

notifyObservers();

}

在DataInputStream和DataOutputStream两个类中的方法都很简单，基本结构为readXXXX()和writeXXXX()其中XXXX代表基本数据类型或者String。

一、创建XML文件

Document doc = new Document(new Element("rootElement"))

或者

Document doc = new Document();
// 根元素

 Element root = new Element("persons");
 doc.addContent(root);

// add person
Element person = new Element("person").setText("test1");
root.addContent(person);

//add person 2
person = new Element("person").setText("test2");
root.addContent(person);

另外一种方式：

Document doc = new Document(new Element("family")
.addContent(new Element("mom"))
.addContent(new Element("dad").addContent("kidOfDad")));

二、解析XML文件

   一般而言，使用org.jdom.input.SAXBuilder更快，推荐使用，而org.jdom.input.DOMBuilder适用于已经存在DOM对象的场合。

SAXBuilder b = new SAXBuilder();
            // Create the document
Document doc = b.build(new File(xmlfilename));

• 获取根元素：Element webapp = doc.getRootElement();
• 获取子节点（支持namespace）：

// Get a List of direct children as Elements
List allChildren = element.getChildren();

// Get all direct children with a given name
List namedChildren = element.getChildren("name");

// Get the first kid with a given name
Element kid = element.getChild("name");

• 增加/删除子节点，可以像操作List对象一样操作子节点集合，当然也可以以传统的方式来操作

List allChildren = element.getChildren();
// Remove the fourth child
allChildren.remove(3);
// Remove all children named "jack"
allChildren.removeAll(element.getChildren("jack"));

或者
element.removeChildren("jack");
// Add a new child
allChildren.add(new Element("jane"));

或者
element.addContent(new Element("jane"));
// Add a new child in the second position
allChildren.add(1, new Element("second"));

• 读取/设置属性

// 读取属性：

String value =table.getAttributeValue("width");// table 是element
// 也可以在读取属性的同时进行类型转换
try {
value =table.getAttribute("border").getIntValue();
}
catch (DataConversionException e) { }

// 设置属性

// Add an attribute
table.addAttribute("vspace", "0");
// Add an attribute more formally 比较正式的写法
table.addAttribute(new Attribute("name", "value"))
// Remove an attribute
table.removeAttribute("border");
// Remove all attributes 移除所有属性
table.getAttributes().clear();

• 获取元素的内容

比如<description>A cool demo</description>，则可以直接获取内容

String content = element.getText();

// 移除多余的空白，字符串前后的空白，不会移除字符串内部的空白

element.getTextNormalize();

• 设置元素的内容

// This blows away all current content
element.setText("A new description");

//Special characters are interpreted correctly: 特殊字符可以被正确地转义

element.setText("<xml> content");

// 创建cdata元素

element.addContent(new CDATA("<xml> content"));

三、输出XML

XMLOutputter 类用来实现XML文件的输出，在创建的时候需要一个Format对象来格式化XML文件，Format对象是一个工厂类，提供几个静态的工厂方法来提供一些常规的XML格式，比如getPrettyFormat()：

XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
        try {
            outputter.output(doc, new FileOutputStream(new File("xmlfile/persons.xml")));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

四、xml Namespace的支持

• 获取名空间

Namespace xhtml = Namespace.getNamespace("xhtml", “http://www.w3.org/1999/xhtml”);

• Namespace 对象可以作为Element 和Attribute的大多数方法的可选参数：

List kids = element.getChildren("p", xhtml);
Element kid = element.getChild("title", xhtml);
Attribute height = element.getAttribute("height", xhtml);

附录：Java下XML编程接口比较：DOM SAX JDOM JAXP（网络装载）

一、DOM （文档对象模型）
为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。
优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；
缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；
使用场合：一旦解析了文档还需多次访问这些数据；
硬件资源充足（内存、CPU）
 二、SAX
为解决DOM的问题，出现了SAX。
SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。
优点：不用事先调入整个文档，占用资源少；
SAX解析器代码比DOM解析器代码小，适于Applet，下载
缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；
无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；
使用场合：Applet;
只需XML文档的少量内容，很少回头访问；
机器内存少；
 三、JDOM
为减少DOM、SAX的编码量，出现了JDOM；
优点：20-80原则，极大减少了代码量
使用场合：要实现的功能简单，如解析、创建等，但在底层，JDOM还是使用SAX（最常用）、DOM、Xanan
四、JAXP
为多个XML解析器提供了统一编程接口
更换解析器，不用更改代码
使用场合：若不用Jdom，一般建议使用JAPX，将代码与各种解析器的实现细节隔离。

• JDOM should be straightforward for Java programmers
– Use the power of the language (Java 2)
– Take advantage of method overloading, the Collections APIs, reflection, weak references
– Provide conveniences like type conversions

• JDOM should hide the complexities of XML wherever possible
– An Element has content, not a child Text node with content
– Exceptions should contain useful error messages
– Give line numbers and specifics, use no SAX or DOM specifics

• JDOM should integrate with DOM and SAX
– Support reading and writing DOM documents and SAX events
– Support runtime plug-in of any DOM or SAX parser
– Easy conversion from DOM/SAX to JDOM
– Easy conversion from JDOM to DOM/SAX

• JDOM should stay current with the latest XML standards
– DOM Level 2, SAX 2.0, XML Schema

• JDOM does not need to solve every problem
– It should solve 80% of the problems with 20% of the effort
– We think we got the ratios to 90% / 10%

JDOM consists of five packages

The org.jdom.input Package

• Classes for reading XML from existing sources:
– DOMBuilder
– SAXBuilder
• Also, outside contributions in jdom-contrib:
– ResultSetBuilder
– SpitfireBuilder
• New support for JAXP-based input
– Allows consistency across applications
– Builders pick up JAXP information and user automatically
– Sets stage for JAXP version.next

The org.jdom.output Package

Classes for writing XML to various forms of output:
– DOMOutputter
– SAXOutputter
– XMLOutputter
Also, outside contributions in jdom-contrib:
– JTreeOutputter

org.jdom.transform

• TRaX is now supported in org.jdom.transform
– Supports XSLT transformations
– Defines Source and Result interfaces
– JDOMSource
– JDOMResult

General Program Flow

• Normally XML Document -> SAXBuilder ->XMLOutputter

完整的pdf下载地址，JDOM: How It Works,and How It Opened the Java Processby Jason Hunter

http://www.blogjava.net/Files/cherishchen/JDOM%20How%20It%20Works.zip

首先还是重温下java的异常体系结构，如图所示，所有异常的根是Throwable，异常又分为checked exception和unchecked exception，RuntimeException就是属于unchecked exception，JVM 一旦捕捉到unchecked exception 就会终止当前运行的程序，并在console中打出错误信息。

ption hierarchy

一、Unchecked exceptions VS Checked exceptions

 下表列出使用两种异常的场合：

 这个方面的例子hibernate就是一个，在hibernate2中，HibernateException还是checked exceptions，但是到了hibernate3中就成了unchecked exceptions，因为对于数据库操作来说，一旦出现异常，就是比较严重的错误，而且在client端基本上是无能为力的，使用unchecked exceptions更加合适。

另外，unchecked exceptions的优点在于不强迫客户端代码显式地处理他们，异常可以一直往上传递（除非需要转化异常，否则异常不需要在中间被捕捉，节省了很多的try{}catch()，代码更加简洁），直到你想捕捉处理他们，（有人会问，如何不强制客户端处理他们，比如像checked exceptions这样，不处理就是语法错误，如何保证异常能够得到处理呢？在这点上，java提供的完善的文档机制，通过API客户端程序员可以很方便地知道他调用的方法可能会抛出什么异常，一个负责人的程序员就应该对其进行catch和处理），Java API提供了很多的unchecked exceptions，比如NullPointerException, IllegalArgumentException, and IllegalStateException，使用java提供的标准的unchecked exceptions是值得推荐的，这样的好处在于使代码更加简洁并可以减少代码对内存的占用。

二、Java异常的推迟处理

Java异常应该尽可能地推迟处理，除非要转化异常，重新抛出，否则最好不要处理，而是留给最后能够处理异常的地方。

通过为方法添加throws声明，可以将处理异常的责任传递到更高的层次。在声明哪些需要抛出的时候，应该尽可能地详细。这样做的目的是可以在API中详细地表述出该方法可能会出现的异常，从而让调用该方法的clinet程序员做好处理异常的准备，比如对于代码通过throws语句详细地声明了可能会抛出的异常，这样调用该方法的程序员就会知道将会有什么样的异常会发生。

public void readPreferences(String filename)

    throws IllegalArgumentException,

          FileNotFoundException, IOException
{

    if (filename == null)
    {

        throw new IllegalArgumentException

                        ("filename is null");

    }  //if
    //
    InputStream in = new FileInputStream(filename);

    //
}

从语法上讲，IllegalArgumentException是unckecked exception 是不需要声明的，但是为了从文档的角度考虑，最好还是加上，这样可以让调用这个方法的程序员知道，这个方法会可能抛出该异常，需要加以捕捉和处理。

三、异常的处理

不管如何，最终程序肯定是要对异常进行处理的，否则会导致不确定情况的发生，但是选择异常处理的位置却是有技巧的，通常要么是程序在这些地方从异常中恢复、继续执行且不会导致进一步异常的发生，要么是在这些地方能为用户反馈特定的信息，比如，如何避免异常的发生或者如何从异常中恢复。因此，对于有用户界面层的程序，将异常的捕捉和处理推迟到UI层是有好处的，在UI层可以使用对话框或者其他方式提示用户出现异常。
 

参考文献

Best Practices for Exception Handling by Gunjan Doshi

Three Rules for Effective Exception Handling by Jim Cushing

举例来说，如果图中的顶点表示城市，而边上的权重表示著城市间开车行经的距离。 Dijkstra算法可以用来找到两个城市之间的最短路径。

Dijkstra算法的输入包含了一个有权重的有向图G，以及G中的一个来源顶点S。 我们以V表示G中所有顶点的集合。图中的每一个边，都是两个顶点所形成的有序元素对。(u,v)表示从顶点u到v有路径相连。 假设E为所有边的集合，而边的权重则由权重函数w: E → [0, ∞]定义。 因此，w(u,v)就是从顶点u到顶点v的非负花费值(cost)。 边的花费可以想像成两个顶点之间的距离。任两点间路径的花费值，就是该路径上所有边的花费值总和。 已知有V中有顶点s及t，Dijkstra算法可以找到s到t的最低花费路径(i.e. 最短路径)。 这个算法也可以在一个图中，找到从一个顶点s到任何其他顶点的最短路径。

算法描述

  这个算法是通过为每个顶点v保留目前为止所找到的从s到v的最短路径来工作的。初始时，源点s的路径长度值被赋为0（d[s]=0）， 同时把所有其他顶点的路径长度设为无穷大，即表示我们不知道任何通向这些顶点的路径（对于V中所有顶点v除s外d[v]= ∞）。当算法结束时，d[v]中储存的便是从s到v的最短路径，或者是无穷大（如果路径不存在的话）。

   Dijstra算法的基础操作是边的拓展：如果存在一条从u到v的边，那么从s到v的最短路径可以通过将边(u,v)添加到s到u的尾部来拓展。这条路径的长度是d[u]+w(u,v)。如果这个值比目前已知的d[v]的值要小，我们可以用新值来替代当前d[v]中的值。拓展边的操作一直执行到所有的d[v]都代表从s到v最短路径的花费。这个算法经过适当的组织因而当d[u]达到它最终的值的时候，每条边(u,v)都只被拓展一次。

算法维护两个顶点集S和Q。集合S保留了我们已知的所有d[v]的值已经是最短路径的值顶点，而集合Q则保留其他所有顶点。集合S初始状态为空，而 后每一步都有一个顶点从Q移动到S。这个被选择的顶点是Q中拥有最小的d[u]值的顶点。当一个顶点u从Q中转移到了S中，算法对每条外接边(u,v)进 行拓展。

算法思想

Spring推荐事务的控制在service层实现，而不是像单独使用hibernate那样，在dao层实现，这样的好处在于更好地支持declear方式的事务（service层通常提供接口，这样可以针对接口来定义事务策略，而不是针对具体的service实现，因此可以很方便地替换service的实现，而不需要修改事务的配置），更加灵活。同时，可以更加方面自然地实现全局事务的控制。

举例如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">



    <!-- this is the service object that we want to make transactional -->
    <bean id="fooService" class="x.y.service.DefaultFooService" />

    <!-- the transactional advice (i.e. what 'happens'; see the <aop:advisor/> bean below) -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <!-- the transactional semantics -->
        <tx:attributes>
            <!-- all methods starting with 'get' are read-only -->
            <tx:method name="get*" read-only="true" />

            <!-- other methods use the default transaction settings (see below) -->
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

    <!-- ensure that the above transactional advice runs for any execution
        of an operation defined by the FooService interface -->
    <aop:config>
        <aop:pointcut id="fooServiceOperation"
            expression="execution(* x.y.service.FooService.*(..))" />
        <aop:advisor advice-ref="txAdvice"
            pointcut-ref="fooServiceOperation" />
    </aop:config>

    <!-- don't forget the DataSource -->
    <bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url"
            value="jdbc:h2:tcp://localhost/D:/try/data/sample;IFEXISTS=TRUE" />
        <property name="username" value="sa" />
        <property name="password" value="123456" />
    </bean>

    <!-- similarly, don't forget the PlatformTransactionManager -->
    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- other <bean/> definitions here -->
</beans>

使用service层方便了使用全局事务

对于横跨多个Hibernate SessionFacotry的分布式事务，只需简单地将 JtaTransactionManager 同多个 LocalSessionFactoryBean 的定义结合起来作为事务策略。你的每一个DAO通过bean属性得到各自的 SessionFactory 引用。在需要进行跨多个数据库的事务操作时，只需要定义一个service层，使用 JtaTransactionManager 作为事务策略，横跨多个DAO和多个session factories来划分事务，而不需要特殊的处理。

    jPDL是一种直观的流程语言，用以展现商业逻辑的处理过程。jPDL包含的概念涉及任务、异步通讯状态、定时器、自动执行的动作等，为此，为了整合上述行为，jPDL提供了强大、可扩展的控制流机制。

graph based execution languages

implementation technique for graph based execution languages：

• based on runtime interpretation of a graph. 
• based on message queues
• code generation.

The strategy on how graph execution can be implemented on top of an OO programming language. For those who are familiar with design patterns, it's a combination of the command pattern and the chain of responsibility pattern.

1、Transitions  可以理解为进入和离开节点的箭头，应该存在多个Transitions  进入一个节点和一个节点有多个离开的Transitions  的情况

the structure of the graph is represented with the classes Node and Transition，而Transition是具有方向性的

transitions are able to pass the execution from a source node to a destination node with the method take.

2、execution ，类似petri中的标记，是变迁就绪的前提

An execution (also known as a token) is represented with a class called Execution. An execution has a reference to the current node.

3、Node

A node is a command and has an execute method. Subclasses of Node are supposed to override the execute method to implement some specific behaviour for that node type.

When an execution arrives in a node, that node is executed. The Node's execute method is also responsible for propagating the execution. Propagating the execution means that a node can pass the execution that arrived in the node over one of its leaving transitions to the next node.

When a node's execute method does not propagate the execution, it behaves as a wait state.

Also when a new execution is created, it is initialized in some start node and then waits for an event.

An event is given to an execution and it can trigger the execution to start moving. If the event given to an execution relates to a leaving transition of the current node, the execution takes that transition. The execution then will continue to propagate until it enters another node that behaves as a wait state.

So now we can already see that the two main features are supported : wait states and a graphical representation. During wait states, an Execution just points to a node in the graph

4、Actions

An Action is a command with an execute method. Actions can be associated with events.

Synchronous execution

The default propagation of execution is synchronous.

WHAT IS JGAP?

JGAP (pronounced "jay-gap") is a Genetic Algorithms and Genetic Programming component provided as a Java framework. It provides basic genetic mechanisms that can be easily used to apply evolutionary principles to problem solutions. See the examples for a demonstration or watch out the graphical tree that can be created with JGAP for found solutions of genetically evolved programs.
JGAP was designed to be very easy to use "out of the box", while also designed to be highly modular so that more adventurous users can easily plug-in custom genetic operators and other sub-components.

Documentation,  quality and stability of code are the top concerns when developing JGAP. You find really many unit tests packaged with JGAP, extensive Javadocs, and quite a lot of examples. Compare JGAP with other projects! Feedback is always welcome.

最近一个桌面的程序需要使用嵌入式数据库，选择了很多不同的嵌入式数据,最终选择了H2，性能是一个很重要的原因，下图是h2提供的Performance的比较图

http://www.h2database.com/html/images/performance.png

h2是Thomas Mueller提供的一个开源的、纯java实现的关系数据库，在google上面有讨论组h2-database@googlegroups.com，Thomas Mueller也非常热情，回答问题非常及时。

下面说下我最终选择h2的原因：

（1）性能、小巧

（2）同时支持网络版和嵌入式版本，另外还提供了内存版

（3）有比较好的兼容性，支持相当标准的sql标准（实际上也不存在一个数据库能够100%符合标准）

（4）提供了非常友好的基于web的数据库管理界面

（5）支持hibernate

Transaction Isolation

This database supports the following transaction isolation levels:

• Serializable
  This is the default level.
  To enable, execute the SQL statement 'SET LOCK_MODE 0'
  or append ;LOCK_MODE=1 to the database URL: jdbc:h2:~/test;LOCK_MODE=1
• Read Committed
  Read locks are released immediately. Higher concurrency is possible when using this level.
  This is the isolation level used for many database systems.
  To enable, execute the SQL statement 'SET LOCK_MODE 0'
  or append ;LOCK_MODE=3 to the database URL: jdbc:h2:~/test;LOCK_MODE=3
• Read Uncommitted
  This level means that transaction isolation is disabled.
  To enable, execute the SQL statement 'SET LOCK_MODE 0'
  or append ;LOCK_MODE=0 to the database URL: jdbc:h2:~/test;LOCK_MODE=0

When using the isolation level 'serializable', dirty reads, non-repeatable reads, and phantom reads are prohibited.

• Dirty Reads
  Means a connection can read uncommitted changes made by another connection.
  Possible with: read uncommitted
• Non-Repeatable Reads
  A connection reads a row, another connection changes a row and commits, and the first connection re-reads the same row and gets the new result.
  Possible with: read uncommitted, read committed
• Phantom Reads
  A connection reads a set of rows using a condition, another connection inserts a row that falls in this condition and commits, then the first connection re-reads using the same condition and gets the new row.
  Possible with: read uncommitted, read committed

Table Level Locking

（1）合理使用checked exception和unchecked exception，说明使用这两种异常的原则的文章很多，不多罗嗦了

  （2）异常的转换，如果需要，可以将底层的异常包装为包含更多含义的自定义异常重新抛出（包括checked和unchecked的自定义异常体系），自定义异常不仅仅需要包含原始的异常信息，还要包含一些特定的含义和处理方法；

(3) 异常的抛出，尽量不要在中间层处理异常，要么在异常发生的地方处理，要么抛出，推迟到由最终调用层来处理，比如由与用户直接打交道的UI层，捕捉异常，并以错误信息框、对话框等信息载体反馈良好的信息给用户

 这也只是我个人的一些观点，希望大家能给出更好的方式

范例：

（1）定义自定义的异常：包括了两个构造函数，一个用于提供默认的异常信息，一个供程序员添加更加详细的异常信息，这个异常，可以用来封装所有的底层异常，但是一般在逻辑上更加清楚，可以增加不同的自定义异常，比如数据库处理异常、文件处理异常、网络处理异常等

（2）使用自定义的异常封装底层异常：
 

（3）在用户界面部分的处理，通过MessageDialog反馈给用户正确的信息：

总结

select calldate,

sum(case class when '1' then callcount else 0 end) as A类,

sum(case class when '2' then callcount else 0 end) as B类,

sum(case class when '3' then callcount else 0 end) as C类

from t group by calldate

最后结果：