1. 下载
2. 新建web project
3. 复制*.jar文件到lib目录
4. 修改web.xml文件
5. 新建并编辑struts.xml文件
6. HelloAction

下载

Struts2的下载地址是： http://struts.apache.org/download.cgi

到现在为止：最新版本是2.0.11.1。把下载后的文件解压缩到一个目录中。在解压缩后的apps目录中，有个struts2-blank-2.0.11.war。这是搭建一个新的struts2项目的很好的参考。本文就参考这个。

新建web工程

新建一个web project。这里假设project 名称为struts2

复制*.jar文件

至少需要5个jar文件。

修改web.xml文件

在web.xml文件中加入下面的内容。（在web-app节点中）

    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

新建并编辑struts.xml文件

struts.xml文件的骨架是下面这样的：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd" >
<struts>
    <package name="struts" extends="struts-default">

        <!--action is here-->

    </package>
</struts>

到现在为止，struts环境已经搭建好了。下面可以编写一个HelloAction来运行测试一下环境。

HelloAction

Action的一般流程是这样的

1. input.jsp文件
2. 配置action。
3. 执行HelloAction
4. 达到result.jsp文件

下面的程序是对两个十六进制（hex）字面常量进行相加，然后打印出十六进制的结果。这个程序会打印出什么呢？

public class JoyOfHex {
    public static void main(String[] args) {
        System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));
    }
}

第 5 天问题的解答

看起来很明显，该程序应该打印出1cafebabe。毕竟，这确实就是十六进制数字10000000016与cafebabe16的和。该程序使用的是long型运算，它可以支持16位十六进制数，因此运算溢出是不可能的。

遗憾的告诉你，结果是cafebabe，并没有任何前导的1。这个输出表示的是正确结果的低32位，但是不知何故，第33位丢失了。

原因

十进制字面常量具有一个很好的属性，即所有的十进制字面常量都是正的，而十六进制或是八进制字面常量并不具备这个属性。

要想书写一个负的十进制常量，可以使用一元取反操作符（-）连接一个十进制字面常量。以这种方式，你可以用十进制来书写任何int或long型的数值，不管它是正的还是负的，并且负的十进制常数可以很明确地用一个减号符号来标识。

但是十六进制和八进制字面常量并不是这么回事，它们可以具有正的以及负的数值。如果十六进制和八进制字面常量的最高位被置位了，那么它们就是负数。在这个程序中，数字0xcafebabe是一个int常量，它的最高位被置位了，所以它是一个负数。它等于十进制数值-889275714。

该程序执行的这个加法是一种"混合类型的计算（mixed-type computation）。左操作数是 long 类型的，而右操作数是 int 类型的。为了执行该计算，Java将int类型的数值用拓宽原始类型转换提升为一个long类型，然后对两个long类型数值相加。因为int是一个有符号的整数类型，所以这个转换执行的是符合扩展，它将负的int类型的数值提升为一个在数值上相等的long类型数值。

解决办法

System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));

这个加法的右操作数0xcafebabe被提升为了long类型的数值0xffffffffcafebabeL。这个数值之后被加到了左操作数0x100000000L上。当作为int类型来被审视时，经过符号扩展之后的右操作数的高32位是-1，而左操作数的高32位是1，将这两个数值相加就得到了0，这也就解释了为什么在程序输出中前导1丢失了。

第 5 天问题的总结

这个题给我们的教训是：混合类型的计算可能会产生混淆，尤其是十六进制和八进制字面常量无需显式的减号符号就可以表示负的数值。为了避免这种窘境，通常最好是避免混合类型的计算。

对于语言的设计者们来说，应该考虑支持无符号的整数类型，从而根除符号扩展的可能性。可能会有这样的争辩：负的十六进制和八进制字面常量应该被禁用，但是这可能会挫伤程序员，他们经常使用十六进制字面常量来表示那些符号没有任何重要含义的数值。

今天的问题

转型被用来将一个数值从一种类型转换到另一种类型。下面的程序连续使用了三个转型。那么它到底会打印出什么呢？

public class Multicast {
    public static void main(String[] args) {
        System.out.println((int) (char) (byte) -1);
    }
}

它又会打印出什么呢？

public class Elementary{
    public static void main(String[] args){
        System.out.println(12345 + 5432l);
    }
}

第 4 天问题的解答

这个题看起来似乎太简单了。结果不就是66666吗？

遗憾的告诉你，结果是17777。

原因

事物往往有别于它的表象。就以这个问题为例，它并没有打印出我们想要的输出。请仔细观察 + 操作符的两个操作数， 我们是将一个int类型的12345加到了long类型的5432l上。请注意左操作数开头的数字1和右操作数结尾的小写字母l之间的细微差异。 数字1的水平笔划（称为"臂（arm）"）和垂直笔划（称为"茎（stem）"）之间是一个锐角，而与此相对照的是，小写字母l的臂和茎之间是一个直角。

解决办法

System.out.println(12345+5432L);

用大写的L替换小写字母l。

第 4 天问题的总结

在你大喊"恶心！"之前，你应该注意到这个问题确实已经引起了混乱，这里确实有一个教训： 在long型字面常量中，一定要用大写的L，千万不要用小写的l。这样就可以完全掐断这个谜题所产生的混乱的源头。

相类似的，要避免使用单独的一个l字母作为变量名。例如，我们很难通过观察下面的代码段来判断它到底是打印出列表l还是数字1。

//不良代码-使用了l作为变量名
List l = new ArrayList<String>();
l.add("Foo");
System.out.println(1);

也许当初允许用小写的l来编写long型字面常量本身就是一个错误。

今天的问题

下面的程序是对两个十六进制（hex）字面常量进行相加，然后打印出十六进制的结果。这个程序会打印出什么呢？

public class JoyOfHex {
    public static void main(String[] args) {
        System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));
    }
}

被除数表示的是一天里的微秒数；而除数表示的是一天里的毫秒数。这个程序会打印出什么呢？

public class LongDivision{
    public static void main(String args[]){ 
        final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000; 
        final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000; 
        System.out.println(MICROS_PER_DAY/MILLIS_PER_DAY); 
    } 
} 

第 3 天问题的解答

这个题看起来相当直观。每天的毫秒数和每天的微秒数都是常量。为清楚起见，它们都被表示成积的形式。你可能想都没想，就脱口而出，结果是1000。 遗憾的是，它打印的是5。这里到底发生了什么呢？

原因

问题在于常数MICROS_PER_DAY的计算"确实"溢出了。尽管计算的结果适合放入long中，并且其空间还有富余，但是这个结果并不适合放入int中。 这个计算完全是以int运算来执行的，并且只有在运算完成之后，其结果才被提升到long，而此时已经太迟了：计算已经溢出了， 它返回的是一个小了200倍的数值。从int提升到long是一种拓宽原始类型转换（widening primitive conversion）， 它保留了（不正确的）数值。这个值之后被MILLIS_PER_DAY整除，而MILLIS_PER_DAY的计算是正确的，因为它适合int运算。这样整除的结果就得到了5

那么为什么计算会是以int运算来执行的呢？因为所有乘在一起的因子都是int数值。当你将两个int数值相乘时， 你将得到另一个int数值。Java不具有目标确定类型的特性，这是一种语言特性，其含义是指存储结果的变量的类型会影响到计算所使用的类型

解决办法

public class LongDivision{
    public static void main(String args[ ]){
        final long MICROS_PER_DAY = 24L * 60 * 60 * 1000 * 1000;
        final long MILLIS_PER_DAY = 24L * 60 * 60 * 1000;
        System.out.println(MICROS_PER_DAY/MILLIS_PER_DAY);
    }
}

通过使用long常量来替代int常量作为每一个乘积的第一个因子，我们就可以很容易地订正这个程序。这样做可以强制表达式中所有的后续计算都用long运作来完成。 尽管这么做只在MICROS_PER_DAY表达式中是必需的，但是在两个乘积中都这么做是一种很好的方式。相似地，使用long作为乘积的"第一个"数值也并不总是必需的， 但是这么做也是一种很好的形式。在两个计算中都以long数值开始可以很清楚地表明它们都不会溢出。下面的程序将打印出我们所期望的1000

第 3 天问题的总结

这个教训很简单：当你在操作很大的数字时，千万要提防溢出--它可是一个缄默杀手。 即使用来保存结果的变量已显得足够大，也并不意味着要产生结果的计算具有正确的类型。当你拿不准时，就使用long运算来执行整个计算。

语言设计者从中可以吸取的教训是：也许降低缄默溢出产生的可能性确实是值得做的一件事。这可以通过对不会产生缄默溢出的运算提供支持来实现。 程序可以抛出一个异常而不是直接溢出，就像Ada所作的那样，或者它们可以在需要的时候自动地切换到一个更大的内部表示上以防止溢出，就像Lisp所作的那样。 这两种方式都可能会遭受与其相关的性能方面的损失。 降低缄默溢出的另一种方式是支持目标确定类型，但是这么做会显著地增加类型系统的复杂度

今天的问题

它又会打印出什么呢？

public class Elementary{
    public static void main(String[] args){
        System.out.println(12345+5432l);
    }
}

请考虑下面这段话所描述的问题：

小明在超市购买了一个价值￥1.10的东西，但是他钱包中只有两元一张的钞票。如果他用一张两元的钞票支付，那么应该找给他多少零钱呢？

下面是一个试图解决上述问题的程序，它会打印出什么呢？

public class Change{
    public static void main(String args[]){
        System.out.println(2.00 - 1.10);
    }
}

第 2 天问题的解答

你可能会说，这不是很简单嘛！输出0.90。但实际的输出确实：0.8999999999999999。

原因

一、程序如何才能知道你想要打印小数点后两位小数呢？

JDK API文档中关于Double.toString的部分指出：

Double.toString的返回值，是足以将double类型的值与最靠近它的临近值区分出来的最短的小数，它在小数点之前和之后都至少有一位。

因此，看起来，该程序应该打印0.9是合理的。

二、并不是所有的小数都可以用二进制浮点数来精确表示的。

问题在于1.1这个数字不能被精确表示成为一个double，因此它被表示成为最接近它的double值。 该程序从2中减去的就是这个值。 遗憾的是，这个计算的结果并不是最接近0.9的double值。 表示结果的double值的最短表示就是你所看到的打印出来的那个可恶的数字。

第 2 天问题的解决办法

方法一

//拙劣的解决方案--仍旧是使用二进制浮点数
System.out.printf("%.2f%n",2.00 - 1.10);

这条语句打印的是正确的结果，但是这并不表示它就是对底层问题的通用解决方案。它使用的仍旧是二进制浮点数的double运算。 浮点运算在一个范围很广的值域上提供了很好的近似，但是它通常不能产生精确的结果。 二进制浮点对于货币计算是非常不适合的，因为它不可能将0.1--或者10的其它任何次负幂--精确表示为一个长度有限的二进制小数

方法二

System.out.println((200 - 110) + "分");

这是在Java中一种简单的解决方法。在Java标准库中，有一个类似的范例Date类，Date类的对于时间的内部表示就是一个以毫秒为单位的long整数。 对于像货币这样的数值，可以用int或long来表示。如果你采纳了解决方法，请确保该整数类型大到足够表示在程序中你将要用到的所有值。

方法三

import java.math.BigDecimal;

public class Change1{
    public static void main(String args[]){
        System.out.println(new BigDecimal("2.00").subtract(new BigDecimal("1.10")));
    }
}

解决该问题的另一种方式是使用执行精确小数运算的BigDecimal。 这里要告诫你一点： 一定要用BigDecimal(String)构造器，而千万不要用BigDecimal(double)。 后一个构造器将用它的参数的"精确"值来创建一个实例：new BigDecimal(1.1)将返回一个表示1.100000000000000055511151231257827021181583404541015625 的BigDecimal。

这个版本并不是十分地完美，因为Java并没有为BigDecimal提供任何语言上的支持。原因：

• 使用BigDecimal的计算很有可能比那些使用原始类型的计算要慢一些，对某些大量使用小数计算的程序来说，这可能会成为问题，而对大多数程序来说，这显得一点也不重要。
• Java不允许运算符重载。使得代码不够直观。

总结

在需要精确答案的地方，要避免使用float和double。

对于货币计算，要使用int、long或BigDecimal。

对于语言设计者来说，应该考虑对小数运算提供语言支持。可以支持下列方式中的一种。

• 提供对操作符重载的有限支持， 以使得运算符可以被塑造为能够对数值引用类型起作用， 例如BigDecimal。
• 提供原始的小数类型，就像 COBOL 与 PL/I 所作的一样。

今天的问题

被除数表示的是一天里的微秒数；而除数表示的是一天里的毫秒数。这个程序会打印出什么呢？

public class LongDivision{
    public static void main(String args[]){ 
        final long MICROS_PER_DAY = 24 * 60 * 60 * 1000 * 1000; 
        final long MILLIS_PER_DAY = 24 * 60 * 60 * 1000; 
        System.out.println(MICROS_PER_DAY/MILLIS_PER_DAY); 
    } 
} 

下面的方法意图确定它那唯一的参数是否是一个奇数。这个方法能够正确运转吗？

    public static boolean odd(int number) {
        return number % 2 == 1;
    }

第 1 天问题的解答

有1/4的情况下，答案是错误的。比如：odd(-3) 表达式得到的结果就是 fasle。对于所有的负奇数，上面的方法都会得到错误的结果。

原因

问题的原因在于求余操作符(%)，在Java中该操作符被定义为

对于所有的 int 数值 a 和所有的非零 int 数值 b，都满足下面的恒等式
(a / b) * b + (a % b) == a

换句话说，(a % b) = a - (a / b) * b

由数学推理运算可知，a % b 的符号有操作数a决定（要么为0，要么和a一致）。也就是说， -5 % 3 => -2， -5 % -3 => -2。

因此，对于所有的负奇数n， n % 2 => -1。问题中的方法自然有问题啦。

解决办法

要判断一个整数是否为奇数的解决办法有两种。

    public static boolean odd(int number) {
        return number % 2 != 0;
    }

    /**
     * 这种方法的性能更好。
     */
    public static boolean odd(int number) {
        return (number & 1) != 0;
    }

总结

无论你何时使用到了取余操作符，都要考虑到操作数和结果的符号。

该操作符的行为在其操作数非负时是一目了然的，但是当一个或两个操作数都是负数时，它的行为就不那么显而易见了。

今天的问题

请考虑下面这段话所描述的问题：

小明在超市购买了一个价值￥1.10的东西，但是他钱包中只有两元一张的钞票。如果他用一张两元的钞票支付，那么应该找给他多少零钱呢？

下面是一个试图解决上述问题的程序，它会打印出什么呢？

public class Change{
    public static void main(String args[]){
        System.out.println(2.00 - 1.10);
    }
}

    public static boolean odd(int number) {
        return number % 2 == 1;
    }

HTTP

HTTP就是一种请求/响应模式。

HTTP事务

1. 连接 建立和服务器的连接
2. 查询 请求服务器上的资源
3. 处理 服务器接受和处理请求
4. 响应 服务器将请求的资源发送回客户端
5. 终止 事务完成后，关闭连接，除非客户机与服务器之间立即发生另一事务。

用telnet程序验证这个过程

连接

80是HTTP协议默认的端口。

查询

↙表示回车。

在telnet中测试HTTP的POST是很麻烦的事。这里就不讲了，何况GET和POST很类似。

处理

Baidu服务器根据请求，处理请求。如果用的是Servlet，就是执行那个Servlet的doGet方法。

响应

终止

用telnet连接web服务器，连接会立马终止。如果用浏览器访问，浏览器会取得与页面有关的所有图像、样式表和脚本文件等，才终止连接。

HTTP查询和响应的消息格式

HTTP查询和响应的消息格式差不多。

后记

HTTP定义了查询和响应的消息格式。但每个浏览器和服务器在这种格式下，有自己定义的内容。服务器通过浏览器请求的消息，知道浏览器具体是什么型号的，是什么操作系统。这些具体怎么做的，下文分解

摘要

我们在写blog或写文档说明的时候，有时候说明在控制台中怎样使用，在windows xp/2000中就是cmd命令。 为了表达这种在控制台中的操作，我写了个 CSS来呈现效果。

需求和设计要求

1. 在网页文档中(blog或用户手册)，呈现一个控制台的样式，有边框和标题栏，黑色背景。如下图
2. 这个控制台可以真实的控制台那样可以，在适当的时候，有上下或左右滚动条
3. 控制台里允许加入的元素有<p>块。
4. 为了区分控制台里的输入和输出字符串，分别可以用<kbd>和<samp>括起来，然后设置他们的CSS样式
5. 当前目录提示符，用<span>元素表达。
6. <kbd>、<samp>和<span>元素只能包含在<p>元素中，不能直接在“控制台”中。

实现

• 控制台标题用背景图片实现
• 因为同时有标题和滚动条，所以为了不让滚动条覆盖部分标题，控制台至少要用两个<div>来表达，一个表示控制台边框，一个表示控制台里内容
• 控制台的宽度是固定的，高度有控制台的内容层表达

CSS

HTML

可以在<div class="console" ...>中设置高度来设置控制台的高度。

后记

一个控制台的效果基本出来了。在IE6和Firefox中测试通过。还有工作可做

• 为了区分控制台中的输入和输出，建议用<kbd>和<samp>标签，并设置这写标签的CSS样式。
• 更改标题栏图标和设置一下CSS样式，就可以实现Linux或Mac等操作系统中的控制台效果
• 还有一些没遇到和想到的问题

这是我第一次用Blog，还不知道上传。这些源代码和图片的，请留下EMail，或等我熟悉了Blog再下载。