SSH-Struts-Spring-Hibernate

在http://packages.debian.org/zh-tw/lenny/i386/fcitx/download

下载fcitx_3.4.3-1_i386.deb

拷贝到某一目录，如/usr下

安装

执行dpkg -i fcitx_3.4.3-1_i386.deb

debiangary:/usr# dpkg -i fcitx_3.4.3-1_i386.deb

Selecting previously deselected package fcitx.

(Reading database ... 61873 files and directories currently installed.)

Unpacking fcitx (from fcitx_3.4.3-1_i386.deb) ...

Setting up fcitx (3.4.3-1) ...

debiangary:/usr# ls

X11R6 fcitx_3.4.3-1_i386.deb include local share src

bin games lib sbin soft

debiangary:/usr#

在/etc/X11/Xsession.d/目录下创建一个名为25xchinput的文件，其内容如下：

export LAGN=zh_CN.utf8

export LC_CTYPE=zh_CN.utf8

export LC_ALL=

export XMODIFIERS=@im=fcitx

fcitx &

开机后将自动启动fcitx输入法。使用Ctrl+Space切换输入法

 查看全文

eclipse-SDK-3.2-linux-gtk.tar.gz和MyEclipse_5_5_1GA_E3_2_2_Installer.bin整合

在http://myeclipseide.com

下载MyEclipse_5_5_1GA_E3_2_2_Installer.bin

拷贝到/ypu下

在/ypu下执行

chmod 777 MyEclipse_5_5_1GA_E3_2_2_Installer.bin

执行./ MyEclipse_5_5_1GA_E3_2_2_Installer.bin

开始安装

找到已经安装好的eclipse3.2的位置。

在source.list中加入deb http://oss.oracle.com/debian/ unstable main non-free

执行

aptitude update

aptitude oracle-xe-client oracle-xe-universal 包有点大260多兆

开始下载oracle-xe-client oracle-xe-universal，大概需要三十多分钟。

下载完后就开始安装，但是系统会提示交换分区不够，所以要增大交换分区。

分别执行

dd if=/dev/zero of=/mnt/swapfile bs=1024 count=1048576

mkswap /mnt/swapfile

swapon /mnt/swapfile

之后。

现在开始安装oracle 10g express

执行

aptitude install oracle-xe-client oracle-xe-universal

安装完成后将提示进行参数配置

执行/etc/init.d/oracle-xe configure

将设置HTTP 端口，默认是8080，此处设置为8081，为了不和tomcat冲突

设置Oracle服务端口使用默认的1521

最后是设置sys和system的密码

系统提示是否开机自动运行oracle，选择yes

最后重启debian

通过http://127.0.0.1:8081/apex/或http://localhost:8081/apex进行管理

在http://tomcat.apache.org/download-60.cgi

下载apache-tomcat-6.0.18.tar.gz

拷贝到/usr/soft/tomcat下

并在目录/usr/soft/tomcat下

执行tar –xzvf apache-tomcat-6.0.18.tar.gz

将解压生成apache-tomcat-6.0.18文件夹，为了简单，将其更名为tomcat6

mv apache-tomcat-6.0.18 tomcat6

如果已经设置好JRE_HOME环境变量，则可在目录/usr/soft/tomcat/tomcat6/bin下执行

./startup.sh驱动tomcat

./shutdown.sh关闭tomcat

设置环境变量TOMCAT_HOME、CATALINA_HOME，修改/etc/profile文件如下：

# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))

# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).

if [ "`id -u`" -eq 0 ]; then

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

else

PATH="/usr/local/bin:/usr/bin:/bin:/usr/games"

fi

if [ "$PS1" ]; then

if [ "$BASH" ]; then

PS1='u@h:w$ '

else

if [ "`id -u`" -eq 0 ]; then

PS1='# '

else

PS1='$ '

fi

fi

fi

PATH=$PATH:/usr/soft/java/jdk/bin:/usr/soft/java/jdk/jre/bin

JAVA_HOME=/usr/soft/java/jdk

JRE_HOME=/usr/soft/java/jdk/jre

CLASSPATH=.:/usr/soft/java/jdk/lib/tools.jar:/usr/soft/java/jdk/lib/dt.jar

TOMCAT_HOME=/usr/soft/tomcat/tomcat6

CATALINA_HOME=/usr/soft/tomcat/tomcat6

export PATH

export JAVA_HOME

export JRE_HOME

export CLASSPATH

export TOMCAT_HOME

export CATALINA_HOME

umask 022

在www.eclipse.org

下载eclipse-jee-ganymede-linux-gtk.tar.gz

安装：

在拷贝eclipse-jee-ganymede-linux-gtk.tar.gz到/usr/soft/eclipse目录下，cd到该目录，执行：

tar -zvxf eclipse-jee-ganymede-linux-gtk.tar.gz

在/usr/soft/eclipse下生成eclipse包，进入eclipse下，即/usr/soft/eclipse/eclipse下，执行./eclipse，将运行eclipse出错，提示：“no java virtual machine was found after searching the following locations：”

解决办法：

原因是没找到jre，解决办法是，进入/usr/soft/eclipse/eclipse目录，建立软连接，连接到jre，

ln -s /usr/soft/java/jdk/jre jre

debiangary:/usr/soft/eclipse/eclipse# ln -s /usr/soft/java/jdk/jre jre

在http://java.sun.com/javase/downloads/ea/6u10/6u10rcDownload.jsp#6u10JREs

下载jdk-6u10-rc-bin-b28-linux-i586-21_jul_2008.bin

拷贝到/usr/soft/java下

并在目录/usr/soft/java下

执行./ jdk-6u10-rc-bin-b28-linux-i586-21_jul_2008.bin将开始安装

安装完成后，在目录/usr/soft/java下下生成jdk1.6.0_10文件夹

为了方便，将其重命名为jdk

mv jdk1.6.0_10 jdk

设置环境变量PATH、JAVA_HOME、JRE_HOME、CLASSPATH，修改/etc/profile文件如下：

# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))

# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).

if [ "`id -u`" -eq 0 ]; then

PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

else

PATH="/usr/local/bin:/usr/bin:/bin:/usr/games"

fi

if [ "$PS1" ]; then

if [ "$BASH" ]; then

PS1='u@h:w$ '

else

if [ "`id -u`" -eq 0 ]; then

PS1='# '

else

PS1='$ '

fi

fi

fi

PATH=$PATH:/usr/soft/java/jdk/bin:/usr/soft/java/jdk/jre/bin

JAVA_HOME=/usr/soft/java/jdk

JRE_HOME=/usr/soft/java/jdk/jre

CLASSPATH=.:/usr/soft/java/jdk/lib/tools.jar:/usr/soft/java/jdk/lib/dt.jar

TOMCAT_HOME=/usr/soft/tomcat/tomcat6

CATALINA_HOME=/usr/soft/tomcat/tomcat6

export PATH

export JAVA_HOME

export JRE_HOME

export CLASSPATH

export TOMCAT_HOME

export CATALINA_HOME

umask 022

笔者先完成Debian的安装后（在Windows XP下的VMWare中安装），首先考虑到是怎么让Windows和Debian之间的资源实现共享。

没用Samba，直接想到了安装SSH

即可用在windows下远程控制Debian，又可以将windows下的文件等直接拷贝到debian下。

安装Debian的SSH：

执行apt-get install openssh-server

将cd1的iso文件引入到VMWare中。

虚拟机à设置

点击CD-ROM(IDE 1:0)，设置如下：

另：

运行安装命令：apt-get install openssh-server 提示有错误，请教了高人，修改/etc/apt/source.list 把源修改为国内的debian.cn99.com就可以正常运行了

apt-get update apt-get install openssh-server

具体的etc/apt/source.list 的配置文件请见附件。（将此文件，不带txt后缀的覆盖掉原来的source.list）

启动/停止服务：/etc/init.d/ssh start|stop|restart

在http://cdimage.debian.org/debian-cd/4.0_r4a/i386/iso-cd/

下载debian-40r4a-i386-DVD-1.iso

放到Windows的目录下：

E:XunleiDebian_DVD_CDdebian-40r4a-i386-DVD-1.iso

安装VMware_ha_vmware.exe后，运行

创建虚拟机

 查看全文

下载eclipse-jee-ganymede-linux-gtk.tar.gz
安装：
在拷贝eclipse-jee-ganymede-linux-gtk.tar.gz到/usr/soft/eclipse目录下，cd到该目录，执行：
tar -zvxf eclipse-jee-ganymede-linux-gtk.tar.gz
在/usr/soft/eclipse下生成eclipse包，进入eclipse下，即/usr/soft/eclipse/eclipse下，执行./eclipse，将运行eclipse出错，提示：“no java virtual machine was found after searching the following locations：”

解决办法：

在debian中安装eclipse：
解压到某位置，此处为/usr/soft/eclipse/，运行eclipse时提示“no java virtual machine was found after searching the following locations：”。
原因是没找到jre，解决办法是，进入/usr/soft/eclipse/eclipse目录，建立软连接，连接到jre，
ln -s /usr/soft/java/jdk/jre jre

debiangary:/usr/soft/eclipse/eclipse# ln -s /usr/soft/java/jdk/jre jre

Windows下Subversion和TortoiseSVN构建SVN版本控制

2008-8-13 杨普

1.下载Subversion的window安装版本svn-1.4.6-setup.exe

http://subversion.tigris.org/

http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=8100

2.下载TortoiseSVN的TortoiseSVN-1.5.2.13595-win32-svn-1.5.1.msi版本

http://tortoisesvn.net/

http://tortoisesvn.net/downloads

3.安装subversion

双击svn-1.4.6-setup.exe，一路next完成安装。

设置环境变量，将subversion对bin设置到path中。如：D:Program FilesSubversionbin

4.安装TortoiseSVN

双击TortoiseSVN-1.5.2.13595-win32-svn-1.5.1.msi，一路next完成安装。

5.创建svn容器Repository

在硬盘上任意位置创建一文件夹，如D:svnRepository，在文件夹上右键

TortoiseSVN->Create repository here

创建成功后将在D:svnRepository下生成一系列文件。

6.配置容器的访问权限

在容器的目录下D:svnRepository的conf中，用记事本打开svnserve.conf文件，找到

# anon-access = read

# auth-access = write

# password-db = passwd

并去掉注释#

注意，去掉注释后，不要留下空格，保持每行顶格，切记！！！

效果如下：

### This file controls the configuration of the svnserve daemon, if you

### use it to allow access to this repository. (If you only allow

### access through http: and/or file: URLs, then this file is

### irrelevant.)

### Visit http://subversion.tigris.org/ for more information.

[general]

### These options control access to the repository for unauthenticated

### and authenticated users. Valid values are "write", "read",

### and "none". The sample settings below are the defaults.

anon-access = read

auth-access = write

### The password-db option controls the location of the password

### database file. Unless you specify a path starting with a /,

### the file's location is relative to the directory containing

### this configuration file.

### If SASL is enabled (see below), this file will NOT be used.

### Uncomment the line below to use the default password file.

password-db = passwd

### The authz-db option controls the location of the authorization

### rules for path-based access control. Unless you specify a path

### starting with a /, the file's location is relative to the the

### directory containing this file. If you don't specify an

### authz-db, no path-based access control is done.

### Uncomment the line below to use the default authorization file.

# authz-db = authz

### This option specifies the authentication realm of the repository.

### If two repositories have the same authentication realm, they should

### have the same password database, and vice versa. The default realm

### is repository's uuid.

# realm = My First Repository

[sasl]

### This option specifies whether you want to use the Cyrus SASL

### library for authentication. Default is false.

### This section will be ignored if svnserve is not built with Cyrus

### SASL support; to check, run 'svnserve --version' and look for a line

### reading 'Cyrus SASL authentication is available.'

# use-sasl = true

### These options specify the desired strength of the security layer

### that you want SASL to provide. 0 means no encryption, 1 means

### integrity-checking only, values larger than 1 are correlated

### to the effective key length for encryption (e.g. 128 means 128-bit

### encryption). The values below are the defaults.

# min-encryption = 0

# max-encryption = 256

配置访问用户列表，用户名加密码

记事本打开该目录下的文件passwd

去掉

# harry = harryssecret

# sally = sallyssecret

的注释#，同意注意每行要顶格，开头也不能有空格。

说明harry = harryssecret表示：用户名=密码

当然也可以自己增加，如gary=gary

最好效果如下：

### This file is an example password file for svnserve.

### Its format is similar to that of svnserve.conf. As shown in the

### example below it contains one section labelled [users].

### The name and password for each user follow, one account per line.

[users]

harry=harryssecret

sally=sallyssecret

gary=gary

7.启动Subversion

因为之前设置了环境变量path= D:Program FilesSubversionbin；因此打开cmd，直接运行命令：svnserve -d -r D:svnRepository

这样Subversion服务器就假设好了。

8.向容器添加需版本控制的文件（也可以远程，只需url为ip就行）

在硬盘上任意位置，右键需要上传的文件的上级文件夹，TortoiseSVN->Import…

此处为了测试，创建文件夹D:importFiles，里面放一doc文件test.doc，即要将test.doc上传到svn中去。右键importFiles，TortoiseSVN->Import…，输入容器的url：

svn://localhost/svnRepository

输入用户名和密码：

就将test.doc文件上传到svn容器了

9.从容器获得test.doc文件（也可以远程，只需url为ip就行）

在任意位置，某文件上右键D:checkOutFiles，点击SVN Checkout…

输入url即可

10.完成

这样就完成的部署和存取，修改相应的文件，提交即可，注意始终保持Subversion的运行。

注意，在第8步中会报错“期望文件系统格式“2”；发现格式“3””

原因是TortoisSVN的版本过高，或与Subversion不匹配。

应该换成低版本的TortoisSVN 用TortoiseSVN-1.4.8.12137-win32-svn-1.4.6.msi

即应该为svn-1.4.6-setup.exe和TortoiseSVN-1.4.8.12137-win32-svn-1.4.6.msi的组合才行，步骤和之前的一样，只是在第6步中的svnserve.conf文件中没有后面的内容

[sasl]

### This option specifies whether you want to use the Cyrus SASL

### library for authentication. Default is false.

### This section will be ignored if svnserve is not built with Cyrus

### SASL support; to check, run 'svnserve --version' and look for a line

### reading 'Cyrus SASL authentication is available.'

# use-sasl = true

### These options specify the desired strength of the security layer

### that you want SASL to provide. 0 means no encryption, 1 means

### integrity-checking only, values larger than 1 are correlated

### to the effective key length for encryption (e.g. 128 means 128-bit

### encryption). The values below are the defaults.

# min-encryption = 0

# max-encryption = 256

Buffalo在经历了两年之久的考验后，近日正式发布2.0版本。Buffalo是一个J2EE轻量级AJAX框架，也是国内著名的开源项目。它与DWR 和JSON-RPC一样，着眼于Web远程调用(Web Remoting)，其简洁而实用的特性一直以来深受开发者喜爱。 Buffalo2.0最大的特点在于其性能的提升，还有完全自行实现的Java到JavaScript协议转换。得益于新的协议实现以及为大规模AJAX 调用而进行的优化，2.0版本比前一阶段版性能有进一步的提高。

　　在国内，对JavaScript技术深入研究的人可谓凤毛麟角，Buffalo的作者陈金洲 (Michael Chen) 就是其中之一。关于这次Buffalo 2.0版本的新特性，陈金洲这样解释：

　　最令人振奋的特性应当是为大规模、频繁远程调用而进行优化的显著性能提升。在2.0-alpha1版本的性能测试中，性能最高提升达到了30%。即便不借助于高级的测试工具，从1.2升级到2.0的用户，应该能显著感受到速度的提升。

　　另外，Buffalo 1.x版本的用户都知道，之前的版本都基于Burlap协议，而Burlap协议的维护者Caucho公司已经很久没有更新这个库了。很多在Resin上使用Buffalo的用户发现这样或者那样基于Burlap的各种问题。种种考虑之后，2.0版本正式使用了完全自行编写的协议解析和转换。
　　当问到Buffalo希望在众多AJAX框架中扮演一个什么样的角色时，他回答：

　　最早的时候希望Buffalo成为一个全功能、全新的、Web 2.0时代的Web框架。异步传输只是其中最基础的一部分。后来发现凭借自己现有的资源（时间，、能力等）不太可能在能够预见的时间内完成这一目标。目前想达到的目标是：最简单最容易使用的AJAX框架。从使用者的反馈看来，这一目标完成的比较不错，大多数用户都能在很短的时间内配置Buffalo并开始使用。

　　那么和Web Remoting框架DWR 和JSON-RPC相比较，在JS-Java之间对象转换功能和协议上，Buffalo有何优势所在？

　　从整体产品上来说，最大的优势在于简单。核心API只有一个方法。在JS-Java对象转换上，谈不上优势吧，各有千秋：buffalo采用自我描述，完整的XML协议，DWR采用自定义文本协议，JSON对JavaScript更友好。

　　社区力量推动Buffalo成长！

　　在一年多前的一次BEA活动上，就曾经听到满江红开源组织的负责人曹晓刚讲述“利用元数据和RIA简化企业应用程序的开发”的主题时推荐了Buffalo。时间过去了这么久，Buffalo并没有像许多的开源项目那样销声匿迹，而是还在不断完善，陈金洲解释了Buffalo的开发路线图和背后的支持动力：

　　2004年11月的时候我提出了AMOWA的概念——即面向消息的Web应用，第二年春即发布了1.0测试版本。具体的日程可以在Buffalo变更历史里看到。从Buffalo产生至今，整整两年了。新的开发计划，还有很多特性没有完成，例如跟Spring更紧密的集成；文件上载支持，以及更好的OPOA支持等。开发计划完全取决于社区的反馈，以及功能纯粹单一的综合衡量。我不希望Buffalo成为庞然大物。

　　其中的动力，我想最大程度上来自于Buffalo社区。在1.2版本发布的时候我写过一篇博客“写在Buffalo1.2发布之后”。我现在的想法虽然稍有不同，但归根结底就是：开源作者提出一个想法，需要得到社区的反馈；同时作者对反馈进行响应。这是一个长期的过程。对此我一直对处在社区中，对Buffalo进行贡献的用户心存感激。Buffalo方便了他们的工作，也满足了我作为一个软件作者某种程度上的虚荣心:)，这种感觉，应该是最大的动力吧。

　　从2.0-alpha升级到Buffalo 2.0正式版！

　　当Buffalo的用户遇到问题时，可以联系Buffalo邮件列表，绝大多数问题都可以找到答案，其他的开发者也会帮助你解决问题。

　　从2.0-alpha1发布至今，经过长达半年多的测试阶段，buffalo 2.0正式版本发布。2.0最大的关注点在于性能的提升和完全自行实现的java到javascript协议转换。根据评测，2.0版本要比前一阶段版本最高提升30%性能。这得益于新的协议实现以及为大规模AJAX调用而进行的优化。

　　对于一直使用alpha版本的用户，此次升级很简单，只需要将相应的jar和js进行替换即可。从1.2.x版本升级的用户，升级也很简单：

* 删除所有burlap*.jar, buffalo*.jar, 替换为buffalo.jar
* 替换新的buffalo.js
* 将继承自BuffaloService的类，对session等信息的使用替换为对RequestContext.getContext().getXXX的使用。（注意，目前有开发者报告在resin 2.1服务器上偶尔会出现丢session的现象）

　　Buffalo2.0正式版本的发布意味着完全自我独立的协议实现，为后续特性的开发打下了基础。

　　马上访问Buffalo并download最新2。0版！

　　初学者可以到Buffalo的中文wiki look一下，这里有详尽的tutorials！

　　当然，在线demo也会生动地展现Buffalo2.0的最新特性！

全球领先的企业基础架构软件公司BEA系统有限公司日前宣布，推出业界第一个统一的混合开发环境——BEAWorkshop10.1。该产品成功地把最佳的开源和商用软件融入到综合开发环境中，是BEA实现Workspace 360°愿景的重要里程碑。它的推出，不仅表明BEA在执行其混合软件战略方面所取得的持续发展，同时进一步增强了BEA在开发工具市场的领先地位。

BEAWorkshop10.1结合了BEAWorkshop for WebLogic和BEA Workshop Studio，旨在提供功能丰富的综合开发环境，有助于让开发人员能把最佳的开源软件和商用软件结合起来，构建具有服务使能的下一代应用——这是BEA混合战略及开发模式的精髓所在。如今，BEA正在履行之前宣布的计划，把现有的开发工具功能和基于Eclipse的NitroX技术（现已改名为Workshop Studio）合并起来。后者是BEA在2005年秋季收购M7公司而获得的技术，它在2006年获得了Eclipse基金会授予的“基于Eclipse的最佳商用工具”奖。

BEA公司负责工具事业部的副总裁BillRoth说：“BEAWorkshop10.1的推出，表明BEA的混合模式愿景已经开花结果。它可以帮助开发人员按自己所需要的方式、采用开源产品和商用产品来构建应用。混合模式已是许多企业的主导开发模式，而BEA是最先认可这种模式的公司。BEA Workshop 10.1的重要性还在于，它再次证明了BEA能够成功地执行计划、优化收购对象的资产，使他们成为BEA产品组合中不可或缺的部分。”

BEAWorkshop10.1旨在支持JavaEE（Java企业版）5，能够有助于加快并从根本上简化应用开发的过程。它提供了一种集成的对象/关系映射Studio，能够提供面向Eclipse的一流的EJB3/JPA、BEA Kodo™、OpenJPA和Hibernate等工具；该产品还包括了独特的AppXRay™技术和所见即所得（WYSIWYG）的开发功能，它们为众多开源和行业标准框架而设计，包括Java Server Faces（JSF）、Struts/Tiles、Spring、JSP/JSTL、EJB3/Hibernate、Apache Beehive及其他框架，有助于进一步简化开发过程、提高整体生产力。Workshop 10.1的新特性还包括全面的拖放式集成开发环境（IDE）和单一管理点功能，前者用于在BEA WebLogic Server上构建企业级服务，后者用于开源maven编译系统的编译、编译报告及编译文档的编制。BEA Workshop不仅支持Apache Tomcat等开源服务器，同时还支持其他应用服务器，比如IBM和JBoss/Redhat的应用服务器。

BEAWorkshop10.1旨在帮助开发人员与架构师进行协作，并通过全面、可扩展的开发环境实现架构的需求。它在BEAWorkSpace 360°愿景中扮演着重要角色。BEA WorkSpace 360°将在2007年陆续上市，旨在从根本上改变业务和IT专业人员在整个扩展型企业中相互协作与独立工作的方式。

密码已经是我们生活工作中必不可少的工具,但一个不安全的密码有又有可能会给我们造成不必要的损失。作为网站设计者,如果我们在网页中能对用户输入的密码进行安全评估,并显示出相应的提示信息,那么对用户设置一个安全的密码将有很大帮助。同时也使得网站更具人性化,更有吸引力.

　　什么是一个安全的密码呢?本程序按以下的方式进行评估.

　　1.如果密码少于5位,那么就认为这是一个弱密码.

　　2.如果密码只由数字、小写字母、大写字母或其它特殊符号当中的一种组成,则认为这是一个弱密码.

　　3.如果密码由数字、小写字母、大写字母或其它特殊符号当中的两种组成,则认为这是一个中度安全的密码.

　　4.如果密码由数字、小写字母、大写字母或其它特殊符号当中的三种以上组成,则认为这是一个比较安全的密码.

　　本程序将根据用户输入的密码分别显示不同的颜色表示密码的强度,具体程序如下:
以下是引用片段：<script language=javascript>



//CharMode函数
//测试某个字符是属于哪一类.
function CharMode(iN){
if (iN>=48 && iN <=57) //数字
return 1;
if (iN>=65 && iN <=90) //大写字母
return 2;
if (iN>=97 && iN <=122) //小写
return 4;
else
return 8; //特殊字符
}

//bitTotal函数
//计算出当前密码当中一共有多少种模式
function bitTotal(num){
modes=0;
for (i=0;i<4;i++){
if (num & 1) modes++;
num>>>=1;
}
return modes;
}

//checkStrong函数
//返回密码的强度级别

function checkStrong(sPW){
if (sPW.length<=4)
return 0; //密码太短
Modes=0;
for (i=0;i<sPW.length;i++){
//测试每一个字符的类别并统计一共有多少种模式.
Modes|=CharMode(sPW.charCodeAt(i));
}

return bitTotal(Modes);

}

//pwStrength函数
//当用户放开键盘或密码输入框失去焦点时,根据不同的级别显示不同的颜色

function pwStrength(pwd){
O_color="#eeeeee";
L_color="#FF0000";
M_color="#FF9900";
H_color="#33CC00";
if (pwd==null||pwd==''){
Lcolor=Mcolor=Hcolor=O_color;
}
else{
S_level=checkStrong(pwd);
switch(S_level) {
case 0:
Lcolor=Mcolor=Hcolor=O_color;
case 1:
Lcolor=L_color;
Mcolor=Hcolor=O_color;
break;
case 2:
Lcolor=Mcolor=M_color;
Hcolor=O_color;
break;
default:
Lcolor=Mcolor=Hcolor=H_color;
}
}

document.getElementById("strength_L").style.background=Lcolor;
document.getElementById("strength_M").style.background=Mcolor;
document.getElementById("strength_H").style.background=Hcolor;
return;
}

</script>

<form name=form1 action="" >
输入密码:<input type=password size=10 onKeyUp=pwStrength(this.value) onBlur=pwStrength(this.value)>
<br>密码强度:
<table width="217" border="1" cellspacing="0" cellpadding="1" bordercolor="#cccccc" height="23" style='display:inline'>
<tr align="center" bgcolor="#eeeeee">

<td width="33%" id="strength_L">弱</td>

<td width="33%" id="strength_M">中</td>

<td width="33%" id="strength_H">强</td>
</tr>
</table>

</form>

java 数据库基本操作
1、java数据库操作基本流程
2、几个常用的重要技巧：
可滚动、更新的记录集
批量更新
事务处理

java数据库操作基本流程：取得数据库连接 - 执行sql语句 - 处理执行结果 - 释放数据库连接
1、取得数据库连接
1）用DriverManager取数据库连接
例子
String className,url,uid,pwd;
className = "oracle.jdbc.driver.OracleDriver";
url = "jdbc:oracle:thin:@127.0.0.1:1521:orasvr;
uid = "system";
pwd = "manager";
Class.forName(className);
Connection cn = DriverManager.getConnection(url,uid,pwd);
2）用jndi(java的命名和目录服务)方式
例子
String jndi = "jdbc/db";
Context ctx = (Context) new InitialContext().lookup("java:comp/env");
DataSource ds = (DataSource) ctx.lookup(jndi);
Connection cn = ds.getConnection();
多用于jsp中

2、执行sql语句
1）用Statement来执行sql语句
String sql;
Statement sm = cn.createStatement();
sm.executeQuery(sql); // 执行数据查询语句（select）
sm.executeUpdate(sql); // 执行数据更新语句（delete、update、insert、drop等）statement.close();
2）用PreparedStatement来执行sql语句
String sql;
sql = "insert into user (id,name) values (?,?)";
PreparedStatement ps = cn.prepareStatement(sql);
ps.setInt(1,xxx);
ps.setString(2,xxx);
...
ResultSet rs = ps.executeQuery(); // 查询
int c = ps.executeUpdate(); // 更新

3、处理执行结果
查询语句，返回记录集ResultSet
更新语句，返回数字，表示该更新影响的记录数
ResultSet的方法
1、next()，将游标往后移动一行，如果成功返回true；否则返回false
2、getInt("id")或getSting("name")，返回当前游标下某个字段的值

4、释放连接
cn.close();
一般，先关闭ResultSet，然后关闭Statement（或者PreparedStatement）；最后关闭Connection

可滚动、更新的记录集
1、创建可滚动、更新的Statement
Statement sm = cn.createStatement(ResultSet.TYPE_SCROLL_ENSITIVE,ResultSet.CONCUR_READ_ONLY);
该Statement取得的ResultSet就是可滚动的
2、创建PreparedStatement时指定参数
PreparedStatemet ps = cn.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

ResultSet.absolute(9000);
批量更新
1、Statement
Statement sm = cn.createStatement();
sm.addBatch(sql1);
sm.addBatch(sql2);
...
sm.executeBatch()
一个Statement对象，可以执行多个sql语句以后，批量更新。这多个语句可以是delete、update、insert等或兼有
2、PreparedStatement
PreparedStatement ps = cn.preparedStatement(sql);
{
ps.setXXX(1,xxx);
...
ps.addBatch();
}
ps.executeBatch();
一个PreparedStatement，可以把一个sql语句，变换参数多次执行，一次更新。

事务的处理
1、关闭Connection的自动提交
cn.setAutoCommit(false);
2、执行一系列sql语句
要点：执行每一个新的sql语句前，上一次执行sql语句的Statement（或者PreparedStatemet）必须先close
Statement sm ;
sm = cn.createStatement(insert into user...);
sm.executeUpdate();
sm.close();

sm = cn.createStatement("insert into corp...);
sm.executeUpdate();
sm.close();

3、提交
cn.commit();
4、如果发生异常，那么回滚
cn.rollback();

JUnit

　　JUnit是由Erich Gamma 和Kent Beck 编写的一个回归测试框架(regression testing framework)。Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何(How)完成功能和完成什么样(What)的功能。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。

　　http://www.junit.org/

　　Cactus

　　Cactus是一个基于JUnit框架的简单测试框架，用来单元测试服务端Java代码。Cactus框架的主要目标是能够单元测试服务端的使用Servlet对象的Java方法如HttpServletRequest,HttpServletResponse,HttpSession等

　　http://jakarta.apache.org/cactus/

　　Abbot

　　Abbot是一个用来测试Java GUIs的框架。用简单的基于XML的脚本或者Java代码，你就可以开始一个GUI。

　　http://abbot.sourceforge.net/

　　JUnitPerf

　　Junitperf实际是junit的一个decorator，通过编写用于junitperf的单元测试，我们也可使测试过程自动化。

　　http://www.clarkware.com/software/JUnitPerf.html

　　DbUnit

　　DbUnit是为数据库驱动的项目提供的一个对JUnit 的扩展，除了提供一些常用功能，它可以将你的数据库置于一个测试轮回之间的状态。

　　http://dbunit.sourceforge.net/

　　Mockrunner

　　Mockrunner用在J2EE环境中进行应用程序的单元测试。它不仅支持Struts actions, servlets，过滤器和标签类还包括一个JDBC和一个JMS测试框架，可以用于测试基于EJB的应用程序。

　　http://mockrunner.sourceforge.net/index.html

　　DBMonster

　　DBMonster是一个用生成随机数据来测试SQL数据库的压力测试工具。

　　http://dbmonster.kernelpanic.pl/

　　MockEJB

　　MockEJB是一个不需要EJB容器就能运行EJB并进行测试的轻量级框架。

　　http://mockejb.sourceforge.net/

　　StrutsTestCase

　　StrutsTestCase 是Junit TestCase类的扩展，提供基于Struts框架的代码测试。StrutsTestCase同时提供Mock 对象方法和Cactus方法用来实际运行Struts ActionServlet，你可以通过运行servlet引擎来测试。因为StrutsTestCase使用ActionServlet控制器来测试你的代码，因此你不仅可以测试Action对象的实现，而且可以测试mappings，from beans以及forwards声明。StrutsTestCase不启动servlet容器来测试struts应用程序(容器外测试)也属于Mock对象测试，但是与EasyMock不同的是，EasyMock是提供了创建Mock对象的API，而StrutsTest则是专门负责测试Struts应用程序的Mock对象测试框架。

　　http://strutstestcase.sourceforge.net/

JFCUnit

　　JFCUnit使得你能够为Java偏移应用程序编写测试例子。它为从用代码打开的窗口上获得句柄提供了支持;为在一个部件层次定位部件提供支持;为在部件中发起事件(例如按一个按钮)以及以线程安全方式处理部件测试提供支持。

　　http://jfcunit.sourceforge.net/

　　JTestCase

　　JTestCase 使用XML文件来组织多测试案例数据，声明条件(操作和期望的结果)，提供了一套易于使用的方法来检索XML中的测试案例，按照数据文件的定义来声明结果。

　　http://jtestcase.sourceforge.net/

　　SQLUnit

　　SQLUnit是一个单元测试框架，用于对数据库存储过程进行回归测试。用Java/JUnit/XML开发。

　　http://sqlunit.sourceforge.net

　　JTR

　　JTR (Java Test Runner)是一个开源的基于反转控制(IOC)的J2EE测试框架。它允许你构建复杂的J2EE测试套件(Test Suites)并连到应用服务器执行测试,可以包括多个测试实例。JTR的licensed是GPL协议。

　　http://jtrunner.sourceforge.net/

　　Marathon

　　Marathon是一个针对使用Java/Swing开发GUI应用程序的测试框架，它由recorder, runner 和editor组成，测试脚本是python代码。Marathon的焦点是放在最终用户的测试上。

　　http://marathonman.sourceforge.net

　　TestNG

　　TestNG是根据JUnit 和NUnit思想而构建的一个测试框架，但是TestNG增加了许多新的功能使得它变得更加强大与容易使用比如：

　　*支持JSR 175注释(JDK 1.4利用JavaDoc注释同样也支持)

　　*灵活的Test配置

　　*支持默认的runtime和logging JDK功能

　　*强大的执行模型(不再TestSuite)

　　*支持独立的测试方法。

　　http://testng.org/

　　Surrogate Test framework

　　Surrogate Test framework是一个值得称赞单元测试框架，特别适合于大型，复杂Java系统的单元测试。这个框架能与JUnit,MockEJB和各种支持模拟对象(mock object )的测试工具无缝给合。这个框架基于AspectJ技术。

　　http://surrogate.sourceforge.net

　　MockCreator

　　MockCreator可以为给定的interface或class生成模拟对象(Mock object)的源码。

　　http://mockcreator.sourceforge.net/

jMock

　　jMock利用mock objects思想来对Java code进行测试。jMock具有以下特点:容易扩展，让你快速简单地定义mock objects,因此不必打破程序间的关联，让你定义灵活的超越对象之间交互作用而带来测试局限，减少你测试地脆弱性。

　　http://www.jmock.org/

　　EasyMock

　　EasyMock为Mock Objects提供接口并在JUnit测试中利用Java的proxy设计模式生成它们的实例。EasyMock最适合于测试驱动开发。

　　http://www.easymock.org/

　　The Grinder

　　The Grinder是一个负载测试框架。在BSD开源协议下免费使用。

　　http://grinder.sourceforge.net/

　　XMLUnit

　　XMLUnit不仅有Java版本的还有.Net版本的。Java开发的XMLUnit提供了两个JUnit 扩展类XMLAssert和XMLTestCase,和一组支持的类。这些类可以用来比较两张XML之间的不同之处，展示XML利用XSLT来,校验XML,求得XPath表达式在XML中的值,遍历XML中的某一节点利DOM展开,

　　http://xmlunit.sourceforge.net/

　　Jameleon

　　Jameleon一个自动化测试工具。它被用来测试各种各样的应用程序，所以它被设计成插件模式。为了使整个测试过程变得简单Jameleon提供了一个GUI,因此Jameleon实现了一个Swing 插件。

　　http://jameleon.sourceforge.net/index.html

　　J2MEUnit

　　J2MEUnit是应用在J2ME应用程序的一个单元测试框架。它基于JUnit.

　　http://j2meunit.sourceforge.net/

　　Jetif

　　Jetif是一个用纯Java实现的回归测试框架。它为Java程序单元测试以及功能测试提供了一个简单而且可伸缩的架构，可以用于个人开发或企业级开发的测试。它容易使用，功能强大，而且拥有一些企业级测试的重要功能。Jetif来源于JUnit, JTestCase以及TestNG的启发，有几个基本的概念直接来自于JUnit，比如说断言机制，Test Listener的概念，因此从JUnit转到Jetif是非常容易的。

　　http://jetif.sourceforge.net/

　　GroboUtils

　　GroboUtils使得扩展Java测试变得可能。它包括用在Java不同方面测试的多个子项目。在GroboUtils中最常被到的工具是:多线程测试(multi-threaded tests),整体单元测试(hierarchial unit tests),代码覆盖工具(code coverage tool)。

　　http://groboutils.sourceforge.net/

　　Testare

　　TESTARE是用来简化分布式应用程序(比如:在SERVLETS,JMS listeners, CORBA ORBs或RMI环境下)测试开发过程的一个测试框架.

　　https://testare.dev.java.net/

Java在最近几年逐渐升温，随着Java SE 5和Java SE 6的推出，Java的未来更显得无比辉煌。但以Java为基础的JSP在Java SE 5推出之前却一直抬不起头来，这最重要的原因就是JSP虽然功能十分强大，但最大的优点也是它的最大缺点，功能强大就意味着复杂，尤其是设计前端界面的可视化工具不多，也不够强大。因此，设计JSP页面就变得十分复杂和繁琐。不过，在Java SE 5推出的同时，Sun为了简化JSP的开发难度，推出了新的JavaServer Faces(简称JSF)规范。从而使JSP走上了康庄大道。

　　一、什么是JSF

　　JSF和JSP是一对新的搭档。JSP是用于后台的逻辑处理的技术，而JSF恰恰相反，是使开发人员能够快速的开发基于 Java 的 Web 应用程序的技术，是一种表现层技术。目前，JSF1.2已经正式作为一个标准加入了Java EE 5中。

　　作为一种高度组件化的技术，开发人员可以在一些开发工具的支持下，实现拖拉式编辑操作，用户只需要简单的将 JSF 组件拖到页面上，就可以很容易的进行 Web 开发了。这是其作为一种组件化的技术所具有的最大好处，我们能用的组件不光是一些比较简单的输入框之类，还有更多复杂的组件可以使用的，比如 DataTable 这样的表格组件， Tree 这样的树形组件等等。

　　作为一种标准的技术，JSF还得到了相当多工具提供商的支持。同时我们也会有很多很好的免费开发工具可以使用，前不久 Sun Java Studio Creator 2 和 Oracle JDeveloper 10g 作为免费的支持 JSF 的开发工具发布，给 JSF 带来了不小的生气。另外我们也有一些很优秀的商业开发工具可共选择，BEA Workshop (原 M7 NitroX)，Exadel，MyEclipse 这样的基于 Eclipse 的插件开发工具，为现在广大的 Eclipse 用户带来了不小的便利，IBM 的 Rational Application Developer 和 Borland 的 JBuilder 也是很不错的支持 JSF 可视化开发的商业开发工具。

　　JSF和传统的Web技术有着本质上的差别，在传统的Web技术需要用户自己对浏览器请求进行捕捉，保存客户端状态，并且手工控制着页面的转向，等等。而JSF的出现，无疑给我们带来了巨大的便利，JSF 提供了事件驱动的页面导航模型，该模型使应用程序开发人员能够设计应用程序的页面流。与 Struts 的方式向类似的是，所有的页面流信息都定义在 JSF 配置 XML 文件 (faces-config.xml) 中，而非硬编码在应用程序中。这很大程度简化了开发人员开发难度，简化了应用程序的开发。

　　同时JSF也是一种遵循模型-视图－控制器 (MVC) 模式的框架。实现了视图代码(View)与应用逻辑(Model)的完全分离，使得使用 JSF 技术的应用程序能够很好的实现页面与代码的分离。所有对 JSF 页面的请求都会通过一个前端控制器 (FacesServlet) 处理，系统自动处理用户的请求，并将结果返回给用户。这和传统的 MVC 框架并没有太大的区别。

　　在JSF中不仅使用了 POJO 技术，而且还使用了类似 Spring 的控制反转(IoC) (或称为依赖注入-DI) 技术，在 JSF 的 Backing Bean 中，我们可以把视图所需要的数据和操作放进一个 Backing Bean 中。同时得益于 JSF 使用的 DI 技术，我们可以在配置文件中初始化 Managed Bean，同时我们也可以通过这样的技术很方便的和使用类似技术的 Spring 进行整合。

二、如何在JSP中使用JSF
　　JSF只有通过和JSP相结合，才能充分发挥它的功效。JSF是通过标签库和JSP进行集成的。标签库就相当于ASP.NET的服务端组件。JSF提供了非常丰富的标签库，通过这些标签库，可以生成各种客户端模型，如HTML、WML、XML以及JavaScript等。通过这些标签，你可以很容易建立大规模的客户端模型，并由这些标签自动处理客户端请求。

　　接下来让我们来看一个如何使JSF和JSP在一起工作的例子。在JSF中有两个库。第一个叫做内核库，在这个库中包含了各种主要的标签，如配置组件、管理事件、验证输入信息等。第二个库的主要功能是将HTML和JSF的各种标签相对应。每一个JSF标签都会对应一个HTML组件。如UIInput标签对应了HTML中的文本框或密码框。

　　在JSF标签中文本输入框叫做inputText，而密码输入库叫inputSecret。下面是一个简单的JSF和JSP结合的用户接口程序。

＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %＞ ＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %＞ ＜html＞ ＜head＞ ＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞ ＜title＞第一个JSF程序＜/title＞ ＜/head＞ ＜body＞ 　＜f:view＞ 　＜h:form id="simpleForm"＞ 　＜h:outputText id="favoriteLabel" value="请输入一个数字："/＞ 　＜h:inputText id="favoriteValue" value="#{simple.longValue}"＞ 　　＜f:validateLongrange maximum="30" minimum="0"/＞ 　＜/h:inputText＞ 　＜p/＞ 　＜h:commandButton id="submit" value="提交" action="#{simple.simpleActionMethod}"/＞ 　＜/h:form＞ 　＜/f:view＞ ＜/body＞ ＜/html＞

　　在上面的代码中，我们可以了解到JSF是如何同JSP集成的。我们首先可以看到一个内核标签：view。然后是几个JSF组件。如form、outputText、inputText以及commandButton。这几个组件被放到form中从而开成了form中的一部分。在程序的最开始，必须使用import导入两个标签库。代码如下。

＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %＞ ＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %＞

　　上面2行代码声明了JSP中要使用哪一个JSF标签库。内核库使用前缀（prefix）f声明，而HTML库使用前缀(prefix)h声明。这两个前缀并不是必须要使用，而只是一个建议。在程序中，内核库必须要使用，因为view在所有的JSF页中必须使用。而HTML标签在运行时将JSF标签转化为HTML组件，这个h前缀并不是必须的，而是JSF规范推荐使用的，这样，我们使我们的JSF程序更易读。

　　在声明后是几行标准的HTML语句，本文不再详述。从＜f:view＞开始，是一段JSF语句。这段代码如下所示：

＜f:view＞ ＜h:form id="simpleForm"＞ ＜h:outputText id="favoriteLabel" value="请输入一个数字："/＞ ＜h:inputText id="favoriteValue" value="#{simple.longValue}"＞ ＜f:validateLongrange maximum="30" minimum="0"/＞ ＜/h:inputText＞ ＜p/＞ ＜h:commandButton id="submit" value="提交" action="#{simple.simpleActionMethod}"/＞ ＜/h:form＞ ＜/f:view＞

　　＜/f:view＞标签预示着JSF的开始，而它的下一个标签form将建立一个HTML Form。而outputText标签相当于HTML中的label组件。inputText标签相当于HTML中的textField组件。而commandButton标签相当于HTML中的submit按钮。

三、JSP如何响应JSF的请求
　　从上面的例子我们已经知道如何在JSP中使用JSF了，在这一部分让我们来看看在JSF是如何处理请求的。

　　首先让我们来看一个例子，这个例子是将华氏度转换为摄氏度。当用户点击提交按钮时程序将进行转换。

＜%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %＞ ＜%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %＞ ＜html＞ ＜head＞ 　＜meta HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=GB2312"＞ ＜title＞温度转换程序＜/title＞ ＜/head＞ ＜body＞ 　＜f:view＞ 　＜h:form＞ 　＜div＞ 　　＜h:outputText id="fahrenheitLabel" value="请输入华氏温度："/＞ 　　＜span＞ 　　　＜h:inputText id="temperature" value="#{tc.fahrenheitTemp}"＞ 　　　＜f:validateDoublerange minimum="-100.0" maximum="100.0"/＞ 　　　＜f:valuechangeListener type="tempconv.page.TCChangedListener"/＞ 　　＜/h:inputText＞ 　　＜/span＞ 　＜/div＞ 　＜div＞ 　　＜h:outputText id="celsiusLabel" value="摄氏温度："/＞ 　　＜span＞ 　　　＜h:outputText id="celsiusValue" value="#{tc.celsiusTemp}"＞ 　　　＜f:convertNumber maxFractionDigits="3" type="number"/＞ 　　＜/h:outputText＞ 　　＜/span＞ 　＜/div＞ 　＜div＞ 　　＜h:commandButton value="转换" action="#{tc.convert}"＞ 　　＜/h:commandButton＞ 　＜/div＞ 　＜/h:form＞ 　＜/f:view＞ ＜/body＞ ＜/html＞

　　在程序的前两行是导入JSF核心库和HTML库，这个在前面已经讨论过，在这里不再详述。

　　下面让我们来看看JSF标签是如何同后端进行交互的。由于我们是在JSP中使用JSF，因此，这个和正常的JSP没有什么区别；JSP实际上就是Servlet，在JSP第一次运行时由JSP编译器将.JSP文件编译成Servlet后再由Servlet调用，然后由Servlet来接收客户端传过来的数据流。但和一般的JSP程序不同的是，JSF标签是由JSF API负责调用的（这样可以做到逻辑层和表现层分离），除此之外，它们和一般的JSP标签没有任何区别。

　　当UIComponent标签收到doStartTag方法时，JSF将使用这些属性来设置标签的值。如本例中的inputText标签将按它的属性值来设置。下面是JSF的代码片段。

＜h:inputText id="temperature" value="#{tc.fahrenheitTemp}"＞ 　＜f:validateDoublerange minimum="-100.0" maximum="100.0"/＞ 　＜f:valuechangeListener type="tempconv.page.TCChangedListener"/＞ ＜/h:inputText＞

　　inputText标签根据相应的值设置了id和value的属性。在JSF中是通过setAttribute(String name, Object value)设置每一个属性值的。但我们需要注意的是JSF标签可以指定相应的默认值。这有些类似java中的系统属性，如果你给了一个属性名子，那系统将返回这个属性的值，如果指定它的默认值，并且这个属性不存在的话，将返回这个默认值。

　　接下来让我们来看看上面程序的最重要的部分，也就是UIInput组件的事件处理。

＜f:valuechangeListener type="tempconv.page.TCChangedListener"/＞

　　在JSF中事件处理是由valuechangeListener标签完成的。这个标签所表示的事件在文本框的值发生变化时引发事件。但有意思的是这个事件并不马上提交，而是要等到用户点击"提交"按钮后这个事件连同相应的数据才提交给后端。因此，这个事件请求也叫做预提交。最后，让我们看看UICommand的代码实现。

＜div＞ 　＜h:commandButton value="转换" action="#{tc.convert}"＞ 　＜/h:commandButton＞ ＜/div＞

　　上面的代码将convert()方法和UICommand连接了起来，也就是说，点击"提交"按钮后，将执行convert()方法。在遇到view标签后，JSF程序结果，JSFAPI最后调用doEnd方法来结束JSF程序。JSF引擎在解析这段程序后，将相应的JSF标签转换为HTML组件。

　　最后，让我们来看看JSP是如何响应JSF事件的。下面是一段响应JSF事件的Java代码。

public class TCChangedListener implements ValueChangeListener { 　public TCChangedListener() 　{ 　　super(); 　} 　// 事件处理 　public void processValueChange(ValueChangeEvent event) throws AbortProcessingException 　{ 　　UIComponent comp = event.getComponent(); 　　Object value = event.getNewValue(); 　　if (null != value) 　　{ 　　　float curVal = ((Number) value).floatValue(); 　　　Map values = comp.getAttributes(); 　　　if (curVal ＜ 0) 　　　{ 　　　　values.put("styleClass", "red"); 　　　} 　　　else 　　　{ 　　　　values.put("styleClass", "black"); 　　　} 　　} }

　　要想响应JSF事件，必须要实现JSF库中的ValueChangeListener接口。上面的程序要注意的是最后根据输入的值来设置相应的颜色。这些值并不依赖JSP。当然，你也可以将它们设置成null，而由JSP 标签来设置它们的颜色。

在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念.

时常看到一些人说掌握了Java，但是让他们用Java做一个实际的项目可能又困难重重，在这里，笔者根据自己的一点理解斗胆提出自己的一些对掌握Java这个说法的标准，当然对于新手，也可以提供一个需要学习哪些内容的参考。另外这个标准仅限于J2SE部分，J2EE部分的内容有时间再另说。
1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。
2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、HtmlConverter、jar、java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。
3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。
4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：
1）、java.lang包下的80％以上的类的功能的灵活运用。
2）、java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer。
3）、java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。
4）、java.math包下的100％的内容。
5）、java.net包下的60％以上的内容，对各个类的功能比较熟悉。
6）、java.text包下的60％以上的内容，特别是各种格式化类。
7）、熟练运用JDBC。
8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java。
9）、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。
10）、Swing的基本内容，和AWT的要求类似。
11）、XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。
5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。
6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。
7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。
8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。
9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。 查看全文

现在我们可以用JDK6 的Compiler API(JSR 199)去动态编译Java源文件，Compiler API结合反射功能就可以实现动态的产生Java代码并编译执行这些代码，有点动态语言的特征。这个特性对于某些需要用到动态编译的应用程序相当有用， 比如JSP Web Server，当我们手动修改JSP后，是不希望需要重启Web Server才可以看到效果的，这时候我们就可以用Compiler API来实现动态编译JSP文件，当然，现在的JSP Web Server也是支持JSP热部署的，现在的JSP Web Server通过在运行期间通过Runtime.exec或ProcessBuilder来调用javac来编译代码，这种方式需要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；Compiler API通过一套易用的标准的API提供了更加丰富的方式去做动态编译,而且是跨平台的。 下面代码演示了Compiler API的使用：

public class CompilerAPITester { 　private static String JAVA_SOURCE_FILE = "DynamicObject.java"; 　private static String JAVA_CLASS_FILE = "DynamicObject.class"; 　private static String JAVA_CLASS_NAME = "DynamicObject"; 　public static void main(String[] args) { 　　JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 　　StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 　　generateJavaClass(); 　　try { 　　　//将产生的类文件拷贝到程序的ClassPath下面,下面这一行代码是特定于Windows＋IntelliJ IDEA 6.0项目,不具有移植性 　　　Runtime.getRuntime().exec("cmd /c copy "+JAVA_CLASS_FILE+" classesproductionJDK6Features"); 　　　Iterable<? extends JavaFileObject> sourcefiles = fileManager.getJavaFileObjects(JAVA_SOURCE_FILE); 　　　compiler.getTask(null, fileManager, null, null, null, sourcefiles).call(); 　　　fileManager.close(); 　　　Class.forName(JAVA_CLASS_NAME).newInstance();//创建动态编译得到的DynamicObject类的实例 　　} catch (Exception ex) { 　　　ex.printStackTrace(); 　　} 　} 　public static void generateJavaClass(){ 　　try { 　　　FileWriter fw = new FileWriter(JAVA_SOURCE_FILE); 　　　BufferedWriter bw = new BufferedWriter(fw); 　　　bw.write("public class "+JAVA_CLASS_NAME+"{"); 　　　bw.newLine(); 　　　bw.write("public "+JAVA_CLASS_NAME+"(){System.out.println("In the constructor of DynamicObject");}}"); 　　　bw.flush(); 　　　bw.close(); 　　} catch (IOException ex) { 　　　ex.printStackTrace(); 　　} 　} }

　　程序运行后，会产生DynamicObject.java和DynamicObject.class两个文件，并在控制台输出：

　　In the constructor of DynamicObject

1.request对象
客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。

1 object getAttribute(String name) 返回指定属性的属性值
[/color]2 Enumeration getAttributeNames() 返回所有可用属性名的枚举
3 String getCharacterEncoding() 返回字符编码方式
4 int getContentLength() 返回请求体的长度（以字节数）
5 String getContentType() 得到请求体的MIME类型
6 ServletInputStream getInputStream() 得到请求体中一行的二进制流
7 String getParameter(String name) 返回name指定参数的参数值
8 Enumeration getParameterNames() 返回可用参数名的枚举
9 String[] getParameterValues(String name) 返回包含参数name的所有值的数组
10 String getProtocol() 返回请求用的协议类型及版本号
11 String getScheme() 返回请求用的计划名,如:http.https及ftp等
12 String getServerName() 返回接受请求的服务器主机名
13 int getServerPort() 返回服务器接受此请求所用的端口号
14 BufferedReader getReader() 返回解码过了的请求体
15 String getRemoteAddr() 返回发送此请求的客户端IP地址
16 String getRemoteHost() 返回发送此请求的客户端主机名
17 void setAttribute(String key,Object obj) 设置属性的属性值
18 String getRealPath(String path) 返回一虚拟路径的真实路径

[color=crimson]
2.response对象
response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。

1 String getCharacterEncoding() 返回响应用的是何种字符编码
2 ServletOutputStream getOutputStream() 返回响应的一个二进制输出流
3 PrintWriter getWriter() 返回可以向客户端输出字符的一个对象
4 void setContentLength(int len) 设置响应头长度
5 void setContentType(String type) 设置响应的MIME类型
6 sendRedirect(java.lang.String location) 重新定向客户端的请求


3.session对象
session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.

1 long getCreationTime() 返回SESSION创建时间
2 public String getId() 返回SESSION创建时JSP引擎为它设的惟一ID号
3 long getLastAccessedTime() 返回此SESSION里客户端最近一次请求时间
4 int getMaxInactiveInterval() 返回两次请求间隔多长时间此SESSION被取消(ms)
5 String[] getValueNames() 返回一个包含此SESSION中所有可用属性的数组
6 void invalidate() 取消SESSION，使SESSION不可用
7 boolean isNew() 返回服务器创建的一个SESSION,客户端是否已经加入
8 void removeValue(String name) 删除SESSION中指定的属性
9 void setMaxInactiveInterval() 设置两次请求间隔多长时间此SESSION被取消(ms)


4.out对象
out对象是JspWriter类的实例,是向客户端输出内容常用的对象

1 void clear() 清除缓冲区的内容
2 void clearBuffer() 清除缓冲区的当前内容
3 void flush() 清空流
4 int getBufferSize() 返回缓冲区以字节数的大小，如不设缓冲区则为0
5 int getRemaining() 返回缓冲区还剩余多少可用
6 boolean isAutoFlush() 返回缓冲区满时，是自动清空还是抛出异常
7 void close() 关闭输出流


5.page对象
page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例


1 class getClass 返回此Object的类
2 int hashCode() 返回此Object的hash码
3 boolean equals(Object obj) 判断此Object是否与指定的Object对象相等
4 void copy(Object obj) 把此Object拷贝到指定的Object对象中
5 Object clone() 克隆此Object对象
6 String toString() 把此Object对象转换成String类的对象
7 void notify() 唤醒一个等待的线程
8 void notifyAll() 唤醒所有等待的线程
9 void wait(int timeout) 使一个线程处于等待直到timeout结束或被唤醒
10 void wait() 使一个线程处于等待直到被唤醒
11 void enterMonitor() 对Object加锁
12 void exitMonitor() 对Object开锁


6.application对象
application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。


1 Object getAttribute(String name) 返回给定名的属性值
2 Enumeration getAttributeNames() 返回所有可用属性名的枚举
3 void setAttribute(String name,Object obj) 设定属性的属性值
4 void removeAttribute(String name) 删除一属性及其属性值
5 String getServerInfo() 返回JSP(SERVLET)引擎名及版本号
6 String getRealPath(String path) 返回一虚拟路径的真实路径
7 ServletContext getContext(String uripath) 返回指定WebApplication的application对象
8 int getMajorVersion() 返回服务器支持的Servlet API的最大版本号
9 int getMinorVersion() 返回服务器支持的Servlet API的最大版本号
10 String getMimeType(String file) 返回指定文件的MIME类型
11 URL getResource(String path) 返回指定资源(文件及目录)的URL路径
12 InputStream getResourceAsStream(String path) 返回指定资源的输入流
13 RequestDispatcher getRequestDispatcher(String uripath) 返回指定资源的RequestDispatcher对象
14 Servlet getServlet(String name) 返回指定名的Servlet
15 Enumeration getServlets() 返回所有Servlet的枚举
16 Enumeration getServletNames() 返回所有Servlet名的枚举
17 void log(String msg) 把指定消息写入Servlet的日志文件
18 void log(Exception exception,String msg) 把指定异常的栈轨迹及错误消息写入Servlet的日志文件
19 void log(String msg,Throwable throwable) 把栈轨迹及给出的Throwable异常的说明信息 写入Servlet的日志文件


7.exception对象
exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象


1 String getMessage() 返回描述异常的消息
2 String toString() 返回关于异常的简短描述消息
3 void printStackTrace() 显示异常及其栈轨迹
4 Throwable FillInStackTrace() 重写异常的执行栈轨迹
5

　
8.pageContext对象
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。


1 JspWriter getOut() 返回当前客户端响应被使用的JspWriter流(out)
2 HttpSession getSession() 返回当前页中的HttpSession对象(session)
3 Object getPage() 返回当前页的Object对象(page)
4 ServletRequest getRequest() 返回当前页的ServletRequest对象(request)
5 ServletResponse getResponse() 返回当前页的ServletResponse对象(response)
6 Exception getException() 返回当前页的Exception对象(exception)
7 ServletConfig getServletConfig() 返回当前页的ServletConfig对象(config)
8 ServletContext getServletContext() 返回当前页的ServletContext对象(application)
9 void setAttribute(String name,Object attribute) 设置属性及属性值
10 void setAttribute(String name,Object obj,int scope) 在指定范围内设置属性及属性值
11 public Object getAttribute(String name) 取属性的值
12 Object getAttribute(String name,int scope) 在指定范围内取属性的值
13 public Object findAttribute(String name) 寻找一属性,返回起属性值或NULL
14 void removeAttribute(String name) 删除某属性
15 void removeAttribute(String name,int scope) 在指定范围删除某属性
16 int getAttributeScope(String name) 返回某属性的作用范围
17 Enumeration getAttributeNamesInScope(int scope) 返回指定范围内可用的属性名枚举
18 void release() 释放pageContext所占用的资源
19 void forward(String relativeUrlPath) 使当前页面重导到另一页面
20 void include(String relativeUrlPath) 在当前位置包含另一文件
　
　
9.config对象
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）


1 ServletContext getServletContext() 返回含有服务器相关信息的ServletContext对象
2 String getInitParameter(String name) 返回初始化参数的值
3 Enumeration getInitParameterNames() 返回Servlet初始化所需所有参数的枚举

有关Java Servlets
JavaTM servlets是一个不受平台约束的Java小程序，它可以被用来通过多种方法扩充一个Web服务器的功能。你可以把Servlet理解成Server上的applets，它被编译成字节码，这样它就可以被动态地载入并用效地扩展主机的处理能力。
Servlet与applets不同的地方是，它不运行在Web浏览器或其他图形化的用户界面上。Servlet通过servlet引擎运行在Web服务器中，以执行请求和响应，请求、响应的典型范例是HTTP协议。
一个客户端程序，可以是一个Web浏览器，或者是非其他的可以连接上Internet的程序，它会访问Web服务器并发出请求。这个请求被运行在Web服务器上的Servlet引擎处理，并返回响应到Servlet。Servlet通过HTTP将这个响应转发到客户端。
在功能上，Servlet与CGI、NSAPI有点类似，但是，与他们不同的是：Servlet具有平台无关性。

Java Servlet概论
Servlet与其他普通的server扩展机制有以下进步：
因为它采用了不同的进程处理模式，所以它比CGI更快。
它使用了许多Web服务器都支持的标准的API。
它继承了Java的所有优势，包括易升级以及平台无关性。
它可以调用Java所提供的大量的API的功能模块。
这份文档说明了Java Servlet API的类和接口的方法。有关更多的信息，请参看下面的API说明。

Servlet的生命周期
一个Java servlet具有一个生命周期，这个生命周期定义了一个Servlet如何被载入并被初始化，如何接收请求并作出对请求的响应，如何被从服务中清除。Servlet的生命周期被javax.servlet.Servlet这个接口所定义。
所有的Java Servlet都会直接地或间接地执行javax.servlet.Servlet接口，这样它才能在一个Servlet引擎中运行。Servlet引擎是Web 服务器按照Java Servlet API定制的扩展。Servlet引擎提供网络服务，能够理解MIME请求，并提供一个运行Servlet的容器。
javax.servlet.Servlet接口定义了在Servlet的生命周期中特定时间以及特定顺序被调用的方法。

Servlet的解析和载入
Servlet引擎解析并载入一个Servlet，这个过程可以发生在引擎启动时，需要一个Servlet去响应请求时，以及在此之间的任何时候。
Servlet引擎利用Java类载入工具载入一个Servlet，Servlet引擎可以从一个本地的文件系统、一个远程的文件系统以及网络载入Servlet。

Servlet的初始化
Servlet引擎载入Servlet后，Servlet引擎必须对Servlet进行初始化，在这一过程中，你可以读取一些固定存储的数据、初始化JDBC的连接以及建立与其他资源的连接。
在初始化过程中，javax.servlet.Servlet接口的init()方法提供了Servlet的初始化信息。这样，Servlet可以对自己进行配置。
init()方法获得了一个Servlet配置对象（ServletConfig）。这个对象在Servlet引擎中执行，并允许Servlet通过它获处相关参数。这个对象使得Servlet能够访问ServletContext对象。

Servlet处理请求
Servlet被初始化之后，它已经可以处理来自客户端的请求，每一个来自客户端的请求都被描述成一个ServletRequest对象，Servlet的响应被描述成一个ServletResponse对象。
当客户端发出请求时，Servlet引擎传递给Servlet一个ServletRequest对象和一个ServletResponse对象，这两个对象作为参数传递到service()方法中。
Servlet也可以执行ServletRequest接口和ServletResponse接口。ServletRequest接口使得Servlet有权使用客户端发出的请求。Servlet可以通过ServletInputStream对象读取请求信息。
ServletResponse接口允许Servlet建立响应头和状态代码。通过执行这个接口，Servlet有权使用ServletOutputStream类来向客户端返回数据。

多线程和映射
在多线程的环境下，Servlet必须能处理许多同时发生的请求。例外的情况是这个Servlet执行了SingleThreadModel接口，如果是那样的话，Servlet只能同时处理一个请求。
Servlet依照Servlet引擎的映射来响应客户端的请求。一个映射对包括一个Servlet实例以及一个Servlet返回数据的URL，例如：HelloServlet with /hello/index.html。
然而，一个映射可能是由一个URL和许多Servlet实例组成，例如：一个分布式的Servlet引擎可能运行在不止一个的服务器中，这样的话，每一个服务器中都可能有一个Servlet实例，以平衡进程的载入。作为一个Servlet的开发者，你不能假定一个Servlet只有一个实例。

Servlet的卸载
Servlet引擎并不必需保证一个Servlet在任何时候或在服务开启的任何时候都被载入。Servlet引擎可以自由的在任何时候使用或清除一个Servlet。因此，我们不能依赖一个类或实例来存储重要的信息。
当Servlet引擎决定卸载一个Servlet时（例如，如果这个引擎被关闭或者需要让资源），这个引擎必须允许Servlet释放正在使用的资源并存储有关资料。为了完成以上工作，引擎会调用Servlet的destroy()方法。
在卸载一个Servlet之前，Servlet引擎必须等待所有的service()方法完成或超时结束（Servlet引擎会对超时作出定义）。当一个Servlet被卸载时，引擎将不能给Servlet发送任何请求。引擎必须释放Servlet并完成无用存储单元的收集

Servlet映射技术
作为一个Servlet引擎的开发者，你必须对于如何映射客户端的请求到Servlet有大量的适应性。这份说明文档不规定映射如何发生。但是，你必须能够自由地运用下面的所有技术：

映射一个Servlet到一个URL
例如，你可以指定一个特殊的Servlet它仅被来自/feedback/index.html的请求调用。

映射一个Servlet到以一个指定的目录名开始的所有URL
例如，你可以映射一个Servlet到/catalog，这样来自/catalog/、 /catalog/garden和/catalog/housewares/index.html的请求都会被映射到这个Servlet。但是来自/catalogtwo 或/catalog.html的请求没被映射。

映射一个Servlet到所有以一个特定的字段结尾的所有URL
例如，你可以映射一个来自于所有以in.thtml结尾的请求到一个特定的Servlet。

映射一个Servlet到一个特殊的URL /servlet/servlet_name。
例如，如果你建立了一个名叫listattributes的Servlet，你可以通过使用/servlet/listattributes来访问这个Servlet。

通过类名调用Servlet
例如，如果Servlet引擎接收了来自/servlet/com.foo.servlet.MailServlet的请求，Servlet引擎会载入这个com.foo.servlet.MailServlet类，建立实例，并通过这个Servlet来处理请求。

Servlet环境
ServletContext接口定义了一个Servlet环境对象，这个对象定义了一个在Servlet引擎上的Servlet的视图。通过使用这个对象，Servlet可以记录事件、得到资源并得到来自Servlet引擎的类（例如RequestDispatcher对象）。一个Servlet只能运行在一个Servlet环境中，但是不同的Servlet可以在Servlet引擎上有不同的视图。
如果Servlet引擎支持虚拟主机，每个虚拟主机有一个Servlet环境。一个Servlet环境不能在虚拟主机之间共享。
Servlet引擎能够允许一个Servlet环境有它自己的活动范围。
例如，一个Servlet环境是属于bank应用的，它将被映射到/bank目录下。在这种情况下，一个对getContext方法的调用会返回/bank的Servlet环境。

HTTP会话
HTTP是一个没有状态的协议。要建立一个有效的Web服务应用，你必须能够识别一个连续的来自远端的客户机的唯一的请求。随着时间的过去，发展了许多会话跟踪的技术，但是使用起来都比较麻烦。
Java Servlet API提供了一个简单的接口，通过这个接口，Servlet引擎可以有效地跟踪用户的会话。

建立Session
因为HTTP是一个请求-响应协议，一个会话在客户机加入之前会被认为是一个新的会话。加入的意思是返回会话跟踪信息到服务器中，指出会话已被建立。在客户端加入之前，我们不能判断下一个客户端请求是目前会话的一部分。
在下面的情况下，Session会被认为是新的Session。
客户端的Session在此之前还不知道
客户端选择不加入Session，例如，如果客户端拒绝接收来自服务器的cookie
作为一个Servlet的开发者，你必须决定你的Web应用是否处理客户机不加入或不能加入Session。服务器会在Web服务器或Servlet规定的时间内维持一个Session对象。当Session终止时，服务器会释放Session对象以及所有绑定在Session上的对象。
绑定对象到Session中
如果有助于你处理应用的数据需求，你也许需要绑定对象到Session中，你可以通过一个唯一的名字绑定任何的对象到Session中，这时，你需要使用HttpSession对象。任何绑定到Session上的对象都可以被处理同一会话的Servlet调用。
有些对