vickzhu

velocity properties加载时是放在HashMap中的，首先会加载configLocation中指定文件的内容，然后加载VelocityConfigurer中通过velocityProperties配置的属性，
因此，在VelocityConfigurer中配置的属性会覆盖configLocation指定文件中的属性

1、达到默认最大buffer size
2、调用HttpServletResponse.flushBuffer()
3、调用HttpServletResponse.getOutputStream().flush()或者HttpServletResponse.getWriter().flush()
4、调用HttpServletResponse.sendError()或者HttpServletResponse.sendRedirect()

在onPrepareDialog()中添加如下代码:

1. 类图之间的关系
依赖和关联关系：
依赖:是类与类之间的连接，表示一个类依赖于另一个类的定义。例如如果A依赖于B，则B体现为局部变量，方法的参数、或静态方法的调用。 
关联:类与类之间的联接，它使一个类知道另一个类的属性和方法， 具体表现为类的成员变量中包含某个对象 

组合和聚合：
在有整体和部分关系是才有组合和聚合的概念，属于关联关系
组合：部分离开整体不能存在
聚合：部分可以离开整体而存在


2. 用例图之间的关系：
包含、泛化、扩展
包含：当两个或多个用例中共用一组相同的动作，这时可以将这组相同的动作抽出来作为一个独立的子用例，供多个基用例所共享。因为子用例被抽出，基用例并非一个完整的用例，所以include关系中的基用例必须和子用例一起使用才够完整，子用例也必然被执行 
泛化：继承关系，子用例将继承基用例的所有行为 ，也就是说在任何使用基用例的地方都可以用子用例来代替。领导拥有审批的权限，而请假申请审批、加班申请审批都是审批的子类
扩展：对基用例的扩展，基用例是一个完整的用例，即使没有子用例的参与，也可以完成一个完整的功能。 

学习osworkflow
http://my.so-net.net.tw/idealist/OSWorkflow/ 

wfentry表中的state字段来自于接口WorkflowEntry，有如下几个值：

在页面中显示某字段时，字段值过长会导致页面样式错乱，这时候我们需要对值进行截取，当截取值时会碰到以下问题：
1、如果按字符截取会导致中英文显示的长度不一
2、如果按字节截取可能会导致最后一个中文截成两部分
以下代码是在网上获取并经过改造而成，能够很好的解决上面两个问题
    /**
     * 根据指定字节数截取字符串,当指定处为中文第一个字节时少截取一个字符,当长度大于指定截取长度时,截取后在字符串末尾追加指定字符串<br/>
     * 这里添加了字符串的编码，因为页面的编码不同，字符串所占字节也不同
     *
     * @param str 待截取字符串,如果为null或者"",则立即返回str
     * @param length 需要截取的长度
     * @param endStr 截取后末尾追加的字符串
     * @param charset 待截取字符串的编码
     * @return
     */
    public String subStringByByte(String str, int length, String endStr, String charset) {
        if (str == null || "".equals(str.trim()) || length <= 0) {
            return str;
        }
        try {
            int strlen = str.getBytes(charset).length;// 这里要和页面的编码相关
            if (strlen < length) return str;
            Pattern p = Pattern.compile("^[""u4e00-""u9fa5]$");
            int i = 0, j = 0;
            int sublength = length - ((endStr == null) ? 0 : endStr.getBytes(charset).length);
            for (char c : str.toCharArray()) {
                Matcher m = p.matcher(String.valueOf(c));
                i += m.find() ? 2 : 1;
                ++j;
                if (i == sublength) break;
                if (i > sublength) {
                    --j;
                    break;
                }
            }
            return str.substring(0, j) + endStr;
        } catch (UnsupportedEncodingException e) {
            return str;
        }
    }

英文不太好，经常忘记，所以现在写下来：
1，transient：在序列化一个类时，如果类中某个字段不想被序列化，则使用此关键字
2、volatile：用于线程同步时

根据分代收集器原理(可以参考垃圾回收机制分类),JVM的内存可分为三个域: 新域、旧域以及永久域
JVM生成的所有新对象放在新域中。一旦对象经历了一定数量的垃圾收集循环后，便进入旧域。而在永久域中是用来存储JVM自己的反射对象的，如class 和method对象，而且GC(Garbage Collection)不会在主程序运行期对永久域进行清理。其中新域和旧域属于堆，永久域是一个独立域并且不认为是堆的一部分
一、java.lang.OutOfMemoryError: PermGen space

PermGen space的全称是Permanent Generation space,是指内存的永久保存区域,
这块内存主要是被 JVM存放Class和Method信息的,Class在被Loader时就会被放到PermGen space中,
它和存放类实例 (Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对
PermGen space进行清理，所以如果你的应用中有很多CLASS的话,就很可能出现PermGen space错误,
这种错误常见在web服务器对 JSP进行pre compile(预编译)的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小
超过了jvm默认的大小(4M)那么就会 产生此错误信息了。
解决方法： 手动设置MaxPermSize大小

修改TOMCAT_HOME/bin/catalina.sh
在“echo "Using CATALINA_BASE:   $CATALINA_BASE"”上面加入以下行：
JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
建议：将相同的第三方jar文件移置到tomcat/shared/lib目录下，这样可以达到减少 jar 文档重复占用内存的目的。

二、java.lang.OutOfMemoryError: Java heap space
Heap size 设置
JVM堆 的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，
其初始空间(即 -Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可
进行设 置。Heap size 的大小是Young Generation 和Tenured Generaion 之和(新域和旧域之和)。
提示：在JVM中如果98％ 的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。
提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。
解决方法：手动设置 Heap size
修改TOMCAT_HOME/bin/catalina.sh
在“echo "Using CATALINA_BASE:   $CATALINA_BASE"”上面加入以下行：
JAVA_OPTS="-server -Xms800m -Xmx800m   -XX:MaxNewSize=256m"

动态应用，是相对于网站静态内容而言， 是指以c/c++、php、Java、perl、.net等 服务器端语言开发的网络应用软件，比如论坛、网络相册、交友、BLOG等常见应用。动态应用系统通 常与数据库系统、缓存系统、分布式存储系统等密不可分。

大型动态应用系统平台主要是针对于大流 量、高并发网站建立的底层系统架构。大型网站的运行需要一个可靠、安全、可扩展、易维护的应用系统平台做为支撑，以保证网站应用的平稳运行。

大型动态应用系统又可分为几个子系统：

l         Web前端系统

l         负载均衡系统

l         数据库集群系统

l         缓存系统

l         分布式存储系统

l         分布式服务器管理系统

l         代码分发系统

Web前端系统

结构图：

为了达到不同应用的服务器共享、避免单点故障、集中管理、统一配置等目的，不以应用划分服 务器，而是将所有服务器做统一使用，每台服务器都可以对多个应用提供服务，当某些应用访问量升高时，通过增加服务器节点达到整个服务器集群的性能提高，同 时使他应用也会受益。该Web前端系统基于Apache/Lighttpd/Eginx等 的虚拟主机平台，提供PHP程序运行环境。服务器对开发人员是透明的，不需要开发人员介入服务器管理

负载均衡系统

负载均衡系统分为硬件和软件两种。硬件负载均衡效率高，但是价格贵，比如F5等。软件负载均衡系统价格较低或者免费，效率较硬件负载均衡系统 低，不过对于流量一般或稍大些网站来讲也足够使用，比如lvs,nginx。大多数网站都是硬件、软件负载均衡系统并用。

数据库集群系统

结构图：

由于Web前端采用了负载均衡集群结构提高了服务的有效性和扩展性，因此数据库必须也是高可靠的才能保证整个服务体系的高可靠性，如何构建一个高可靠的、可以提供大规模并发处理的数据库体系？

我们可以采用如上图所示的方案：

1)        使用 MySQL 数据库，考虑到Web应用的数据库读多写少的特点，我们主要对读数据库做了优化，提供专用的读数据库和写数据库，在应用程序中实现读操作和写操作分别访问不同的数据库。

2)        使用 MySQL Replication 机制实现快速将主库（写库）的数据库复制到从库（读库）。一个主库对应多个从库，主库数据实时同步到从库。

3)        写数据库有多台，每台都可以提供多个应用共同使用，这样可以解决写库的性能瓶颈问题和单点故障问题。

4)        读数据库有多台，通过负载均衡设备实现负载均衡，从而达到读数据库的高性能、高可靠和高可扩展性。

5)        数据库服务器和应用服务器分离。

6)        从数据库使用BigIP做负载均衡。

缓存系统

缓存分为文件缓存、内存缓存、数据库缓存。在大型Web应用中使用最多且效率最高的是内存缓存。最常用的内存缓存工具是Memcachd。使用正确的缓存系统可以达到实现以下目标：

1、   使用缓存系统可以提高访问效率，提高服务器吞吐能力，改善用户体验。

2、   减轻对数据库及存储集服务器的访问压力

3、Memcached服务器有多台，避免单点故障，提供高可靠性和可扩展性，提高性能。

分布式存储系统

结构图：

WEB系统平台中的存储需求有下面两个特点：

1) 存储量很大，经常会达到单台服务器无法提供的规模，比如相册、视频等应用。因此需要专业的大规模存储系统。

2) 负载均衡cluster中的每个节点都有可能访问任何一个数据对象，每个节点对数据的处理也能被其他节点共享，因此这些节点要操作的数据从逻辑上看只能是一个整体，不是各自独立的数据资源。

因此高性能的分布式存储系统对于大型网站应用来说是非常重要的一环。（这个地方需要加入对某个分布式存储系统的简单介绍。）

分布式服务器管理系统

结构图：

随着网站访问流量的不断增加，大多的网络服务都是以负载均衡集群的方式对外提供服务，随之集群规模的扩大，原来基于单机的服务器管理模式已经不能够满足我们的需求，新的需求必须能够集中式的、分组的、批量的、自动化的对服务器进行管理，能够批量化的执行计划任务。

在分布式服务器管理系统软件中有一些比较优秀的软件，其中比较理想的一个是 Cfengine。它可以对服务器进行分组，不同的分组可以分别定制系统配置文件、计划任务等配置。它是基于C/S 结构的，所有的服务器配置和管理脚本程序都保存在Cfengine Server上，而被管理的服务器运行着 Cfengine Client 程序，Cfengine Client通过SSL加密的连接定期的向服务器端发送请求以获取最新的配置文件和管理命令、脚本程序、补丁安装等任务。

有了Cfengine 这种集中式的服务器管理工具，我们就可以高效的实现大规模的服务器集群管理，被管理服务器和 Cfengine Server 可以分布在任何位置，只要网络可以连通就能实现快速自动化的管理。

代码发布系统

结构图：

随着网站访问流量的不断增加，大多的网络服务都是以负载均衡集群的方式对外提供服务，随之集群规模的扩大，为了满足集群环境下程序代码的批量分发和更新，我们还需要一个程序代码发布系统。

这个发布系统可以帮我们实现下面的目标：

1) 生产环境的服务器以虚拟主机方式提供服务，不需要开发人员介入维护和直接操作，提供发布系统可以实现不需要登陆服务器就能把程序分发到目标服务器。

2) 我们要实现内部开发、内部测试、生产环境测试、生产环境发布的4个开发阶段的管理，发布系统可以介入各个阶段的代码发布。

3) 我们需要实现源代码管理和版本控制，SVN可以实现该需求。

这里面可以使用常用的工具Rsync，通过开发相应的脚本工具实现服务器集群间代码同步分发。

管道："|"
    将一个命令的输出作为下一个命令的输入
    例：ls | grep text            --这个命令将查找当前目录下名称中包含text的目录或者文件
xargs：
    将一个命令的输入作为下一个命令的参数
    例：ls | xargs grep -i text        --这个命令将当前目下的所有文件作为参数传递给grep来查找文件中是否包含"text" 
         find . | xargs grep "user"    --查询当前目录及其子目录下所有内容中包含"user"的文件

mysql：select * from 表名 order by rand() limit 10;
sql server：select top 10 * from 表名 order by newid();
oracle：select * from(select * from 表名 order by dbms_random.value) where rownum<=20;
access：select top 10 * from 表名 order by rnd(ID)

样式代码如下：
html { filter:progid:DXImageTransform.Microsoft.BasicImage(grayscale=1); }
需要最新网页标准支持：
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
Flash要在object标签中加入如下代码：
<param value="false" name="menu"/>
<param value="opaque" name="wmode"/>

1、下载wamp5，安装wamp5，如需更改端口请修改Apache配置文件，更改端口(如：8888)后还需要更改wamp根目录wampmanager.ini文件中的以下地方
    Type: item; Caption: "Localhost"; Action: run; FileName: "C:\WINDOWS\explorer.exe"; Parameters: "http://localhost:8888/"; Glyph: 5
    Type: item; Caption: "phpMyAdmin"; Action: run; FileName: "C:\WINDOWS\explorer.exe"; Parameters: "http://localhost:8888/phpmyadmin/"; Glyph: 5
    Type: item; Caption: "SQLiteManager"; Action: run; FileName: "C:\WINDOWS\explorer.exe"; Parameters: "http://localhost:8888/sqlitemanager/"; Glyph: 5
2、安装后访问首页http://localhost:8888，点击phpinfo()查看php信息，如果只显示如下信息：
    This program makes use of the Zend Scripting Language Engine:
    Zend Engine v2.2.0, Copyright (c) 1998-2007 Zend Technologies
    查看php目录下的php.ini文件，没有[Zend]块，表明ZendOptimizer没有安装
3、下载ZendOptimizer，安装路径选择D:\Program Files\Zend，选择apache2.x及php.ini的位置，安装完成后php.ini最后会添加以下内容：
    [Zend]
    zend_extension_manager.optimizer_ts="D:\Program Files\Zend\ZendOptimizer-3.3.0\lib\Optimizer-3.3.0"
    zend_extension_ts="D:\Program Files\Zend\ZendOptimizer-3.3.0\lib\ZendExtensionManager.dll"
4、访问http://loalhost:8888/ppframe进行ppframe的安装，安装成功后登陆后台，如果没有安装ZendOptimizer，左侧的exam是打不开的，但是passport可以打开。

1、如果页面有<base/>标签的则要在js引入后再添加<base target="_self" />;

2、在<script/>中添加属性defer="defer";

比如java向txt文件中写入新的一行时，java获得文本输入框中的新行时等
Unix系统里，每行结尾只有“<换行>”，即“\r”；
Windows系统里面，每行结尾是“<换行><回车>”，即“\r\n”；
Mac系统里，每行结尾是“<回车>”，即“\n”。
一个直接后果是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；
而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号。

如果已经配置mysql的环境变量，请直接执行：mysql -u 输入用户名 -p 回车 之后输入密码
如果未配置环境变量请先进入mysql的bin目录下
执行如下语句导入：source 输入sql文件的位置
执行如下语句导出：mysqldump -u输入用户名 -p输入密码 数据库名 表名 >文件名.sql

服务端：http://labs.northscale.com/memcached-packages/
客户端：http://code.google.com/p/memcached/wiki/Clients/

1、安装jdk --> D:\Program Files\Java\jdk1.5.0
2、配置JAVA_HOME --> D:\Program Files\Java\jdk1.5.0
3、解压tomcat5.5 --> D:\Program Files\Apache Software Foundation\Tomcat 5.5
4、打开cmd，进入到tomcat5.5bin目录 --> D:\Program Files\Apache Software Foundation\Tomcat 5.5\bin>
5、执行命令：service install tomcat
        执行结果为：
            Installing the service 'tomcat' ...
            Using CATALINA_HOME:    D:\Program Files\Apache Software Foundation\Tomcat 5.5
            Using CATALINA_BASE:    D:\Program Files\Apache Software Foundation\Tomcat 5.5
            Using JAVA_HOME:        D:\Program Files\Java\jdk1.5.0
            Using JVM:              D:\Program Files\Java\jdk1.5.0\jre\bin\server\jvm.dll
            The service 'tomcat' has been installed.
        此时产生名为：Apache Tomcat tomcat 的服务
6、卸载命令：service remove tomcat
        执行结果为：
            The service 'tomcat' has been removed

@echo off
rem 这段代码的作用是对mysql进行查询操作，并将查询结果写入到result.txt文件中
echo %TIME%
set errorlevel=0
set path_bin_mysql="D:\Program Files\mysql_1\bin\mysql"
set host=localhost
set port=3308
set database_mysql=mysql
set user_mysql=root
set password_mysql=admin
%path_bin_mysql% -u%user_mysql% -p%password_mysql% -h%host% -P%port% %database_mysql%< test.sql >

result.txt
pause

千万人同时访问的网站，一般是有很多个数据库同时工作，说明白一点就是数据库集群和并发控制，这样的网站实时性也是相对的。这些网站都有一些共同的特点：数据量大，在线人数多，并发请求多，pageview高，响应速度快。总结了一下各个大网站的架构，主要提高效率及稳定性的几个地方包括：

　　1、程序

　　程序开发是一方面，系统架构设计（硬件+网络+软件）是另一方面。

　　软件架构方面，做网站首先需要很多web服务器存储静态资源，比如图片、视频、静态页等，千万不要把静态资源和应用服务器放在一起。

　　一个好的程序员写出来的程序会非常简洁、性能很好，一个初级程序员可能会犯很多低级错误，这也是影响网站性能的原因之一。

　　网站要做到效率高，不光是程序员的事情，数据库优化、程序优化这是必须的，在性能优化上要数据库和程序齐头并进！缓存也是两方面同时入手。第一，数据库缓存和数据库优化，这个由dba完成（而且这个有非常大的潜力可挖，只是由于我们都是程序员而忽略了他而已）。第二，程序上的优化，这个非常的有讲究，比如说重要一点就是要规范ＳＱＬ语句，少用in 多用or，多用preparestatement，另外避免程序冗余如查找数据少用双重循环等。另外选用优秀的开源框架加以支持，我个人认为中后台的支持是最最重要的，可以选取spring＋ibatis。因为ibatis直接操作SQL并有缓存机制。spring的好处就不用我多说了，ＩＯＣ的机制可以避免new对象，这样也节省开销。据我分析，绝大部分的开销就是在NEW的时候和连接数据库时候产生的，请尽量避免。另外可以用一些内存测试工具来做一个demo说明hibernate和ibatis谁更快！前台你想用什么就用什么，struts,webwork都成，如果觉得自己挺牛X可以试试tapestry。

　　用数据库也未必不能解决访问量巨大所带来的问题，作成静态文件硬盘的寻址时间也未必少于数据库的搜索时间，当然对资料的索引要下一翻工夫。我自己觉得门户往往也就是当天、热门的资料点击率较高，将其做缓存最多也不过1~2G的数据量吧，举个例子：

拿网易新闻来http://news.163.com/07/0606/09/3GA0D10N00011229.html

　　格式化一下，方便理解：http://域名/年/月日/新闻所属分类/新闻ID.html

　　可以把当天发布的、热门的、流揽量大的作个缓寸，用hashtable（key：年-月-日-分类-ID，value：新闻对象），静态将其放到内存（速度绝对快过硬盘寻址静态页面）。

通常是采用oracle存储过程＋2个weblogic，更新机制也几乎一样每签发一条新闻，就会生成静态页面，然后发往前端的web服务器，前端的web都是做负载均衡的。另外还有定时的程序，每5-15分钟自动生成一次。在发布新闻的同时将数据缓存。当然缓存也不会越来越大，在个特定的时间段（如凌晨）剔除过期的数据。做一个大的网站远没有想象中那么简单，服务器基本就要百十个的。

　　这样可以大大增加一台计算机的处理速度，如果一台机器处理不了，可以用httpserver集群来解决问题了。


　　2、网络
　　中国的网络分南北电信和网通，访问的ip就要区分南北进入不同的网络。


　　3、集群
　　通常会使用CDN与GSBL与DNS负载均衡技术，每个地区一组前台服务器群，例如：网易，百度使用了DNS负载均衡技术，每个频道一组前台服务器，一搜使用了DNS负载技术，所有频道共用一组前台服务器集群。

　　网站使用基于Linux集群的负载均衡，失败恢复，包括应用服务器和数据库服务器，基于linux-ha的服务状态检测及高可用化。

　　应用服务器集群可以采用apache+tomcat集群和weblogic集群等；web服务器集群可以用反向代理，也可以用NAT的方式，或者多域名解析都可以；Squid也可以，方法很多，可以根据情况选择。

　4、数据库

　　因为是千万人同时访问的网站，所以一般是有很多个数据库同时工作的，说明白一点就是数据库集群和并发控制，数据分布到地理位置不同的数据中心，以免发生断电事故。另外还有一点的是，那些网站的静态化网页并不是真的，而是通过动态网页与静态网页网址交换做出现的假象，这可以用urlrewrite 这样的开源网址映射器实现。这样的网站实时性也是相对的，因为在数据库复制数据的时候有一个过程，一般在技术上可以用到hibernate和 ecache，但是如果要使网站工作地更好，可以使用EJB和websphere，weblogic这样大型的服务器来支持，并且要用oracle这样的大型数据库。

　　大型门户网站不建议使用Mysql数据库，除非你对Mysql数据的优化非常熟悉。Mysql数据库服务器的master-slave模式，利用数据库服务器在主从服务器间进行同步，应用只把数据写到主服务器，而读数据时则根据负载选择一台从服务器或者主服务器来读取，将数据按不同策略划分到不同的服务器（组）上，分散数据库压力。

　　大型网站要用oracle，数据方面操作尽量多用存储过程，绝对提升性能；同时要让DBA对数据库进行优化，优化后的数据库与没优化的有天壤之别；同时还可以扩展分布式数据库，以后这方面的研究会越来越多；


　　5、页面

　　从开始就考虑使用虚拟存储/簇文件系统。它能让你大量并行IO访问，而且不需要任何重组就能够增加所需要的磁盘。

　　页面数据调用更要认真设计，一些数据查询可以不通过数据库的方式，实时性要求不高的可以使用lucene来实现，即使有实时性的要求也可以用lucene，lucene+compass还是非常优秀的。

　　新闻类的网站可以用静态页存储，采用定时更新机制减轻服务器负担；首页每个小模块可以使用oscache缓存，这样不用每次都拉数据。

　　前端的基于静态页面缓存的web加速器，主要应用有squid等。squid 将大部分静态资源(图片，js，css等）缓存起来，直接返回给访问者，减少应用服务器的负载网站的静态化网页并不是真的，而是通过动态网页与静态网页网址交换做出现的假象，这可以用urlrewrite这样的开源网址映射器实现，后缀名为htm或者html并不能说明程序生成了静态页面，可能是通过 url重写来实现的，为的只不过是在搜索引擎中提升自己网站的覆盖面积罢了。

　　生成静态页面的服务器和www服务器是两组不同的服务器，页面生成后才会到www服务器，一部分数据库并不是关系数据库，这样更适合信息衍生，www、mail服务器、路由器多，主要用负载平衡解决访问瓶颈。

　　静态页面的缺点：

　　1) 增加了程序的复杂度

　　2) 不利于管理资料

　　3) 速度不是最快

　　4) 伤硬盘

　　6、缓存

　　从一开始就应该使用缓存，高速缓存是一个更好的地方存储临时数据，比如Web站点上跟踪一个特定用户的会话产生的临时文件，就不再需要记录到数据库里。

　　不能用lucene实现的可以用缓存，分布式缓存可以用memcached，如果有钱的话用10来台机器做缓存，> 10G的存储量相信存什么都够了；如果没钱的话可以在页面缓存和数据缓存上下功夫，多用OSCACHE和EHCACHE，SWARMCACHE也可以，不过据说同步性不是很好；

　　可以使用Memcache进行缓存，用大内存把这些不变的数据全都缓存起来，而当修改时就通知cache过期，memcache是LJ开发的一款分布式缓存产品，很多大型网站在应用，我们可以把Cache Server与AppServer装在一起。因为Cache Server对CPU消耗不大，而有了Cache Server的支援，App Server对内存要求也不是太高，所以可以和平共处，更有效的利用资源。

将response内响应给使用者的内容，使用GZIP压缩的方式回传给浏览器，而IE5和NS6也都有支持Gzip的压缩格式。
这个方法在之前就有人提出过，因为是让网页在输出时经过压缩，可以让传输量变小很多，虽然现在的网络频宽对于用来看网页已经绰绰有余，但是档案大小太大的网页还是会造成一定的影响。
经过Gzip压缩过的网页，档案大小可以到原本压缩前的20%。

package com.jsptw.filter;
import java.io.*;
import java.util.zip.GZIPOutputStream;
import javax.servlet.*;
import javax.servlet.http.*;
public class GZIPEncodeFilter implements Filter {
      public void init(FilterConfig filterConfig) {}
      public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain)
                                      throws IOException, ServletException {       
        String transferEncoding = getGZIPEncoding((HttpServletRequest)request);       
        if (transferEncoding == null) {           
          chain.doFilter(request, response);       
        } else{         
          ((HttpServletResponse)response).setHeader("Content-Encoding", transferEncoding);
            GZIPEncodableResponse wrappedResponse = new GZIPEncodableResponse((HttpServletResponse)response);
            chain.doFilter(request, wrappedResponse);         
            wrappedResponse.flush();       
        }   
      }   
      public void destroy() {}   
      private static String getGZIPEncoding(HttpServletRequest request) {       
        String acceptEncoding = request.getHeader("Accept-Encoding");       
          if (acceptEncoding == null)
            return null;       
          acceptEncoding = acceptEncoding.toLowerCase();       
          if (acceptEncoding.indexOf("x-gzip") >= 0) {
            return "x-gzip";
          }       
          if (acceptEncoding.indexOf("gzip") >= 0) {           
            return "gzip";       
          }       
          return null;   
      }   
     
      private class GZIPEncodableResponse extends HttpServletResponseWrapper {       
        private GZIPServletStream wrappedOut;       
          public GZIPEncodableResponse(HttpServletResponse response) throws IOException {          
            super(response);           
              wrappedOut = new GZIPServletStream(response.getOutputStream());       
          }       
          public ServletOutputStream getOutputStream() throws IOException {           
            return wrappedOut;       
          }       
          private PrintWriter wrappedWriter;       
          public PrintWriter getWriter() throws IOException {           
            if (wrappedWriter == null) {               
                wrappedWriter = new PrintWriter( new OutputStreamWriter( getOutputStream(), getCharacterEncoding()));            }           
                 return wrappedWriter;       
              }       
          public void flush() throws IOException {           
            if (wrappedWriter != null) {              
                wrappedWriter.flush();           
              }          
              wrappedOut.finish();       
          }   
      }   
     
      private class GZIPServletStream extends ServletOutputStream {       
        private GZIPOutputStream outputStream;       
          public GZIPServletStream(OutputStream source) throws IOException {           
         outputStream = new GZIPOutputStream(source);       
       }       
       public void finish() throws IOException {
         OutputStream.finish();       
       }       
      public void write(byte[] buf) throws IOException {           
        outputStream.write(buf);       
      }       
      public void write(byte[] buf, int off, int len) throws IOException {           
        outputStream.write(buf, off, len);       
      }       
      public void write(int c) throws IOException {           
        outputStream.write(c);       
      }       
      public void flush() throws IOException {           
        outputStream.flush();       
      }      
      public void close() throws IOException {           
        outputStream.close();        
      }   
    }
}

web.xml中的设定为：
<filter>       
<filter-name>GZIPEncoder</filter-name>       
<filter-class>com.jsptw.filter.GZIPEncodeFilter</filter-class>
</filter>

<filter-mapping> 
<filter-name> GZIPEncoder</filter-name> 
<url-pattern>/*</url-pattern>
</filter-mapping> 

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/a_heng/archive/2009/09/22/4579979.aspx

一 简单加密(不可逆)：
        MD5(信息摘要算法,Message Digest)，SHA(安全散列算法,Secure Hash,Algorithm)、HMAC(散列消息鉴别码,Hash Message Authentication Code)

二 复杂算法：
        1、对称加密：加密解密使用相同的密钥：DES(Data Encryption Standard，数据加密算法) 、IDEA、RC2、RC4、SKIPJACK
        2、非对称加密：分为公开密钥(publickey)和私有密钥(privatekey)，且公开密钥与私有密钥是一对。非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。非对称加密算法的保密性比较好，它消除了最终用户交换密钥的需要，但加密和解密花费时间长、速度慢，它不适合于对文件加密而只适用于对少量数据进行加密。经典的非对称加密算法如RSA(三个人名：Ron Rivest, AdiShamir 和Leonard Adleman)算法等安全性都相当高。

Insert是T-sql中常用语句，Insert INTO table(field1,field2,...) values(value1,value2,...)这种形式的在应用程序开发中必不可少。但我们在开发、测试过程中，经常会遇到需要表复制的情况，如将一个table1的数据的部分字段复制到table2中，或者将整个table1复制到table2中，这时候我们就要使用SELECT INTO 和 INSERT INTO SELECT 表复制语句了。

      1.INSERT INTO SELECT语句

      语句形式为：Insert into Table2(field1,field2,...) select value1,value2,... from Table1

      要求目标表Table2必须存在，由于目标表Table2已经存在，所以我们除了插入源表Table1的字段外，还可以插入常量。示例如下：

INSERT INTO SELECT语句复制表数据

   --1.创建测试表

    create TABLE Table1

    (

        a varchar(10),

        b varchar(10),

        c varchar(10),

        CONSTRAINT [PK_Table1] PRIMARY KEY CLUSTERED

        (

            a ASC

        )

    ) ON [PRIMARY]

    create TABLE Table2

    (

        a varchar(10),

        c varchar(10),

        d int,

        CONSTRAINT [PK_Table2] PRIMARY KEY CLUSTERED

        (

            a ASC

        )

    ) ON [PRIMARY]

    GO

    --2.创建测试数据

    Insert into Table1 values('赵','asds','90')

    Insert into Table1 values('钱','asds','100')

    Insert into Table1 values('孙','asds','80')

    Insert into Table1 values('李','asds',null)

    GO

    select * from Table2

    --3.INSERT INTO SELECT语句复制表数据

    Insert into Table2(a, c, d) select a,c,5 from Table1

    GO

    --4.显示更新后的结果

    select * from Table2

    GO

    --5.删除测试表

    drop TABLE Table1

    drop TABLE Table2

      2.SELECT INTO FROM语句

      语句形式为：SELECT vale1, value2 into Table2 from Table1

      要求目标表Table2不存在，因为在插入时会自动创建表Table2，并将Table1中指定字段数据复制到Table2中。示例如下：

SELECT INTO FROM创建表并复制表数据

   --1.创建测试表

    create TABLE Table1

    (

        a varchar(10),

        b varchar(10),

        c varchar(10),

        CONSTRAINT [PK_Table1] PRIMARY KEY CLUSTERED

        (

            a ASC

        )

    ) ON [PRIMARY]

    GO

    --2.创建测试数据

    Insert into Table1 values('赵','asds','90')

    Insert into Table1 values('钱','asds','100')

    Insert into Table1 values('孙','asds','80')

    Insert into Table1 values('李','asds',null)

    GO

    --3.SELECT INTO FROM语句创建表Table2并复制数据

    select a,c INTO Table2 from Table1

    GO

    --4.显示更新后的结果

    select * from Table2

    GO

    --5.删除测试表

    drop TABLE Table1

    drop TABLE Table2

用于指定服务器上可以使用该COOKIE的文件所在的路径,它只对该网址下的该路径下的应用起作用."/"表示服务器上所有目录都可以使用该COOKIE.

页面如果用到Ext最好不要在body有任何文字输出，不然的话ext会报一个错误！

对象不支持此属性或方法
ext-all.js                                        行：9

郁闷了两天了，spring+hibernate查询数据，sql语句在数据库里试过了是正确的，数据库里有数据，但是就是查不出数据。后来仔细看日志文件，恍然大悟，原来是整形字段赋值为null，
Null value was assigned to a property of primitive type setter of com.*.*.*.age

1、得到record中的某个字段：record.get("字段名称")
2、得到form中的某个字段值：this.form.findField("字段名称").getValue()
3、从reader中得到root指定的字段除外的字段：store.reader.jsonData.字段名称
4、关于combobx
    valueField  ：  设置值
    displayField  ：设置显示的值
    hiddenName ：动态产生一个隐藏字段，以便表单提交的时候一起提交，事实上valueField和displayField在表单提交中没有启任何作用，往往指定hiddenName就行，如果在combobox中找到hiddenName匹配的值，则将匹配的值显示出来，因此，细心的朋友可以发现，在将选择的记录赋给combobox所在的form时(this.form.loadRecord(record))，在combobox里首先会显示出hiddenName指定的值(一般是id)，在combobox的store加载完后，如果找到匹配的值则会显示匹配的值，中间有个值的变化过程！引申一下，如果我们combobox下拉框里用的是树，则hiddenName肯定是找不到匹配项的(Ext总是会在原始combobox下拉项中匹配，而现在下拉项换成了树)，因此combobox会一直显示hiddenName的值(即一个id值)。在这种情况下我们就需要手动指定combobox的显示值，具体方法是在combobox的load事件中用setRawValue指定。注意这里不能用setValue指定，因为在使用hiddenName的情况下，setValue首先将值赋给隐藏字段，如果在combobox中找到匹配项则显示匹配项的值，如果没有匹配的值就显示setValue的值。

apache common Pool 对象池
apache common dbcp 数据库连接池
common dbcp依赖 common pool

一、Ignoring namespace handler [org.springframework.ejb.config.JeeNamespaceHandler]: handler class not found
        需要添加spring-remoting.jar包，具体路径为：MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.springframework_6.0.1.zmyeclipse601200710\data\2.0\dist\modules
二、org.springframework.scripting.config.LangNamespaceHandler
        添加spring-support.jar包，具体路径为：MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.springframework_6.0.1.zmyeclipse601200710\data\2.0\dist\modules

解决两种情况下的用户访问超时。
a）普通http请求的session超时。
b）异步http请求的session超时，使用ext后大部分的界面刷新都是异步的ajax请求。

不管是那种类型的http请求总是可以由一个过滤器来捕捉。
分类：普通http请求的header参数中没有x-requested-with:XMLHttpRequest头信息，而异步的有。
其实对于常见的ajax框架，header中还有标示自己身份的header信息。

对于普通的http请求，发现session超时后直接重定向到一个超时页面，显示访问超时。
对于异步http请求，发现session超时后则向请求的response中写入特定的超时头信息，客户端ajax对象检测
头信息，发现有超时状态标志后调用显示超时信息的javascript方法，提示用户访问超时。

服务器端session超时后在过滤器中为response添加新的头信息，标记该请求超时：

if(r.getHeader("x-requested-with")!=null
&& r.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")){
response.setHeader("sessionstatus","timeout");
}

使用Ext.Ajaxt对象完成异步请求的交互，Ext.Ajax是单实例对象（非常重要，全局单一Ext.Ajax实例！）。
注册Ext.Ajax的requestcomplete事件，每个ajax请求成功后首先响应该事件。在该事件的回调函数里面判断
访问请求是否超时。使用Ext.Ajax对象的好处是，只需要引入一个包含了几行超时处理代码的js文件，就可以
为当前应用增加超时处理功能，原有代码不需要做任何修改。

使用Ext.Ajaxt对象完成异步请求交互，假如checkUserSessionStatus是你的回调方法，每个页面引用：

Ext.Ajax.on('requestcomplete',checkUserSessionStatus, this);
function checkUserSessionStatus(conn,response,options){
//Ext重新封装了response对象
if(typeof response.getResponseHeader.sessionstatus != 'undefined'){
//发现请求超时，退出处理代码...
}
}

可以利用的几个特性：
a）所有的ajax请求均带有x-requested-with:XMLHttpRequest头信息
b）Ext.Ajax是单实例对象（非常重要，全局单一Ext.Ajax实例！）
c）注册Ext.Ajax的requestcomplete事件，每个ajax请求成功后首先响应该事件（概念类似spring的aop拦截）。 

jquery提供了几个全局事件可以用来处理session过期请求，如当ajax请求开始时会触发ajaxStart()方法的回调函数；
当ajax请求结束时，会触发ajaxStop()方法的回调函数。这些方法都是全局的方法，因此无论创建它们的代码位于何处，
只要有ajax请求发生时，都会触发它们。类似的事件还有：ajaxComplete(),ajaxError(),ajaxSend(),ajaxSuccess()等。

如果使某个ajax请求不受全局方法的影响，那么可以在使用$.ajax()方法时，将参数中的global设置为false，jquery代码如下：
$.ajax({
    url:"test.html",
    global:false//不触发全局ajax事件


})

 对于其他的ajax框架，解决用户访问请求超时这个问题的思路是类似的。

在这里推荐一个很实用的Js方法：

function getRootWin(){
var win = window;
while (win != win.parent){
win = win.parent;
}
return win;
}

 

通过该方法，可以在一个任意深度的iframe中调用父iframe中的方法。具体到这里就是无论哪一个iframe中的用户访

问请求超时，都可以通过该方法调用最外层iframe中的退出方法，这样便为用户提供了一个统一的访问超时退出的UI

呈现。

failure:function(form, action){
    if(action.failureType == 'server'){
        //服务器端你自己返回success为false时
     Ext.MessageBox.alert('友情提示', action.result.info);
    }else if(action.failureType == 'connect'){
        //服务器指定的路径链接不上时
     Ext.Msg.alert('连接错误','指定路径连接错误!');
    }else if(action.failureType == 'client'){
        //客户端数据验证失败的情况下，例如客户端验证邮件格式不正确的情况下提交表单
     Ext.Msg.alert('提示','数据错误，非法提交');
    }else{
        //其它类型的错误
     Ext.MessageBox.alert('警告', '服务器数据传输失败：'+action.response.responseText);
    }
},

Ext的数据存储器为：Ext.data.Store
ExtJS中有一个名为Record的类，表格等控件中使用的数据是存放在Record对象中，一个Record可以理解为关系数据表中的一行，也可以称为记录。Record对象中即包含了记录（行中各列）的定义信息（也就是该记录包含哪些字段，每一个字段的数据类型等），同时又包含了记录具体的数据信息（也就是各个字段的值）。一个比较正规的创建store的代码如下：
var MyRecord = Ext.data.Record.create([
 {name: 'title'},
 {name: 'username', mapping: 'author'},
 {name: 'loginTimes', type: 'int'},
 {name: 'lastLoginTime', mapping: 'loginTime', type: 'date'}
]);
var dataProxy=new Ext.data.HttpProxy({url:"login.do"});
var theReader=new Ext.data.JsonReader({
 totalProperty: "results", 
 root: "rows",             
 id: "id"                  
 },MyRecord
);
var store=new Ext.data.Store({  
 proxy:dataProxy,
 reader:theReader
});
store.load();
store在创建的时候会自动使用HttpProxy来加载参数，并且使用post方式来提交请求，因此上面的代码可简化为：
var MyRecord = Ext.data.Record.create([
 {name: 'title'},
 {name: 'username', mapping: 'author'},
 {name: 'loginTimes', type: 'int'},
 {name: 'lastLoginTime', mapping: 'loginTime', type: 'date'}
]);
var theReader=new Ext.data.JsonReader({
 totalProperty: "results", 
 root: "rows",             
 id: "id"                  
 },MyRecord
);
var store=new Ext.data.Store({  
url:'login.do',
 reader:theReader
});
store.load();
在Store类的基础上提供了SimpleStore、JSonStore、GroupingStore等，因此上面的JsonReader可以省略：
var store = new Ext.data.JsonStore({
            url:'contact.do',
            root:'data',
            totalProperty:'totalCount',
            fields:[{name: 'vid', mapping: 'id'},
                {name: 'name', mapping: 'name'},
                {name: 'vmethod', mapping: 'vmethod'}]
        });

       success:function(form,action){
              window.location.href = 'index.jsp'; 
        },
        failure : function(form, action) {
         if(action.failureType == 'server'){
          Ext.Msg.alert('登录错误',action.result.errors);
            }else if(action.failureType == 'connect'){
             Ext.Msg.alert('连接错误','指定路径连接错误!');
            }else{
             Ext.MessageBox.alert('警告', '服务器数据传输失败：'+action.response.responseText);
            }
        }

        
        java返回的数据，成功为：String json="{success:true}"，失败为： String json="{success:false,errors:'用户名或者密码错误！！！'}";

使用group by子句的注意事项：

（1）在SELECT子句的字段列表中，除了聚集函数外，其他所出现的字段一定要在group by子句中有定义才行。例如“group by A，B”，那么“SELECT SUM（A），C”就有问题，因为C不在group by中，但是SUM（A）是可以的。

（2）SELECT子句的字段列表中不一定要有聚集函数，但至少要用到group by子句列表中的一个项目。例如“group by A，B，C”，则“SELECT A”是可以的。

（3）在SQL Server中text、ntext和image数据类型的字段不能作为group by子句的分组依据。

格式 
定义变量：

$identifier $(identifier) $(identifier:conversion)

变量的字符串级别最高，如果遇到相同的字符串，首先被认为是变量。显示$，需要后面在跟一个，$$。例如：

You account has $$1650.00 in it.

变量名称规则：
1、变量名是由US-ASCII码、下划线和数字组成；
2、只能以US-ASCII码开头；
3、变量名大小写敏感。
注意：
1、WML变量没有类型，均表示为字符串；
2、变量没有被赋值的时候，内容为空，即空字符串。
3、可以在运行过程中改变它的值。

创建变量
最简单的方法是使用<setvar>元素，语法如下：

<setvar name="string" value="string" />

<setvar>只能在<go>、<prev>和<refresh>中使用。
下例定义了一个叫vNAME的变量并赋值为“Jeff”：

<setvar name="vNAME" value="Jeff" />

另外，还可以在<input>、<select>和<postfield>中定义变量。

替换文本 
变量可以用作替换用途，但只能在文本类型（如显示字符、URL等）中使用。
任何元素和属性都不能使用变量来替代。例如：

Hello, $vNAME.

将显示：

Hello, Jeff.

ESCAPE转换
前面说过变量可以用作替换用途，但是在URL中使用时，变量的内容必须遵守[RFC2396]标准。
这个标准规定某些特殊字符在URL里使用的时候必须用特殊表示方法，即ESCAPE八进制表示。
例如：

list.asp?id=3

在URL中要表示为：

list.asp%3fid=3

所以变量有可能需要标志为是否对其内容进行ESCAPE转换，变量定义就有如下几种特殊方式：

效果	表达方式1	表达方式2	表达方式3
对变量中ESCAPE字符进行转换	$(var:e)	$(var:E)	$(var:escape)
不进行ESCAPE转换	$(var:u)	$(var:U)	$(var:unesc)
变量中没有ESCAPE字符	$(var:n)	$(var:N)	$(noesc)

给变量进行ESCAPE转换是WML的默认方式。

概述：
Servlet监听器用于监听一些重要事件的发生，监听器对象可以在事情发生前、发生后可以做一些必要的处理。
接口：
目前Servlet2.4和JSP2.0总共有8个监听器接口和6个Event类，其中HttpSessionAttributeListener与
HttpSessionBindingListener 皆使用HttpSessionBindingEvent;HttpSessionListener和 HttpSessionActivationListener则都使用HttpSessionEvent;其余Listener对应的Event如下所 示：

Listener接口	Event类
ServletContextListener	ServletContextEvent
ServletContextAttributeListener	ServletContextAttributeEvent
HttpSessionListener	HttpSessionEvent
HttpSessionActivationListener
HttpSessionAttributeListener	HttpSessionBindingEvent
HttpSessionBindingListener
ServletRequestListener	ServletRequestEvent
ServletRequestAttributeListener	ServletRequestAttributeEvent

分别介绍：
一 ServletContext相关监听接口
补充知识：
通过ServletContext 的实例可以存取应用程序的全局对象以及初始化阶段的变量。
在JSP文件中，application 是 ServletContext 的实例，由JSP容器默认创建。Servlet 中调用 getServletContext()方法得到 ServletContext 的实例。
注意：
全局对象即Application范围对象，初始化阶段的变量指在web.xml中，经由<context-param>元素所设定的变量，它的范围也是Application范围，例如：

<context-param>
<param-name>Name</param-name>
<param-value>browser</param-value>
</context-param>
当容器启动时，会建立一个Application范围的对象，若要在JSP网页中取得此变量时：
String name = (String)application.getInitParameter("Name");
或者使用EL时：
${initPara.name}
若是在Servlet中，取得Name的值方法：
String name = (String)ServletContext.getInitParameter("Name");

1.ServletContextListener：
用于监听WEB 应用启动和销毁的事件，监听器类需要实现javax.servlet.ServletContextListener 接口。
ServletContextListener 是 ServletContext 的监听者，如果 ServletContext 发生变化，如服务器启动时 ServletContext 被创建，服务器关闭时 ServletContext 将要被销毁。

ServletContextListener接口的方法：
void contextInitialized(ServletContextEvent sce)
通知正在接受的对象，应用程序已经被加载及初始化。
void contextDestroyed(ServletContextEvent sce)
通知正在接受的对象，应用程序已经被载出。

ServletContextEvent中的方法：
ServletContext getServletContext()
取得ServletContext对象

2.ServletContextAttributeListener：用于监听WEB应用属性改变的事件，包括：增加属性、删除属性、修改属性，监听器类需要实现javax.servlet.ServletContextAttributeListener接口。

ServletContextAttributeListener接口方法：
void attributeAdded(ServletContextAttributeEvent scab)
若有对象加入Application的范围，通知正在收听的对象
void attributeRemoved(ServletContextAttributeEvent scab)
若有对象从Application的范围移除，通知正在收听的对象
void attributeReplaced(ServletContextAttributeEvent scab)
若在Application的范围中，有对象取代另一个对象时，通知正在收听的对象

ServletContextAttributeEvent中的方法：
java.lang.String getName()
回传属性的名称
java.lang.Object getValue()
回传属性的值

二、HttpSession相关监听接口
1.HttpSessionBindingListener接口
注意：HttpSessionBindingListener接口是唯一不需要再web.xml中设定的Listener

当我们的类实现了HttpSessionBindingListener接口后，只要对象加入Session范围 （即调用HttpSession对象的setAttribute方法的时候）或从Session范围中移出（即调用HttpSession对象的 removeAttribute方法的时候或Session Time out的时候）时，容器分别会自动调用下列两个方法：
void valueBound(HttpSessionBindingEvent event)
void valueUnbound(HttpSessionBindingEvent event)

思考：如何实现记录网站的客户登录日志， 统计在线人数？

2.HttpSessionAttributeListener接口
HttpSessionAttributeListener监听HttpSession中的属性的操作。
当 在Session增加一个属性时，激发attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。这和ServletContextAttributeListener比较类似。

3.HttpSessionListener接口
HttpSessionListener监听 HttpSession的操作。当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。

4.HttpSessionActivationListener接口
主要用于同一个Session转移至不同的JVM的情形。

请注意HttpSessionAttributeListener与HttpSessionBindingListener的区别：
１．前者是需要在web.xml中进行描述的，后者不需要。
２．前者是在任何session的属生变化时都会触发执行其方法中的代码，而后者只是在实现它的对象被绑定到会话属性或被从会话属生中解除绑定时，才会触发执行那个对象的valueBound和valueUnboundy这两个方法的代码。比如说有两个对象A和B都实现了HttpSessionBindingListener接口,当Ａ被绑定到会话属性中时，只是Ａ的valueBound()方法被触发执行。

三、ServletRequest监听接口
1.ServletRequestListener接口
和ServletContextListener接口类似的，这里由ServletContext改为ServletRequest
2.ServletRequestAttributeListener接口
和ServletContextListener接口类似的，这里由ServletContext改为ServletRequest

  下面说明如何在web.xml中布署事件监听器以实现对事件的处理，格式如下：
<listener>
  <listener-class> 
    fey.servlet.listener.CustomServletContextListener 
  </listener-class >  
</listener>
  其中fey.servlet.listener.CustomServletContextListener是实现上述各事件监听器接口的类名。当然，你需要将这些类放入Web容器的Web应用的classes或lib目录下以让Web容器可以找到。
  另外说明一点，一个类可以一个或多个监听器接口。

有的listener可用于统计网站在线人数及访问量。 如下：

服务器启动时（实现ServletContextListener监听器contextInitialized方法），读取数据库，并将其用一个计数变量保存在application范围内

session创建时（实现HttpSessionListener监听器sessionCreated方法），读取计数变量加1并重新保存

服务器关闭时（实现ServletContextListener监听器contextDestroyed方法），更新数据库

简例一

监听用户上线与退出，显示在线用户

1、登陆页面 Login.jsp

<%@page pageEncoding="gb2312" contentType="text/html; charset=gb2312" %>
<%
session=request.getSession(false);
if(session!=null)session.invalidate();
%>
<html>
<head><title></title></head>
<body>
<form action="isOnline.jsp" method="post">
用户名：<input type="text" name="uName"/>
<input type="submit" value="上线">
</form>
</body>
</html>

2、控制页面（只是为了说明监听器问题，所以简单了点...） isOnline.jsp

<%@page pageEncoding="gb2312" contentType="text/html; charset=gb2312" %>
<html>
<head><title></title></head>
<body>
<%
session=request.getSession();
session.setAttribute("userName",request.getParameter("uName"));
response.sendRedirect("showOnline.jsp");
%>
</body>
</html>

3、显示页面 showOnline.jsp

<%@page pageEncoding="gb2312" contentType="text/html; charset=gb2312" import="java.util.ArrayList" %>
<html>
<head><title></title></head>
<body>
<%
ArrayList showList=(ArrayList)(getServletContext().getAttribute("list"));
out.print("在线人数 "+showList.size()+"<br>");
for(int i=0;i<showList.size();i++){
out.print(showList.get(i)+"在线"+"<br>");
}
%>
<br>
<a href="Login.jsp">退出</a>
</body>
</html>

4、配置页面 web.xml

<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<listener>
    <listener-class>org.xiosu.listener.onlineListener</listener-class>
</listener>
</web-app>

5、监听器 onlineListener.java

package org.xiosu.listener;

import java.util.ArrayList;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class onlineListener implements HttpSessionListener,
HttpSessionAttributeListener {
// 参数
ServletContext sc;
ArrayList list = new ArrayList();
// 新建一个session时触发此操作
public void sessionCreated(HttpSessionEvent se) {
sc=se.getSession().getServletContext();
System.out.println("新建一个session");
}
// 销毁一个session时触发此操作
public void sessionDestroyed(HttpSessionEvent se) {
System.out.println("销毁一个session");
if (!list.isEmpty()) {
   list.remove((String) se.getSession().getAttribute("userName"));
   sc.setAttribute("list", list);
}
}
// 在session中添加对象时触发此操作，在list中添加一个对象
public void attributeAdded(HttpSessionBindingEvent sbe) {
list.add((String) sbe.getValue());
sc.setAttribute("list", list);
}
// 修改、删除session中添加对象时触发此操作
public void attributeRemoved(HttpSessionBindingEvent arg0) {
}
public void attributeReplaced(HttpSessionBindingEvent arg0) {
}
}

在Web开发中关于监听器的应用
首先，也要在web.xml配置文件中进行声明：
        在web.xml文件中的声明如下：(声明片断)    要放在filter过滤器声明和filter-mapping声明后面
   
   <listener>
        <listener-class>markchen.web.listener.MySessionListener</listener-class>
    </listener>
    <listener>
         <listener-class>markchen.web.listener.MyServletContextListener</listener-class>
    </listener>

//这两个java类的内容都和简单，仅仅是为了演示说明而已

//MySessionListener.java文件的内容如下
     //Web应用程序中会话的生命周期监听器实现   
package markchen.web.listener;

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MySessionListener implements HttpSessionListener {
   
    //在会话一创建时该方法被调用,可以在此处编写自己需要做特殊处理的程序代码
     public void sessionCreated(HttpSessionEvent event) {
               
                  HttpSession session = event.getSession();       
                  String sessionId=session.getId();
                  System.out.println("Session::::::"+sessionId+"******Created******");
        }
       
     //在会话即将销毁时该方法被调用,可以在此处编写自己需要做特殊处理的程序代码
     public void sessionDestroyed(HttpSessionEvent event) {
               
                 HttpSession session = event.getSession();       
                 String sessionId=session.getId();
                 System.out.println("Session::::::"+sessionId+"******Destroyed******");
       
                }       
}
    
      注意：在sessionDestroyed()方法中一定不要再调用session.invalidate()方法了
            因为每调用一次session.invalidate()方法都会触发sessionDestroyed()方法的调用
             进而形成死循环，最终使Web应用程序意外终止

      //MyServletContextListener.java
            //Web应用程序的生命周期监听器实现
package markchen.web.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyServletContextListener implements ServletContextListener {
       
         //在Web应用程序初始化后该方法被调用
         public void contextInitialized(ServletContextEvent event) {
              
              System.out.println("******Application started******");               
         }
       
         //在Web应用程序销毁时该方法被调用
       public void contextDestroyed(ServletContextEvent event) {

                 System.out.println("******Application ended******");               
        }
}

一，查看linux的ssh服务是否已经启动：service sshd status;
    如果没有启动则执行：service sshd start 或者 service sshd restart
二，使linux防火墙开启22端口，因为ssh是通过22端口提供服务的
    1.在/etc/sysconfig/iptables里添加

-A RH-Firewall-1-INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

    2.重启iptables

[root@localhost ~]# /etc/init.d/iptables restart

    3.看下状态

[root@localhost ~]# /etc/init.d/iptables status

三，使用SSH Secure shell连接，选接连接方式为：password。

四，OK

redhat9下安装VMware Tools

下面是安装步骤:
1.启动Rad Hat 9.0(图形界面方式登陆)，并且以管理员的身份登陆。
2.在VMware虚拟机的菜单中点击：虚拟机->安装VMware 工具->install。
3.Red Hat 9.0自动挂载VMware Tools的虚拟光驱,并显示在桌面。
4.进去VMware Tools的虚拟光驱里，把VMwareTools-5.5.1-19175.tar.gz复制到/tmp目录。
5.进去/tmp目录，把VMwareTools-5.5.1-19175.tar.gz解压到当前目录下。
6.打开一个终端(shell)，并以root身份登陆。
7.输入以下命令：cd /tmp/vmware-tools-distrib（进入vmware-tools-distrib目录）。
8.输入：./vmware-install.pl（执行vmware-install.pl文件）。
9.然后一路“回车”，就OK。
10. 输入reboot命令(重新启动)。
OK！！！

  Web2.0时代，大家都一再强调互动! 互动! 互动! 企业级网站需要与客户沟通互动，所以我们之前介绍了10款免费的网站在线客服系统，个人站长们也越来越追求互动，博客从一开始就为互动而生，好像不互动就不像个博客似儿的．虽然本博早已厌倦互动，但还是为大家介绍10多款基于Web的网页即时聊天程序．使用网页即时聊天程序的好处就是，让访客能即时的和站长或博客主沟通交流，形成良好的氛围，甚至成为朋友．尤其对博客来说，能很好的增加稳定的读者群．

注：下面的其中几个程序并非标准的Web即时聊天程序，只能算留言本而已．但其实他能当聊天程序用，只是少了”即时”…

Plugoo

plugoo不需要额外的帐号，只需要你经常使用的IM帐号即可（目前plugoo支持的IM 有： MSN Messenger/ Yahoo! Messenger/ GoogleTalk/ Jabber ），注册成功以后系统会自动添加 plugoo@plugoo.com为你IM的好友，同时生成一段代码，挂在自己的网站上便可以直接于你网站的访客进行Web网页即时聊天。via

Hab.la

一款十分高效且简洁的网页即时聊天程序序，一段简单的Javascript代码可以帮助你完善个人站点的客服系统。Hab.la 目前仍然是一款测试中的产品，他们提供了一整套高效的网页客服解决方案。缺少了MSN、AIM、Y! Messenger等多款IM通信协议的支持外，Hab.la 几乎同Plugoo实现的功能如出一辙——只需要在自己的站点中添加上一小段轻量级的Javascript代码，便可以很轻松的帮助站长和管理员来连接自己用户和读者，并建立相对比较完善的客服系统。目前，Hab.la 已经能够全面支持Jabber与Google Talk！via

Chatback Badge

Chatback Badge是Google Talk团队发布的一款很有意思的网页即时聊天小工具，它可以在页面上实时显示你的GT在线状态以及个性化签名等信息；不仅如 此，Chatback 还是一款可以即时引导用户进入Google Talk 网页版 Badge进行实时交流状态的扩展，这样，你的访客便可以借助网页版GT和你的客户端GTalk进行即时聊天了，简单而快捷，你的读者甚至不需要独立的 GTalk帐户也能够轻松和你交流。via

TocPlus

TocPlus是让您直接与网上商城、博客、网页的访客进行实时对话的通讯系统。如果将TocPlus的服务适用于网上商城，就如地面商城可以向顾客直接推荐合适的商品或即时回答顾客所提出的咨询，因此可提高营业效益。TocPlus的所有服务为免费。

vawkr

一个即时的视频聊天服务，通常我们需要使用同一种IM即时聊天工具，才能实现和别人视频聊天，但是通过vawkr，只要双方都有摄像头，那么无需下载任何 IM工具，双方都可进行视频聊天，你可以创建一个永久的聊天室，然后得到一个url地址，将这个地址发给你要邀请的人，当他点击进入后，如果允许 vawkr使用其摄像头和麦克风，那么你们就可以进行视频聊天了，vawkr还支持将聊天室放在MySpace 、Facebook、 blog 或者web上。via

-以下5个来自web20share

Gabbly

可 以在浏览器，网页中嵌入聊天系统,可以自定义用户名，显示在线访问人数，访客登陆/离开网站提示（可以选择关闭），访客登陆提示音（可以选择关闭），所有 聊天记录都可以被RSS订阅保存。Gabbly还有一个功能，任何一个网页，即便没有装Gabbly 在线聊天器，你只要在网址前加上’gabbly.com/’，如gabbly.com/hopesome.com，就可以和同在这个页面的人即时聊天。

Blobber

功能和Gabbly类似，需要注册。

Woocall

新浪推出的服务，和新浪网页上的差不多。需要邮件申请，感觉用户的可定制性不是很强.

MeeboMe
作 为一个可以嵌入website/blog的flash widget，本身并不突出，但是当它和Meebo结合起来之后，任何人都会觉得眼前一亮！换句简单点的话说，登录Meebo之后，你不仅可以同时和 MSN、Y!M、Jabber/Gtalk以及AIM中的联系人进行交流，而且还能实时地和你的website/blog上的读者进行交流，而这一切都在 你的浏览器页面中完成.

Cbox-blog
Cbox-更像是一个可以嵌入到blog中的留言本服务，使用非常简单方便，通过调用一段代码就可插入到blog中。并且还可以自定义大小和颜色样式等，以便符合自已的blog风络。

Twitterchat

通过twitter也可以做个简单的聊天室. 你必须有个twitter帐号，然后在 twitterchat.com注册一个帐号，需要用twitter的用户名及密码，邮箱填自己的随便一个．注册后会得到一段代码，可以自己修改聊天窗口宽和高。然后挂在自己上的blog 即可。via

chirrup

Chirrup是一个基于twitter的简单的评论/留言系统，可以很方便地加入到自己blog/wiki/Web中。如果你的blog或者其他web没有评论或者留言本系统，除了以前介绍的js-kit外，chirrup也是一个不错的选择，在twitter“大行其道”的网络时代，所谓“鸟随鸾凤飞腾远,人伴贤良品质高”，安装一个基于twitter的留言或评论系统，对提高blog的流量、人气等等也是很有帮助的。使用方法

Aimboo

是一个类似于Plugoo的 即时通讯服务，可通过代码调用放置一个聊天窗口在你的Blog上，并与你的本地IM软件连接，这样当你的读者访问你的Blog时，就可以与你及时联络了, 目前 Aimboo支持Jabber、Gtalk、MSN、AIM及ICQ等常用的IM协议。

FTPClient client = new FTPClient();
  client.connect("ip地址", 21);
  client.login("用户名", "密码");
  client.setSoTimeout(5000);//设置连接超时时间为5000毫秒
  // 在尝试连接以后，你应该检查返回码验证是否连接成功！
  int reply = client.getReplyCode();
  if (!FTPReply.isPositiveCompletion(reply)) {
   client.disconnect();
   System.err.println("FTP 服务器拒绝连接.");
   System.exit(1);
  }
  System.out.println("连接正在建立中......");
  if (client.isConnected()) {
   System.out.println("连接已建立！");
   client.setControlEncoding("gb2312");// 设置编码方式，默认编码方式为：ISO8859-1
   client.changeWorkingDirectory("archives");// 改变当前ftp的工作目录
   // client.changeToParentDirectory();//回到上级目录
   FTPFile[] fs = client.listFiles(); // 得到当前工作目录下的所有文件
   for (FTPFile ff : fs) {
    if (ff.getName().equals("test.txt")) {
     File file = new File("E:\\ftpdata" + File.separator
       + "test.txt");
     RandomAccessFile rfile = new RandomAccessFile(file, "rw");// 随机访问文件类
     long offset = rfile.length();
     client.setRestartOffset(offset);
     rfile.seek(offset);
     InputStream input = client
       .retrieveFileStream("test.txt");
     byte[] data = new byte[1024];
     System.out.println(new Date() + " 数据写入中...");
     while (input.read(data) != -1) {
      rfile.write(data);
     }
     System.out.println(new Date() + " 所有数据已接受完成！");
     input.close();
     rfile.close();
    }
   }
  }
  client.logout();
  client.disconnect();

基本步骤：
    1，创建连接
    2，登录
    3，上传或下载文件
    4，退出
    5，断开连接
常用方法：
    void setControlEncoding(String encoding)：设置FTP控制连接的编码方式(默认读取中文文件名时为乱码)
    boolean changeWorkingDirectory(String pathname)：设置当前的工作目录
    boolean changeToParentDirectory()：返回上级目录
    void setRestartOffset(long offset)：设置重新启动的偏移量(用于断点续传)
下载文件：
    boolean retrieveFile(String,remote,OutputStream local)：从服务器返回指定名称的文件并且写入到OuputStream，以便写入到文件或其它地方。
    InputStream retrieveFileStream(String remote)：从服务器返回指定名称的文件的InputStream以便读取。
上传文件：
    boolean storeFile(String remote,InputStream local)：利用给定的名字(remote)和输入流(InputStream)向服务器上传一个文件。
    OutputStream storeFileStream(String remote)：根据给定的名字返回一个能够向服务器上传文件的OutputStream。
    boolean storeUniqueFile(InputStream local)：根据服务器自己指定的唯一的名字和输入流InputStream向服务器上传一个文件。
    boolean storeUniqueFile(String remote,InputStream local)：根据指定的名字和输入流InputStream向服务器上传一个文件。
    OuputStream storeUniqueFileStream()：返回一个输出流OutputStream,以便向服务器写入一个文件，该文件由服务器自己命名。
    OutputStream storeUniqueFileStream(String remote)：返回一个输出流OutputStream,以便向服务器写入一个文件，该文件由用户自己指定。

    OutputStream os=new FileOutputStream("");
  OutputStreamWriter osr=new OutputStreamWriter(os);
  BufferedWriter bw=new BufferedWriter(osr);
    
    InputStream is = new FileInputStream("");
  InputStreamReader isr=new InputStreamReader(is);
  BufferedReader br=new BufferedReader(isr);

    

oracle占领http8080端口的问题最近得以解决
最简单的一种：
登录oracle enterprise manager console 选择独立登录，选择xml数据库，配置，直接修改http-port就ok了！

Hibernate支持第三方的连接池，官方推荐的连接池是C3P0,Proxool,以及DBCP。在配置连接池时需要注意的有三点：
　　一、Apche的DBCP在Hibernate2中受支持，但在Hibernate3中已经不再推荐使用，官方的解释是这个连接池存在缺陷。如果你因为某种原因需要在Hibernate3中使用DBCP，建议采用JNDI方式。
　　二、默认情况下（即没有配置连接池的情况下），Hibernate会采用内建的连接池。但这个连接池性能不佳，且存在诸多BUG，因此官方也只是建议仅在开发环境下使用。
　　三、Hibernate2和Hibernate3的命名空间有所变化。例如，配置C3P0时的provider_class有Hibernate2环境下使用net.sf.hibernate.connection.C3P0ConnectionProvider，在Hibernate3环境下使用org.hibernate.connection.C3P0ConnectionProvider。
　　下面是Hibernate环境下几种常见的连接池配置，都是以连接MySQl为例。
　　<!-- JDBC驱动程序 -->
　　<property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
　　<property name="connection.url">jdbc:mysql://localhost:3306/struts?useUnicode=true
　　& characterEncoding=GBK</property>
　　<!-- 数据库用户名 -->
　　<property name="connection.username">root</property>
　　<!-- 数据库密码 -->
　　<property name="connection.password">8888</property>
　　上面的一段配置，在c3p0和dbcp中，都是必需的，因为hibernate会根据上述的配置来生成connections，再交给c3p0或dbcp管理。但是proxool则不能，可以让proxool自身来生成连接，这在下面再讲。
　　从网上google了一下，发现大致有三种可以实施的解决方案：
　　1、使用hibernate自带的连接池；
　　2、使用c3po包的连接池功能；
　　3、使用dbcp包的连接池功能；
　　4、使用Proxool包的连接池功能；
        5、使用JNDI连接池
　　第一种方案，Hibernate默认连接池，就是在myeclipse产生的hibernate.cfg.xml中添加一个属性：
　　<property name="connection.pool_size">20</property>
　　第二种方案是：C3P0
　　只需在hibernate.cfg.xml中加入
　　<property name="c3p0.min_size">2</property>
　　<property name="c3p0.max_size">10</property>
　　<property name="c3p0.timeout">1800</property>
　　<property name="c3p0.acquireRetryAttempts">4</property>
　　<property name="c3p0.acquireIncrement">1</property>
　　<property name="c3p0.idleConnectionTestPeriod">36000</property>
　　<property name="c3p0.initialPoolSize">2</property>
　　<property name="c3p0.maxPoolSize">10</property>
　　<property name="c3p0.maxIdleTime">1200</property>
　　<property name="c3p0.maxStatements">30</property>
　　<property name="c3p0.minPoolSize">2</property>
　　<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
　　还有在classespath中加入c3p0-0.8.4.5.jar
　　第三种方案是：dbcp
　　在hibernate.cfg.xml中加入
　　<property name="dbcp.maxActive">100</property>
　　<property name="dbcp.whenExhaustedAction">1</property>
　　<property name="dbcp.maxWait">60000</property>
　　<property name="dbcp.maxIdle">10</property>
　　<property name="dbcp.ps.maxActive">100</property>
　　<property name="dbcp.ps.whenExhaustedAction">1</property>
　　<property name="dbcp.ps.maxWait">60000</property>
　　<property name="dbcp.ps.maxIdle">10</property>
　　还有在classespath中加入commons-pool-1.2.jar 和commons-dbcp-1.2.1.jar.
　　第四种方案是：Proxool
　　建立一个Proxool.xml文件：
　　<?xml version="1.0" encoding="UTF-8"?>
　　<!-- the proxool configuration can be embedded within your own application’s.
　　Anything outside the "proxool" tag is ignored. -->
　　<something-else-entirely>
　　<proxool>
　　<alias>
　　mysql
　　</alias>
　　<driver-url>
　　jdbc:mysql://localhost:3306/jackdemo
　　</driver-url>
　　<driver-class>
　　com.mysql.jdbc.Driver
　　</driver-class>
　　<driver-properties>
　　<property name="user" value="root" />
　　<property name="password" value="jack" />
　　</driver-properties>
　　<house-keeping-sleep-time>
　　60000
　　</house-keeping-sleep-time>
　　<proxool.simultaneous-build-throttle>
　　100
　　</proxool.simultaneous-build-throttle>
　　<prototype-count>
　　2
　　</prototype-count>
　　<maximum-connection-count>
　　100
　　</maximum-connection-count>
　　<minimum-connection-count>
　　10
　　</minimum-connection-count>
　　</proxool>
　　</something-else-entirely>
　　现在来看下配置的意思：
　　<alias>配置连接池的别名；
　　<driver-url>和写JDBC连接数据库时的URL一样。
　　<driver-class>和写JDBC连接数据库时的Driver一样。
　　<driver-properies>就是连接数据库时的用户名和密码。
　　<house-keeping-sleep-time>proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁
　　<prototype-count>最少保持的空闲连接数
　　<maximum-connection-count>最大连接数。
　　<minimum-connection-count>最小连接数。
　　以下是在Hibernate配置文件中对连接池的配置：
　　<?xml version=’1.0’ encoding=’UTF-8’?>
　　<!DOCTYPE hibernate-configuration PUBLIC
　　"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
　　"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
　　<hibernate-configuration>
　　<session-factory>
　　<!-- proxool连接池加载的类-->
　　<property name="hibernate.connection.provider_class">
　　org.hibernate.connection.ProxoolConnectionProvider
　　</property>
　　<!--连接池的别名，即配置连接池时起的别名-->
　　<property name="hibernate.proxool.pool_alias">
　　mysql
　　</property>
　　<!--连接池文件的地址-->
　　<property name="hibernate.proxool.xml">
　　config/proxool/proxool.xml
　　</property>
　　<!--是否将运行期生成的SQL输出到日志以供调试-->
　　<property name="show_sql">true</property>
　　<mapping resource="com/jack/ssh/demo/bo/City.hbm.xml" />
　　<mapping resource="com/jack/ssh/demo/bo/Province.hbm.xml" />
　　</session-factory>
　　</hibernate-configuration>
　　第五种方案是：JNDI连接池。数据源已经由应用服务配置好(如Web服务器)，Hibernate需要做的只是通过JNDI名查找到此数据源。应用服务器将连接池对外显示为JNDI绑定数据源，它是javax.jdbc.Datasource类的一个实例。只要配置一个Hibernate文件，如：
　　hibernate.connection.datasource = java:/comp/env/jdbc/portal //JNDI名
　　hibernate.transaction.factory_class = org.hibernate.transaction.JTATransactionFactory
　　hibernate.transaction.manager_loopup_class = org.hibernate.transaction.JBossTransactionManagerLookup
　　hibernate.dialect = org.hibernate.dialect.MySQLDialect。

Name Lession Mark
Amy Chinese 89
Amy Math 59
Amy History 87
Amy Japanese 77
Alan Math 54
Alan Chinese 83
Alan History 86
Alan Japanese 76
Bruce History 83
Bruce Math 58
Bruce Japanese 82
Alisa Math 59


1. 请查询出学生出姓名mark<60
2. 请查询每门学科中存在有一门不及格的学生姓名
3. 请查询出各科总分排行前三名的学生姓名和成绩（包含并列）
4. 请查询出每门科目中前三名的学生姓名和科目（包含并列的）

<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" id=scriptmain name=scriptmain codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,29,0" width="560" height="176">
       <param name="movie" value="/images/bcastr.swf?bcastr_xml_url=/pages/web/xml/bcastr.xml" />
       <param name="quality" value="high" />
       <param name=scale value=noscale />
       <param name="LOOP" value="false" />
       <param name="menu" value="false" />
       <param name="wmode" value="transparent" />
       <embed src="/images/bcastr.swf?bcastr_xml_url=/pages/web/xml/bcastr.xml" width="560" height="176" loop="false" quality="high" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" salign="T" name="scriptmain" menu="false" wmode="transparent"></embed>
</object>

<?xml version="1.0" encoding="utf-8"?>
<bcaster autoPlayTime="5">
<item item_url="flash图片" link="链接路径" >
</item>
<item item_url="flash图片" link="链接路径" >
</item>
</bcaster>

困扰我多年的sql语句执行顺序今天终于在网上找到了
1. 先where 后select
2. 先where 再group 再having 后select
3. 先where 再group 再having 再order 后select
4. 先join 再where 后select
例：select top 3 name from student group by name order by sum(mark) desc
    (查询班上总分排名前三的学生姓名)
开心啦，开心！

1，load()方法从来就是假定数据在数据库中是存在的，在使用时如果不存在则会抛出ObjectNotFoundException；而get()方法不会假定数据在数据库中存在，如果不存在则返回null
2，load()方法返回的是实体类的代理类，因此load()可以使用延迟加载策略来加载对象
      get()方法返回的不一定是实体类，可能是代理类，因为get()方法如果在session缓存(一级缓存)中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加载过，那么返回的还是原先的代理对象，而不是实体类对象。
3，load()方法查询数据时会先从session缓存(一级缓存)中查找,如果没有找到则会创建代理类，该代理类仅仅初始化了OID属性，当第一次访问其他属性值时，则会依次从二级缓存-->数据库查找，直到找到数据，最后将所有属性值赋给代理类。而get()方法则会直接按照一级缓存-->二级缓存-->数据库的顺序查找。

看到网上的全都是复制的，而且错误不少，怎么就没有人修正一下呢？

HTTP头中一般断点下载时才用到Range和Content-Range实体头，
Range用户请求头中，指定第一个字节的位置和最后一个字节的位置，如（Range：200-300）
Content-Range用于响应头

请求下载整个文件:
***********************************
GET  /test.rar  HTTP/1.1
Connection:  close
Host:  116.1.219.219
Range:  bytes=0-100
***********************************
Range头域可以请求实体的一个或者多个子范围，Range的值为0表示第一个字节，也就是Range计算字节数是从0开始的
表示头500个字节：bytes=0-499
表示第二个500字节：bytes=500-999
表示最后500个字节：bytes=-500
表示500字节以后的范围：bytes=500-
第一个和最后一个字节：bytes=0-0,-1
同时指定几个范围：bytes=500-600,601-999


一般正常回应
***********************************
HTTP/1.1 206 OK
Content-Length:  801     
Content-Type:  application/octet-stream 
Content-Location: http://www.onlinedown.net/hj_index.htm
Content-Range:  bytes  0-100/2350 //2350:文件总大小
Last-Modified: Mon, 16 Feb 2009 16:10:12 GMT
Accept-Ranges: bytes
ETag: "d67a4bc5190c91:512"
Server: Microsoft-IIS/6.0
Date: Wed, 18 Feb 2009 07:55:26 GMT
***********************************

注意：如果用户的请求中含有range ，则服务器的相应代码为206。
206 - Partial Content 客户发送了一个带有Range头的GET请求，服务器完成了它（HTTP 1.1新）。

        最近我们公司的jsp网站要和另一家公司的asp网站做通讯，之间通过xml传递信息
        现假如我们公司是A，对方公司是B，如果A发送一条信息给B，B必须反馈一条信息表示是否执行成功。这里有两种模式可以使用，
    第一：A、B把对方都当做服务器进行消息发送
    第二：A相当于浏览器、B相当于服务器，A发送一个消息给B，B直接返回给A信息。
    下面我们来看看这两种方式分别怎么实现？
    第一种:
        1、A(a.jsp)的代码：
        StringBuffer sb=new StringBuffer("<?xml version=\"1.0\" encoding=\"GBK\"?>");
        sb.append("<User>");
        sb.append("<HEAD>");
        sb.append("<SUCCESS></SUCCESS>");
        sb.append("</HEAD>");
        sb.append("<BODY>");
        sb.append("<MOBILE></MOBILE>");
        sb.append("<NAME></NAME>");
        sb.append("<SEX></SEX>");
        sb.append("</BODY>");
        sb.append("</User>");
        URL url = new URL("B服务器的接收路径");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestProperty("Content-Type", "text/xml;charset=gbk");
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Length", String.valueOf(xml.length()));
        conn.setConnectTimeout(5000);
        conn.setDoOutput(true);
        OutputStream os = conn.getOutputStream();
        os.write(sb.toString().getBytes());
        os.flush();
        os.close();
        2、B服务器接收到A的请求后，也以类似于1(当然asp中的代码我不知道怎么写)将反馈信息发送到A的指定路径(b.jsp)
        3、A(b.jsp)接收B的反馈信息：
            InputStream is=request.getInputStream();
    第二种：
        1、A(a.jsp)的代码
            StringBuffer sb=new StringBuffer("<?xml version=\"1.0\" encoding=\"GBK\"?>");
            sb.append("<User>");
            sb.append("<HEAD>");
            sb.append("<SUCCESS></SUCCESS>");
            sb.append("</HEAD>");
            sb.append("<BODY>");
            sb.append("<MOBILE></MOBILE>");
            sb.append("<NAME></NAME>");
            sb.append("<SEX></SEX>");
            sb.append("</BODY>");
            sb.append("</User>");
            URL url = new URL("B服务器的接收路径");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestProperty("Content-Type", "text/xml;charset=gbk");
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Length", String.valueOf(xml.length()));
            conn.setConnectTimeout(5000);
            conn.setDoOutput(true);
            OutputStream os = conn.getOutputStream();
            os.write(sb.toString().getBytes());
            os.flush();
            os.close();
        2、B接收到A(a.jsp)服务器的代码后用
                byte[] byts = new byte[Request.InputStream.Length];
             Request.InputStream.Read(byts,0,byts.Length);
                然后用Response.OutputStream.write()返回信息
        3、A(a.jsp)接收B服务器的反馈信息(和1的代码同在a.jsp中，并且就接着1代码的后面)
               if(conn.getResponseCode()==200){
                   String line=null;
                   String body="";
                   is = conn.getInputStream();
                   BufferedReader br = new BufferedReader(new InputStreamReader(is));
                   while ((line = br.readLine()) != null) {
                        body += line;
                   }
                   conn.disconnect();
              }
        其中访问一个页面主要用到了HttpURLConnection这个类，当然还有其它几种方式可以使用，具体请参见我的文章http://www.blogjava.net/vickzhu/archive/2008/11/12/240013.html

错误代码:
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker from transaction definition
错误原因:
OpenSessionInViewFilter在getSession的时候,会把获取回来的session的flush mode 设为FlushMode.NEVER。然后把该sessionFactory绑定到TransactionSynchronizationManager，使request的整个过程都使用同一个session，在请求过后再解除该sessionFactory的绑定，最后closeSessionIfNecessary根据该session是否已和transaction绑定来决定是否关闭session。在这个过程中，若HibernateTemplate 发现自当前session有不是readOnly的transaction，就会获取到FlushMode.AUTO Session，使方法拥有写权限。
也即是，如果有不是readOnly的transaction就可以由Flush.NEVER转为Flush.AUTO,拥有insert,update,delete操作权限，如果没有transaction，并且没有另外人为地设flush model的话，则doFilter的整个过程都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有。
参考文章:
http://calvin.blog.javascud.org/post/46.htm
解决办法:
采用spring的事务声明,使方法受transaction控制
<bean id="baseTransaction"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
abstract="true">
<property name="transactionManager" ref="transactionManager"/>
<property name="proxyTargetClass" value="true"/>
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="add*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="remove*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
    <bean id="userService" parent="baseTransaction">
<property name="target">
<bean class="com.phopesoft.security.service.impl.UserServiceImpl"/>
</property>
</bean>

暂时发现了两种静态页包含静态页的方法
1、<object style="border:0px" type="text/x-scriptlet" data="test.html" width=100% height=1000></object>
2、<iframe src="" frameborder="0"></iframe>
第一种可以解决大部分问题，不过第二种如果你的a页面包含b页面，b页面中的链接都是在b页面本页打开的话，b链接的页面就不会在a主窗体显示

public class VickTest {
 public static void main(String[] args) throws InterruptedException {

  for (int i = 0; i <= 65535; i++) {
   MyTask mt=new MyTask(i);
   Thread thread=new Thread(mt);
   thread.start();
   if(i%100==0){
    Thread.sleep(500);
   }
  }
 }

}

class MyTask implements Runnable{
 int port;
 public MyTask(int port) {
  this.port = port;
 }

 public void run() {
  try {
   Socket s=new Socket("203.208.35.100",port);
   System.out.println("端口"+port+"绑定成功！");
  } catch (UnknownHostException e) {
   System.out.println("主机不明");
  } catch (IOException e) {
   System.out.println("端口"+port+"绑定失败.");
  }
 }
}

cvsnt配置 创建用户

以下都是实战经验：
1、Socket读取
      String strServer=http://www.google.cn;//这里同样可以用ip来访问:203.208.35.100
      String strPage="/language_tools?hl=zh-CN";
      try { 
           String hostname = strServer; 
           int port = 80; 
           InetAddress addr = InetAddress.getByName(hostname); 
           Socket socket = new Socket(addr, port);
           BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF8")); 
           wr.write("GET " + strPage + " HTTP/1.0\r\n"); 
           wr.write("HOST:" + strServer + "\r\n"); 
           wr.write("\r\n"); 
           wr.flush();
           BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));
           String line; 
           while ((line = rd.readLine()) != null) { 
                System.out.println(line); 
           }
           wr.close(); 
           rd.close(); 
      } catch (Exception e) { 
           System.out.println(e.toString()); 
      }
2、HttpClient方式
      HttpClient client=new HttpClient();
      GetMethod method=new GetMethod("http://www.baidu.com/");
      int status=client.executeMethod(method);
      if(status==HttpStatus.SC_OK){
       //读取内容
       byte[] responseBody = method.getResponseBody();
       //处理内容
       System.out.println(new String(responseBody));
       System.out.println("文件名称："+method.getPath());
        }
3、HttpURLConnection方式
      URL url = new URL("这里是你要连接的地址");
      HttpURLConnection conn = (HttpURLConnection)url.openConnection();
      conn.setDoOutput(true);//是否可用于输出(输出参数)，默认为fasle。另:setDoInput()为是否可用于输入，默认为true
      String parameters = "name=admin&password=123456";//这里是要传递的参数
      OutputStream os = conn.getOutputStream();
      os.write(parameters.getBytes("utf-8"));
      os.flush();
      os.close();
      System.out.println("返回状态码："+conn.getResponseCode());
      System.out.println("返回消息："+conn.getResponseMessage());
      InputStream is = conn.getInputStream();
      BufferedReader br = new BufferedReader(new InputStreamReader(is,"utf-8"));
      String line = null;
      while((line=br.readLine())!=null){
       System.out.println(line);
      }
    //  DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();;
    //  DocumentBuilder db = dbf.newDocumentBuilder();
    //  Document doc = db.parse(is);
如果谁还有更多的方式分享，请留言！

    getOutputStream() has already been called for this response 这个错误遇到过不少次，网上看到大多不能解决问题。
    下面两点是我自己总结出来的：
    1、在我们应用验证码时，都会用到字节流response.getOutputStream()来将验证码输出，但是jsp页面自己最后会调用字符流JspWriter的out()方法将页面的内容输出。通过查看servlet的API我们可以看到知道，在servlet中不能够同时利用这两个流输出，解决办法将验证码写在servlet中，具体见下面。
    2、相信请求转发( request.getRequestDispacher().forward() )和请求跳转( response.sendRedirect() )的区别大家都知道。其中request.getRequestDispacher().forward() 方法的调用者与被调用者之间共享相同的request对象和response对象，它们属于同一个访问请求和响应过程。JSP页面转译为的_servlet会最后调用releasePageContext()方法( All PageContext objects obtained via this method shall be released by invoking releasePageContext().)释放我们页面所有的实体对象，当我们的调用者有页面输出时，就会抛出这个异常。具体原因也没有弄清楚，各位大侠如果谁知道可以告知一下。其实验证码也是同一个原理，如果我们将验证码的代码写在jsp页面中，因为jsp页面会调用JspWriter的out()方法将内容输出，同时我们的图片又调用了response.getOutputStream()方法因此会抛出这个异常；如果我们将验证码写在servlet中，就不会同时使用两种输出也就不会出错。有时即使调用者页面没有输出，也会抛出这个异常，仔细看jsp转译以后的源码发现输出了换行，因此，我们最好把调用者页面的%>和<%之间换行去掉，把%>和<%直接写在一起。
    另外，如果我们实在要在jsp中用到response.getOutputStream()，比如验证码、jspSmartUpload，我们需要在最后加入如下代码：
        response.reset();
        out.clear();
        out=pageContext.pushBody();

    有不对之处还望指教！
    

网上找了很久，关于这方面的文章都是转载的，而且过时了，根本就用不上，自己做了一个这方面的整合，现在和大家分享一下：
准备工作：
    一、下载Apache服务器：
            地址：http://apache.justdn.org/httpd/binaries/win32/apache_2.2.10-win32-x86-no_ssl.msi
            (D:\Program Files\Apache Software Foundation\Apache2.2)
    二、下载JK(Apache、tomcat整合必须)
            地址：http://www.apache.org/dist/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.26/mod_jk-1.2.26-httpd-2.2.4.so
            放在D:\Program Files\Apache Software Foundation\Apache2.2\modules下
            (mod_jk-1.2.26-httpd-2.2.4.so适用于Apache2.2所有版本)
    三、Tomcat和JDK就不用说了，我用的是Tomcat6.0(D:\Programe Files\Tomcat 6.0)和JDK1.6(D:\Programe Files\JDK1.6)
配置：
        1、在D:\Programe Files\Tomcat 6.0\conf 下新建文件workers.properties
        内容如下：
        workers.tomcat_home=D:\Programe Files\Tomcat 6.0 
        #让mod_jk模块知道Tomcat的位置
        workers.java_home=D:\Programe Files\JDK1.6\jre 
        #让mod_jk模块知道jre的位置 
        ps=\ 
        worker.list=ajp13 #模块版本 
        worker.ajp13.port=8009 
        #工作端口,若没占用则不用修改 
        worker.ajp13.host=192.168.0.142
        #本机
        worker.ajp13.type=ajp13 
        #类型 
        worker.ajp13.lbfactor=1 
        #代理数,不用修改

    2、修改D:\Program Files\Apache Software Foundation\Apache2.2\conf\httpd.conf文件
        端口：Listen 80 这是默认的，大家可以改这里
        模块：里面有一堆模块在其中添加一个LoadModule jk_module modules/mod_jk-1.2.26-httpd-2.2.4.so
        ServerAdmin：不用改，是个邮件地址
        ServerName：服务器名称，可以用ip也可用dns，这里通常注释了，我们通常把注释给去掉，否则当你启动apache的时候会报Could not reliably determine the server's fully qualified domain name, using 192.168.0.142 for ServerName错误，但是这并不影响你的程序的运行
        DocumentRoot：工程的根路径，和Tomcat里配置的虚拟目录docBase属性相同
        <Directory "  ">：这里必须和DocumentRoot设置一样
        添加如下代码：
            <VirtualHost localhost>
             DirectoryIndex index.html index.htm index.jsp
             JkMount /servlet/* ajp13
             #让Apache支持对servlet传送，用以Tomcat解析
             JkMount /*.jsp* ajp13 
             #让Apache支持对jsp传送，用以Tomcat解析
             JkMount /*.bst* ajp13 
             #让Apache支持对.bst传送，用以Tomcat解析
             JkMount /RandCode* ajp13
             #让Apache支持对Servlet传送，用以Tomcat解析
            </VirtualHost>
    完毕，运行http://localhost和http://locahost:8080可以看到结果是一样的
    不正确的地方请多多指教！

公司里的表里有很多数据不正确，今天打算将数据库中的数据整理一下，正好发现两张表需要联合更新

在网上查了一些资料，自己试了一下，sql语句如下：
    update law_answer set law_answer.lmakerID=q.lUserID from law_answer a,law_question q where a.lquestionID=q.lquestionID
注意set后面要更新的列不能用别名

        今天又测试了一下搭建了一下SSH框架，但是出了一个问题，当我用get()加载一个对象的时候没有异常，但是用load()的时候抛出了异常，异常如下：
java.lang.NullPointerException
 at org.hibernate.tuple.AbstractEntityTuplizer.createProxy(AbstractEntityTuplizer.java:372)
 at org.hibernate.persister.entity.AbstractEntityPersister.createProxy(AbstractEntityPersister.java:3121)
 at org.hibernate.event.def.DefaultLoadEventListener.createProxyIfNecessary(DefaultLoadEventListener.java:232)
 at org.hibernate.event.def.DefaultLoadEventListener.proxyOrLoad(DefaultLoadEventListener.java:173)
 at org.hibernate.event.def.DefaultLoadEventListener.onLoad(DefaultLoadEventListener.java:87)
 at org.hibernate.impl.SessionImpl.fireLoad(SessionImpl.java:862)
 at org.hibernate.impl.SessionImpl.load(SessionImpl.java:781)
 at org.hibernate.impl.SessionImpl.load(SessionImpl.java:774)
 at org.springframework.orm.hibernate3.HibernateTemplate$3.doInHibernate(HibernateTemplate.java:508)
 at org.springframework.orm.hibernate3.HibernateTemplate.execute(HibernateTemplate.java:372)
 at org.springframework.orm.hibernate3.HibernateTemplate.load(HibernateTemplate.java:502)
 at org.springframework.orm.hibernate3.HibernateTemplate.load(HibernateTemplate.java:496)
 at com.bestone.SSH.hibernate.LawUserDAO.findByName(LawUserDAO.java:104)
 at com.bestone.SSH.service.impl.LoginServiceImpl.checkLogin(LoginServiceImpl.java:30)
 at com.bestone.SSH.struts.action.LoginAction.execute(LoginAction.java:63)
 at org.springframework.web.struts.DelegatingActionProxy.execute(DelegatingActionProxy.java:110)
 at org.apache.struts.action.RequestProcessor.processActionPerform(RequestProcessor.java:431)
 at org.apache.struts.action.RequestProcessor.process(RequestProcessor.java:236)
 at org.apache.struts.action.ActionServlet.process(ActionServlet.java:1196)
 at org.apache.struts.action.ActionServlet.doPost(ActionServlet.java:432)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:710)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:803)
 at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:290)
 at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
 at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:233)
 at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:175)
 at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:128)
 at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:102)
 at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:109)
 at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:286)
 at org.apache.coyote.http11.Http11Processor.process(Http11Processor.java:844)
 at org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler.process(Http11Protocol.java:583)
 at org.apache.tomcat.util.net.JIoEndpoint$Worker.run(JIoEndpoint.java:447)
 at java.lang.Thread.run(Thread.java:619)

        碰到这个问题，我马上想到了加载数据时load和get的区别：
        1、load总是假定要查询的数据存在，如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
        2、load方法返回实体的代理实例，而get方法永远直接返回实体类。
        3、load方法可以充分的利用一级缓存和二级缓存中的数据，而get方法则仅仅在一级缓存中进行数据查找，如果没有发现对应的数据，将越过二级缓存，直接调用sql完成数据读取(经过我的证实，在hibernate3.2中get()方法是可以查找二级缓存的)。
        仔细看了看错误，想来想去应该是生成代理类的时候出现了错误。java中生成代理类有两种形式，一是java动态代理，二是利用cglib生成。而hibernate中实体的代理类是用cglib生成的。
        后来仔细研究了一下jar包，通过jar包源码发现，原来是cglib-2.1.3.jar和cglib-nodep-2.1_3.jar相冲突,只需要把cglib-2.1.3.jar包删除就没有问题了。查看cglib-nodep-2.1_3.jar的源码我们还发现一个问题，它包含了asm-attrs.jar的全部类，但是使用的包名不同，不知道有没有冲突，运行程序查看日志，暂时没有发现什么问题，就留着asm-attrs.jar吧。
        

1、gpedit.msc   组策略
2、msconfig      系统配置实用程序
3、dxdiag         DirectX诊断工具 可以查看显卡，声卡是否安装等
4、winmsd       系统信息(包括硬件资源、软件环境、组件、Internet设置等)
5、secpol         本地安全策略

修改/bin/service.bat里面的 set SERVICE_NAME=Tomcat6(这里是服务名，名字可以随意起)
在命令行执行下面的命令：
安装服务：service install Tomcat6
卸载服务：service remove Tomcat6

启动服务：net start Tomcat6
关闭服务：net stop Tomcat6

a.html:
    <a href="b.html?src=logo.gif">图片</a>

    b.html
    <script> 
    function window.onload() {
        var str = self.location.href;
        var image=str.substring(str.indexOf("=")+1);
        document.getElementById('vick').src=image;
    }
    </script>

    <img id="vick" src=""></img>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>无标题文档</title>
<style type="text/css">
table.dynamic tbody tr{ display:none;}
table.dynamic tbody tr.show{display:block;}
html>body table.dynamic tbody tr.show{ display:table-row;}
th,td{ padding:5px;}
th{ background:#eef;}
table.pagelist{ border:1px solid #ccc; border-bottom:none; border-right:none; width:500px;}
table.pagelist td,table.pagelist th{ font-size:12px; border:1px solid #ccc; border-top:none; border-left:none;}
p.paginatedNav{ font-size:12px; width:480px; margin-top:8px; text-align:right;}
p.paginatedNav a{ color:#ccc;}
p.paginatedNav a:link,p.paginatedNav a:visited{ color:#369;}
</style>
<script type="text/javascript" src="http://www.heluyao.com.cn/DOMhelp.js"></script>
<script type="text/javascript">
<!--
pn = {
 //css class
 paginationClass:'pagelist',
 dynamicClass:'dynamic',
 showClass:'show',
 paginationNavClass:'paginatedNav',
 
 //设置每页显示数据条数
 increase : 5,
 //分页导航的替换文本
 counter:'  _x_到_y_条  共_z_条  ',
 nextLabel:'下一页',
 previousLabel:'上一页',
 
 init:function(){
     var tablebody;
  if(!document.getElementById || !document.createTextNode){return;}
  var ts=document.getElementsByTagName('table');
  for(var i=0;i<ts.length;i++){
   if(!DOMhelp.cssjs('check',ts[i],pn.paginationClass)){continue;}
   if(ts[i].getElementsByTagName('tr').length<pn.increase+1){continue;}
   tablebody=ts[i].getElementsByTagName('tbody')[0];
   ts[i].datarows=tablebody.getElementsByTagName('tr');
   ts[i].datarowsize=ts[i].datarows.length;
   ts[i].current=null;
   DOMhelp.cssjs('add',ts[i],pn.dynamicClass);
   pn.createPaginationNav(ts[i]);
   pn.showSection(ts[i],0);
  }
 },
 createPaginationNav:function(table){
  var navBefore,navAfter;
  navBefore=document.createElement('p');
  DOMhelp.cssjs('add',navBefore,pn.paginationNavClass);
  navBefore.appendChild(DOMhelp.createLink('#',pn.previousLabel));
  navBefore.appendChild(document.createElement('span'));
  counter=pn.counter.replace('_x_',1);
  counter=counter.replace('_y_',pn.increase);
  counter=counter.replace('_z_',table.datarowsize-1);
  navBefore.getElementsByTagName('span')[0].innerHTML=counter;
  navBefore.appendChild(DOMhelp.createLink('#',pn.nextLabel));
  table.parentNode.insertBefore(navBefore,table);
  navAfter=navBefore.cloneNode(true);
  table.parentNode.insertBefore(navAfter,table.nextSibling);
  table.topPrev=navBefore.getElementsByTagName('a')[0];
  table.topNext=navBefore.getElementsByTagName('a')[1];
  table.bottomPrev=navAfter.getElementsByTagName('a')[0];
  table.bottomNext=navAfter.getElementsByTagName('a')[1];
  DOMhelp.addEvent(table.topPrev,'click',pn.navigate,false); 
  DOMhelp.addEvent(table.bottomPrev,'click',pn.navigate,false); 
  DOMhelp.addEvent(table.topNext,'click',pn.navigate,false); 
  DOMhelp.addEvent(table.bottomNext,'click',pn.navigate,false); 
  table.bottomNext.onclick=DOMhelp.safariClickFix;
  table.topPrev.onclick=DOMhelp.safariClickFix;
  table.bottomPrev.onclick=DOMhelp.safariClickFix;
  table.topNext.onclick=DOMhelp.safariClickFix;
  table.topCounter=navBefore.getElementsByTagName('span')[0];
  table.bottomCounter=navAfter.getElementsByTagName('span')[0];
 },
 navigate:function(e){
  var start, table;
  var t=DOMhelp.getTarget(e);
  while(t.nodeName.toLowerCase()!='a'){t=t.parentNode;}
  if(t.getAttribute('href') == null || t.getAttribute('href') == ''){return;}
  if(t.parentNode.previousSibling.nodeName.toLowerCase() == 'table'){
   table=t.parentNode.previousSibling; 
  }else{
   table=t.parentNode.nextSibling; 
  }
  if(t==table.topNext || t==table.bottomNext){
   start=table.current+pn.increase;
  }else if(t==table.topPrev || t==table.bottomPrev){
   start=table.current-pn.increase;
  }
  pn.showSection(table,start)
 },
 showSection:function(table,start){
  var i;
  pn.changePaginationNav(table,start);
  if(table.current!=null){
   for(i=table.current;i<table.current+pn.increase;i++){
    if(table.datarows[i]){
     DOMhelp.cssjs('remove',table.datarows[i],pn.showClass);
    }
   } 
  }
  for(i=start;i<start+pn.increase;i++){
   if(table.datarows[i]){
    DOMhelp.cssjs('add',table.datarows[i],pn.showClass); 
   }
  }
  table.current=start;
 },
 changePaginationNav:function(table,start){
  if(start-pn.increase<0){
   table.bottomPrev.removeAttribute('href');
   table.topPrev.removeAttribute('href');
  }else{
   table.bottomPrev.setAttribute('href','#');
   table.topPrev.setAttribute('href','#');
  }
  if(start+pn.increase>table.datarowsize-2){
   table.bottomNext.removeAttribute('href');
   table.topNext.removeAttribute('href'); 
  }else{
   table.bottomNext.setAttribute('href','#');
   table.topNext.setAttribute('href','#');
  }
  var counter=pn.counter.replace('_x_',start+1);
  var last=start+pn.increase;
  if(last>table.datarowsize){last=table.datarowsize;}
  counter=counter.replace('_y_',last);
  counter=counter.replace('_z_',table.datarowsize);
  table.topCounter.innerHTML=counter;
  table.bottomCounter.innerHTML=counter;
 }
}
DOMhelp.addEvent(window,'load',pn.init,false);
-->
</script>
</head>
<body>
<table class="pagelist" cellspacing="0" cellpadding="0">
<thead>
 <tr><th scope="col">ID</th><th scope="col">作者</th><th scope="col">标题</th><th scope="col">介绍</th></tr>
</thead>
<tbody>
 <tr><th>1</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>2</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>3</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>4</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>5</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>6</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>7</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>8</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>9</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>10</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>11</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>12</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>13</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>14</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>15</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>16</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>17</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>18</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>19</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>20</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
 <tr><th>21</th><td>萧涤非 等著</td><td>唐诗鉴赏辞典</td><td>《唐诗鉴赏辞典》为代表的文学鉴赏辞典系列</td></tr>
 <tr><th>22</th><td>左民安</td><td>细说汉字（精装版）</td><td>这是一本介绍汉字基本知识的通俗读物</td></tr>
</tbody>
</table>
</body>
</html>

为了提高速度，LinkedHashMap散列化所有的元素，但是在遍历键值对时，却又以元素的插入顺序返回键值对（System.out.println()会迭代遍历该映射，因此可以看到遍历的结果）。此外，可以在构造器中设定LinkedHashMap，使之采用基于访问的最近最少使用（LRU）算法，于是没有被访问过的（可被看作需要删除的）元素就会出现在队列的前面。对于需要定期清理元素以节省空间的程序来说，此功能使得程序很容易得以实现。下面就是一个简单的例子，它演示了LinkedHashMap的这两种特点： 在输出中可以看到，键值对是以插入的顺序进行遍历的，甚至LRU算法的版本也是如此。但是，在LRU版本中，在（只）访问过前面六个元素后，最后三个元素移到了队列前面。然后再一次访问元素“o”时，它就被移到队列后端了。
LinkedHashMap平常用的比较少，但是却是用在相当重要的地方，利用其LRU算法可以创建对象池、连接池等等。

    1、是否为空：
            ${empty sessionScope.username}
    2、是否不为空
            ${not empty sessionScope.username}
    3、得到请求参数
            ${param.username}
    4、判断数字
            ${requestScope.age==20}
    5、判断字符串
            ${requestScope.username=='vickzhu'}
            或者${requestScope.username=="vickzhu"}
    6、选中单选、复选、下拉框
            下拉框：<option value="${cityInfo.cityCode }" ${param.cityCode==cityInfo.cityCode? "selected='selected'":"" } >${cityInfo.cityName }</option>
            单选、复选：<input name="gender" type="radio" ${param.gender==1?"checked='checked'":"" } value="1" />男
                                    <input name="gender" type="radio" ${param.gender==2?"checked='checked'":"" } value="2" />女

不论是在开发还是在已经发布的项目中，我们经常会碰到的一个问题：
    java.lang.OutOfMemoryError: PermGen space

PermGen space的全称是Permanent Generation space,是指内存的永久保存区域，OutOfMemoryError: PermGen space从表面上看就是内存溢出，解决方法是加大内存。说说为什么会内存溢出：PermGen space用于存放Class和Meta的信息,Class在被 Load的时候被放入PermGen space区域，它和存放Instance的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的APPLICATION会LOAD很多CLASS的话,就很可能出现PermGen space错误。这种错误常见在web服务器对JSP进行pre compile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。

建议：将相同的第三方jar文件移置到tomcat/lib目录下，这样可以达到减少jar 文档重复占用内存的目的。
改正方法：-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m

其中-Xms<size> 为JVM初始化堆的大小
        -Xmx<size> 为JVM堆的最大值
        -XX:MaxNewSize 为调大新对象区，以减少垃圾回收器回收次数

但是有的时候可能这样的设置还会不行(比如，当Server应用程序加载较多类时，即jvm加载类时，永久域中的对象急剧增加，从而使jvm不断调整永久域大小，为了避免调整)，你可以使用更多的参数配置，如： java -Xms512m -Xmx512m -XX:PermSize=64m -XX:MaxPermSize=128m
其中，使用   -XX:MaxPermSize标志来增加永久域的大小，-XX:PermSize标志设置初始值
如果虚拟机启动时设置使用的内存比较小而在这种情况下有许多对象进行初始化，虚拟机就必须重复地增加内存来满足使用。由于这种原因，我们一般把-Xms和-Xmx设为一样大，而堆的最大值受限于系统使用的物理内存。一般使用数据量较大的应用程序会使用持久对象，内存使用有可能迅速地增长。当应用程序需要的内存超出堆的最大值时虚拟机就会提示内存溢出，并且导致应用服务崩溃。因此一般建议堆的最大值设置为可用内存的最大值的80%。


在tomcat中redeploy时出现outofmemory的错误.
可以有以下几个方面的原因:
１,使用了proxool,因为proxool内部包含了一个老版本的cglib.
2, log4j,最好不用,只用common-logging
3, 老版本的cglib,快点更新到最新版。
４，更新到最新的hibernate3.2

< jsp-config> 包括< taglib> 和< jsp-property-group> 两个子元素。

其中< taglib>元素在JSP 1.2时就已经存在，用于在jsp页面引用标签库描述符(.tld)；而< jsp-property-group>是JSP 2.0 新增的元素，用于设置jsp页面的某些属性。

< jsp-property-group>元素主要有八个子元素，它们分别为：

1.< description>：设定的说明；
2.< display-name>：设定名称；
3.< url-pattern>：设定值所影响的范围，如：/CH2 或 /*.jsp；
4.< el-ignored>：若为true，表示不支持EL 语法；
5.< scripting-invalid>：若为true，表示不支持< % scripting %>语法；
6.< page-encoding>：设定JSP 网页的编码；
7.< include-prelude>：设置JSP 网页的抬头，扩展名为.jspf；
8.< include-coda>：设置JSP 网页的结尾，扩展名为.jspf。

一个简单的< jsp-config>元素完整配置：

< jsp-config>
< taglib>
< taglib-uri>Taglib< /taglib-uri>
< taglib-location>/WEB-INF/tlds/MyTaglib.tld< /taglib-location>
< /taglib>
< jsp-property-group>
< description>Special property group for JSP Configuration JSP example.< /description>
< display-name>JSPConfiguration< /display-name>
< url-pattern>/jsp/* < /url-pattern>
< el-ignored>true< /el-ignored>
< page-encoding>GB2312< /page-encoding>
< scripting-invalid>true< /scripting-invalid>
< include-prelude>/include/prelude.jspf< /include-prelude>
< include-coda>/include/coda.jspf< /include-coda>
< /jsp-property-group>
< /jsp-config>

　Java对象的生命周期分析

　　Java对象的生命周期大致包括三个阶段：对象的创建，对象的使用，对象的清除。因此，对象的生命周期长度可用如下的表达式表示：T = T1 + T2 +T3。其中T1表示对象的创建时间，T2表示对象的使用时间，而T3则表示其清除时间。由此，我们可以看出，只有T2是真正有效的时间，而T1、T3则是对象本身的开销。下面再看看T1、T3在对象的整个生命周期中所占的比例。

　　我们知道，Java对象是通过构造函数来创建的，在这一过程中，该构造函数链中的所有构造函数也都会被自动调用。另外，默认情况下，调用类的构造函数时，Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。所以用new关键字来新建一个对象的时间开销是很大的，如表1所示。

　　表1 一些操作所耗费时间的对照表

运算操作	示例	标准化时间
本地赋值	i = n	1.0
实例赋值	this.i = n	1.2
方法调用	Funct()	5.9
新建对象	New Object()	980
新建数组	New int[10]	3100

　　从表1可以看出，新建一个对象需要980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而若新建一个数组所花费的时间就更多了。

　　再看清除对象的过程。我们知道，Java语言的一个优势，就是Java程序员勿需再像C/C++程序员那样，显式地释放对象，而由称为垃圾收集器（Garbage Collector）的自动内存管理系统，定时或在内存凸现出不足时，自动回收垃圾对象所占的内存。凡事有利总也有弊，这虽然为Java程序设计者提供了极大的方便，但同时它也带来了较大的性能开销。这种开销包括两方面，首先是对象管理开销，GC为了能够正确释放对象，它必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等。其次，在GC开始回收“垃圾”对象时，系统会暂停应用程序的执行，而独自占用CPU。

　　因此，如果要改善应用程序的性能，一方面应尽量减少创建新对象的次数；同时，还应尽量减少T1、T3的时间，而这些均可以通过对象池技术来实现。

　　对象池技术的基本原理

　　对象池技术基本原理的核心有两点：缓存和共享，即对于那些被频繁使用的对象，在使用完后，不立即将它们释放，而是将它们缓存起来，以供后续的应用程序重复使用，从而减少创建对象和释放对象的次数，进而改善应用程序的性能。事实上，由于对象池技术将对象限制在一定的数量，也有效地减少了应用程序内存上的开销。

　　实现一个对象池，一般会涉及到如下的类：

　　1）对象池工厂（ObjectPoolFactory）类

　　该类主要用于管理相同类型和设置的对象池（ObjectPool），它一般包含如下两个方法：

　　·createPool：用于创建特定类型和设置的对象池；

　　·destroyPool：用于释放指定的对象池；

　　同时为保证ObjectPoolFactory的单一实例，可以采用Singleton设计模式，见下述getInstance方法的实现：

public static ObjectPoolFactory getInstance() { 　if (poolFactory == null) { 　　poolFactory = new ObjectPoolFactory(); 　} 　return poolFactory; }

　　2）参数对象（ParameterObject）类

　　该类主要用于封装所创建对象池的一些属性参数，如池中可存放对象的数目的最大值（maxCount）、最小值（minCount）等。

　　3）对象池（ObjectPool）类

　　用于管理要被池化对象的借出和归还，并通知PoolableObjectFactory完成相应的工作。它一般包含如下两个方法：

　　　·getObject：用于从池中借出对象；
　　　·returnObject：将池化对象返回到池中，并通知所有处于等待状态的线程；

　　4）池化对象工厂（PoolableObjectFactory）类

　　该类主要负责管理池化对象的生命周期，就简单来说，一般包括对象的创建及销毁。该类同ObjectPoolFactory一样，也可将其实现为单实例。

 

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

publicclass TestTimer {

   

    publicstaticvoid main(String[] args) throws ParseException {

       TestTimer tt=new TestTimer();

       tt.vick();

    }   

    publicvoid vick() throws ParseException{

       Timer timer=new Timer();

       Test timerTask=new Test();

       SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

       Date d=df.parse("2008-08-21 09:00:00");   //在这里设置开始时间

       long delay=d.getTime()-System.currentTimeMillis();   //延迟多少毫秒后开始调用

       long cycle=24*60*60*1000;   //循环调用的时间间隔

       timer.schedule(timerTask, delay, cycle);

    }

}

class Test extends TimerTask{

    privateinti=1;

    publicvoid run() {

       System.out.println("这是第 "+i+" 次调用，时间为:"+new Date());

       i++;

    }

}

        其实servletContext和application 是一样的，就相当于一个类创建了两个不同名称的变量
        大家只要打开jsp编译过后生成的Servlet中的_jspService()方法就可以看到如下的声明：
            ServletContext application = null;
        两者的区别就是application用在jsp中，servletContext用在servlet中
        很简单的问题，但是有很多人在问。

一，修改tomcat配置
         将tomcat的server.xml配置文件中的connector节点加上属性：useBodyEncodingForURI="true"
          <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443"
               useBodyEncodingForURI="true"
            />
        或者在配置中加上 URIEncoding="utf-8"
        这是最切实及有效的方式！最大的缺点是需要修改配置文件

二，jsp编码
        未完待续......

 

1.
tomcat5下jsp出现getOutputStream() has already been called for this response异常的原因和解决方法

在tomcat5下jsp中出现此错误一般都是在jsp中使用了输出流（如输出图片验证码，文件下载等），
没有妥善处理好的原因。
具体的原因就是
在tomcat中jsp编译成servlet之后在函数_jspService(HttpServletRequest request, HttpServletResponse response)的最后
有一段这样的代码
finally {
    if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);
  }
这里是在释放在jsp中使用的对象，会调用response.getWriter(),因为这个方法是和
response.getOutputStream()相冲突的！所以会出现以上这个异常。

然后当然是要提出解决的办法，其实挺简单的（并不是和某些朋友说的那样--
将jsp内的所有空格和回车符号所有都删除掉），

在使用完输出流以后调用以下两行代码即可：
out.clear();
out = pageContext.pushBody();

最后这里是一个输出彩色验证码例子（这样的例子几乎随处可见）
imag.jsp

<%@ page import="java.awt.*,java.awt.image.*,java.util.*,javax.imageio.*" %>
<%@ page import="java.io.OutputStream" %>
<%!
Color getRandColor(int fc,int bc){
Random random = new Random();
if(fc>255) fc=255;
if(bc>255) bc=255;
int r=fc+random.nextInt(bc-fc);
int g=fc+random.nextInt(bc-fc);
int b=fc+random.nextInt(bc-fc);
return new Color(r,g,b);
}
%>
<%
try{
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
int width=60, height=20;
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
OutputStream os=response.getOutputStream();
Graphics g = image.getGraphics();
Random random = new Random();
g.setColor(getRandColor(200,250));
g.fillRect(0, 0, width, height);

g.setFont(new Font("Times New Roman",Font.PLAIN,18));
g.setColor(getRandColor(160,200));
for (int i=0;i<155;i++)
{
int x = random.nextInt(width);
int y = random.nextInt(height);
int xl = random.nextInt(12);
int yl = random.nextInt(12);
g.drawLine(x,y,x+xl,y+yl);
}
String sRand="";
for (int i=0;i<4;i++){
String rand=String.valueOf(random.nextInt(10));
sRand+=rand;
g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
g.drawString(rand,13*i+6,16);
}
session.setAttribute("rand",sRand);
g.dispose();

ImageIO.write(image, "JPEG",os);
os.flush();
os.close();
os=null;
response.flushBuffer();
out.clear();
out = pageContext.pushBody();
}
catch(IllegalStateException e)
{
System.out.println(e.getMessage());
e.printStackTrace();
}%>

2
getOutputStream() has already been called for this response问题的解决
在jsp向页面输出图片的时候,使用response.getOutputStream()会有这样的提示：java.lang.IllegalStateException:getOutputStream() has already been called for this response,会抛出Exception

原因一:
JSP默认的输出流为PrintWriter ,即<% %>以外的东西所默认的输出方式,如果你尝试在JSP中使用ServletOutputStream就会引起错误.要嘛直接改用Servlet输出(复写service方法),要嘛删除除%><%中的任何东西(包括HTML标签,空格,回车等东西)应该就可以。
对于这样的情况应该这样来解决，删除%><%之间的所有内容包括空格和换行符，最后也要消除空格和换行符，最好再加上一句response.reset()。
原因二:
 
在J2EE的API参考里有这么个:

ServletResponse的getWriter()方法里会抛出这个异常,

IllegalStateException - if the getOutputStream method has already been called
for this response object

而它的getOutputStream()方法里会抛出这个异常.

IllegalStateException - if the getOutputStream method has already been called for this response object

并且两者的函数申明里都有这么样的一句
Either this method or getOutputStream() may be called to write the body, not both.
Either this method or getWriter() may be called to write the body, not both.

以上说明也解释了为什么在往页面中写入图片的时候要使用如下循环格式
OutputStream output=response.getOutputStream();
while((len=in.read(b)) >0)
{
output.write(b,0,len);

}
output.flush();
而不是把response.getOutputStream().write()放到循环体内

//document构造工厂，学过工厂模式的都知道
DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
//document构造器
DocumentBuilder db=dbf.newDocumentBuilder();
//StringReader用来将字符串转化为流
StringReader sr=new StringReader("str");
InputSource is=new InputSource(sr);
//转换document
Document doc=db.parse(is);

       我要抓取的页面的完整路径为：http://www.google.cn/language_tools?hl=zh-CN

       String strServer="www.google.cn";//这里同样可以用ip来访问:203.208.35.100

       String strPage="/language_tools?hl=zh-CN";

       try {

           String hostname = strServer;

           int port = 80;

           InetAddress addr = InetAddress.getByName(hostname);

           Socket socket = new Socket(addr, port);

           BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF8"));

           wr.write("GET " + strPage + " HTTP/1.0"r"n");

           wr.write("HOST:" + strServer + ""r"n");

           wr.write(""r"n");

           wr.flush();

           BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));

           String line;

           while ((line = rd.readLine()) != null) {

              System.out.println(line);

           }

           wr.close();

           rd.close();

       } catch (Exception e) {

           System.out.println(e.toString());

       }

   一、<c:forEarch>
             

     <c:forEach items="${docList}"var="doc" varStatus="li">

        <tr>

           <td>

              <a href="doc.action?URL=<%=URLEncoder.encode("ID="+((Map)pageContext.getAttribute("doc")).get("ID")) >">${doc.title }</a>

           </td>

        </tr>

     </c:forEach>

            由此可见，forEarch中变量保存的范围为pageContext

    二、<ww:iterator>
             

      <ww:iterator value="#request['questions']" id="question" status="li">

          <div class="layer_con">

              <ul>

                  <li class="layer_p">

                      <a href="details.action?qstID=<%=((Question)request.getAttribute("question")).getID() %>"></a>

                  </li>

              </ul>

          </div>       

      </ww:iterator>

            webwork是将变量保存在request中的
    三、struts的迭代变量保存在pageContext里

得到当前元素并改变背景色：
         <script type="text/javascript"> 
             function changeColor(src){
              var obj=document.getElementsByTagName("td");
              for (i=0;i<obj.length;i++ ) 
             { 
               obj[i].style.backgroundColor="white"; 
             }

            src.style.backgroundColor="red";
             src.children.tags('a')[0].style.backgroundColor="cyan";
             alert(src.parentElement.tagName);
             }
            </script>

        <table>
            <tr>
                <td onclick="javascript:changeColor(this)"><a>aaa</a></td>
                <td onclick="javascirpt:changeColor(this)"><a>bbb</a></td>
                <td onclick="javascirpt:changeColor(this)"><a>ccc</a></td>
            </tr>
        </table>
    

注：改变背景图片
        obj[i].style.background="url(http://localhost:8080/images/abcimg.gif)";