对服务器来说，我们有几点是要长期观察的，任何一点都可能是瓶颈：
1. CPU：动态文件的解析需要比较多的CPU，CPU出现瓶颈就要看是不是哪个功能过长时间占用线程，如果是就分出去。或者就是每一个请求处理时间不长，但是访问量很高，那么就加服务器。CPU是好东西，不能让他干等，不做事情。
2. 内存：缓存从IIS进程独立出去，一般对WEB服务器来说内存不够的情况不是很多。内存比磁盘快，要合理利用。
3. 磁盘IO：用性能监视器找到哪些文件IO特别大，找到了就分到独立的一组文件服务器上去，或者直接做CDN。磁盘慢，大规模读取数据的应用靠缓存，大规模写入数据的应用可以靠队列来降低突发的并发。
4. 网络：我们知道，网络的通讯是比较慢的，比磁盘还慢，如果是做分布式缓存，分布式计算的话，要考虑到物理服务器之间网络通讯的时间，当然，在流量大了以后，这可以提高系统的接纳能力一个等级。静态内容可以借助CSD分担一部分，在做服务器假设的时候还要考虑中国特色的电信网通情况以及防火墙。

对SQL SERVER数据库服务器来说[UPDATE]：
其实还是水平分割和纵向分割，一个二维表，水平分割就是横过来切一刀，纵向分割就是竖直切一刀：
1、纵向分割就是，我们不同的应用可以分到不同的DB中，不同的实例中，或者说把某个拥有很多字段的表拆分成小表。
2、横向分割就是，某些应用可能不负载，比如用户注册，但是用户表会非常大，可以把大表分开。可以采用表分区，数据存储在不同文件上，然后再部署到独立物理服务器增加IO吞吐以改善读写性能，土一点的做法就是自己定期把老的数据存档。表分区的另外一个优势可以增加数据查询速度，因为我们的页索引可以有多层了，就像一个文件夹中的文件不要太多，多分几层文件夹一样。
3、还可以通过数据库镜像、复制订阅、事物日志，把读写分开到不同的镜像物理数据库上，一般来说够用，如果还不行可以用硬件来实现数据库的负载均衡。当然，对于BI，我们可能还会有数据仓库。

架构上考虑到了这些之后，流量大了，就可以在这个的基础上再去调整或者做WEB服务器或者应用服务器的负载均衡。很多时候我们都是在重复发现问题-》找到瓶颈-》解决这个过程。

典型的架构如下：


动态WEB服务器配好点的CPU，静态WEB服务器和文件服务器磁盘好点
应用服务器内存大点，缓存服务器也是，数据库服务器当然内存和CPU都要好


请大家讨论。。。。

转自http://blog.csdn.net/LoveCherry/archive/2008/06/19/2564096.aspx

Email:ltdreamboy@yahoo.com.cn

前言

jar文件的用法.

具体的打包例子

加入第三方类库

其它信息

前言

jar文件的用法.

用法：jar {ctxu}[vfm0Mi] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...

选项：

• -c 创建新的存档
• -t 列出存档内容的列表
• -x 展开存档中的命名的（或所有的〕文件
• -u 更新已存在的存档
• -v 生成详细输出到标准输出上
• -f 指定存档文件名
• -m 包含来自标明文件的标明信息
• -0 只存储方式；未用ZIP压缩格式
• -M 不产生所有项的清单（manifest〕文件
• -i 为指定的jar文件产生索引信息
• -C 改变到指定的目录，并且包含下列文件：

如果一个文件名是一个目录，它将被递归处理。

清单（manifest〕文件名和存档文件名都需要被指定，按'm' 和 'f'标志指定的相同顺序。

示例1：将两个class文件存档到一个名为 'classes.jar' 的存档文件中：

       jar cvf classes.jar Foo.class Bar.class

       jar cvfm classes.jar mymanifest -C foo/ .

具体的打包例子

2004-11-21  20:34    <DIR>          images

2004-11-22  02:19             2,519 CellandMaskDialog.class

2004-11-22  02:19               449 CellEx$1.class

2004-11-22  02:19            13,523 CellEx.class

2004-11-22  02:19             4,636 CellExAction.class

2004-11-22  02:19             2,008 CellImagePanel.class

2004-11-22  02:19             1,919 CellMask.class

2004-11-22  02:19             2,009 CellMaskPanel.class

2004-11-22  02:19             2,139 OptionDialog.class

2004-11-22  02:19               592 PngFilter.class

9 File(s)         29,794 bytes

1 Dir(s)   1,102,630,912 bytes free

>jar -cvf output.jar *.class images

output.jar 为归档后新生成的 .jar 文件， *.class images 为放入归档中的文件。 即是说， 将*.class以及images目录放入一个名为output.jar的文件当中(即归档文件)。如果你有多个目录则:

>jar -cvf output.jar *.class images folder1 folder2 foldern

Manifest-Version: 1.0

Created-By: 1.4.2_05 (Sun Microsystems Inc.)

Main-Class: CellEx

好了,所有条件都具备了,现在我们来看看如何创建你的可执行jar文件,为了显得更加清晰,现在我们的目录结构如下:

2004-11-22  02:15                91 MANIFEST.MF

2004-11-21  20:34    <DIR>          images

2004-11-22  02:19             2,519 CellandMaskDialog.class

2004-11-22  02:19               449 CellEx$1.class

2004-11-22  02:19            13,523 CellEx.class

2004-11-22  02:19             4,636 CellExAction.class

2004-11-22  02:19             2,008 CellImagePanel.class

2004-11-22  02:19             1,919 CellMask.class

2004-11-22  02:19             2,009 CellMaskPanel.class

2004-11-22  02:19             2,139 OptionDialog.class

2004-11-22  02:19               592 PngFilter.class

10 File(s)         29,794 bytes

1 Dir(s)   1,102,630,912 bytes free

开始创建可执行jar文件(注意在此我们加了 m 参数,以及 MANIFEST.MF 文件,请注意 MANIFEST.MF 文件的位置,在 output.jar 文件后):

>jar -cvfm output.jar MANIFEST.MF *.class images

如果在linux等其它系统,你需要通过命令行: >java -jar output.jar 来执行.

加入第三方类库

下例中我们加入了一个第三方类库

Class-Path: lib/jfig2.jar

Main-Class: CellEx

其它信息

写完CORBA系列后，本想接着写写其它几种典型的远程通信协议：RMI、XML-RPC、SOAP，但由于工作的原因，加之房子装修等麻烦事，一直没有心情动笔。今天接到装修公司老板电话说开工证要晚几天办下来，要停工4-5天，狂怒后突然有了静下心来完成原本想写的东西的想法，既来之，则安之（i.e.郁闷啊，郁闷啊，就习惯了...）

大卫注2：

这个系列基本上是一份笔记，没有加入太多我自己的东西，仅仅记录了自己在使用过程中遇到的问题，及其解决办法。

2. 本文的适用对象

3.怎样阅读

4. 概述

4.1. 加密Java源码的原因

4.2. Java密码体系和Java密码扩展

4.3. 本文采用的方式

5. 基本设计思想

这个过程可以划分成5个部分:

6.那个文件应该被加密

7. 怎样加密自己的java文件

7.2.  文件的加密

c:> encryption –encrypto myClass.class

8. 从LicenceCenter获取的产品信息

LicenceFactory licenceFactory=new LicenceFactory();         licenceFactory.getLicence("urProductName");

9.程序需要增加什么配置

<env-entry>               <env-entry-name>licence_service_url</env-entry-name>                     <env-entry-value>http://192.168.2.212:8080/licenceCenter/LicenceService</env-entry-value>               <env-entry-type>java.lang.String</env-entry-type>        </env-entry>

10.关于验证中心的安装

<web-app id="demo" app-dir="E:/licencescenter/webapp">                             <servlet-mapping url-pattern='*.jsp'                                    servlet-name='com.caucho.jsp.JspServlet'/>          </web-app>

<servlet servlet-name="LicenceService"      servlet-class="com.caucho.hessian.server.HessianServlet">     <init-param service-class="com.collegesoft.licence.LicenceService"/>     <init-param api-class="com.collegesoft.licence.LicenceServiceStub"/>   </servlet>   <servlet-mapping url-pattern="/LicenceService" servlet-name="LicenceService"/>

11. 常见问题

13.关于作者

转赛迪技术

String s = "Hello world!";

　　许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

String string = s;

　　我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。

　　问题二："=="和equals方法究竟有什么区别？

　　==操作符专门用来比较变量的值是否相等。比较好理解的一点是：

int a=10;
int b=10;

　　则a==b将是true。
　　但不好理解的地方是：

String a=new String("foo");
String b=new String("foo");

　　则a==b将返回false。

　　根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。

　　对象内容的比较，正是equals方法做的事。

　　看一下Object对象的equals方法是如何实现的：

boolean equals(Object o){
return this==o;
}

　　Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出，Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。

　　看一下一个极端的类：

Class Monster{
private String content;
...
boolean equals(Object another){ return true;}
}

　　覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。

　　所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。

　　问题三：String到底变了没有？

　　没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码：

String s = "Hello";
s = s + " world!";

　　s所指向的对象是否改变了呢？从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中，s原先指向一个String对象，内容是"Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

　　通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。

　　同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：

public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}

　　而非

　　s = new String("Initial Value");

　　后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。

　　上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。

　　至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即StringBuffer。

　　问题四：final关键字到底修饰了什么？

　　final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。

　　引用本身的不变：

final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误

　　引用指向的对象不变：

final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过

　　可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。

　　理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。

　　问题五：到底要怎么样初始化！

　　本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。

1. 类的属性，或者叫值域
2. 方法里的局部变量
3. 方法的参数

　　对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。

int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0

　　所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。

　　对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。

　　对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！

　　其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。

　　问题六：instanceof是什么东东？

　　instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

String s = "I AM an Object!";
boolean isObject = s instanceof Object;

　　我们声明了一个String对象引用，指向一个String对象，然后用instancof来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。

　　instanceof有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}

　　在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}

　　这样就可以用一个方法处理两种子类。

　　然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

public double calculate(PhoneBill bill) {
//计算电话账单
}

public double calculate(GasBill bill) {
//计算燃气账单
}

　　所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1478143

    <!-- Test entry for demonstration purposes -->
    <Environment name="simpleValue" type="java.lang.Integer" value="30"/>

    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
       description="User database that can be updated and saved"
           factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
          pathname="conf/tomcat-users.xml" />

  </GlobalNamingResources>

注：maxActive ：指定数据库连接池中处于活动状态的数据库连接最大数目，0表示不受限制；maxIdle：指定数据库连接池中处于空闲状态的数据库连接的最大数目，0表示不受限制；maxWait ：指定数据库连接池中的数据库连接处于空闲状态的最长时间（单位为毫秒），超过这一事件，将会抛出异常。-1表示可以无限期等待；auth：指定管理Resource的Manager，由两个可选值：Container和Application。Container表示由容器来创建和管理Resource，Application表示由WEB应用来创建和管理Resource。如果在web application deployment descriptor中使用<resource-ref>，这个属性是必需的，如果使用<resource-env-ref>，这个属性是可选的。

3、在%TOMCAT_HOME%/conf/Catalina/localhost下新建一个与你web文件夹同名的xml文件（KuaiBaoWeb.war.xml）
这一步非常重要,如果没有这步就会出错,会出现错误：

Database init error:org.apache.tomcat.dbcp.dbcp.SQLNestedException: Cannot create JDBC driver of class '' for connect URL 'null'

在文件中内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<Context> 
  <Resource      name="jdbc/MSSQLDS"      type="javax.sql.DataSource"      password="sa"      driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"      maxIdle="30"      maxWait="5000"      username="sa"      url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=SuperDB"      maxActive="30"/>
</Context>

可以看出，就是在元素<Content>里加入第2步同样的内容，根据个人情况做相应修改。
4、修改%TOMCAT_HOME%/webapps/yourweb/WEB-INF下的web.xml文件,在<web-app></web-app>之间添加以下内容：
  <resource-ref>
    <res-ref-name>jdbc/MSSQLDS</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
  </resource-ref>
jdbc/MSSQLDS为前面定义的JNDI名字。

相应的获取JNDI的代码：
......
Context initCtx=new InitialContext();
                
DataSource ds=(DataSource)initCtx.lookup("java:comp/env/jdbc/MSSQLDS")
.......

到此为止，数据源配置完成。

二、Jboss3.2.8+SQL Server2000

1、把数据库JDBC驱动（msutil.jar、mssqlserver.jar、msbase.jar）拷贝到jboss-3.2.8.SP1\server ..\lib目录下。
2、修改mssql-ds.xml文件,如下:

<?xml version="1.0" encoding="UTF-8"?>
<datasources>
  <local-tx-datasource>
    <jndi-name>MSSQLDS</jndi-name>
    <connection-url>jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=SuperDB</connection-url>
    <driver-class>com.microsoft.jdbc.sqlserver.SQLServerDriver</driver-class>
    <user-name>sa</user-name>
    <password>sa</password>
    <connection-property name="char.encoding">UTF-8</connection-property>
    <min-pool-size>30</min-pool-size>
    <max-pool-size>100</max-pool-size>
    <blocking-timeout-millis>5000</blocking-timeout-millis>
    <idle-timeout-minutes>5</idle-timeout-minutes>
  </local-tx-datasource>
</datasources>
获取JNDI代码：

 ctx = new InitialContext();
    ds = (DataSource) ctx.lookup("java:/MSSQLDS");
      conn = ds.getConnection();

数据源配置完成。注：JBOSS4.0下，配置多数据源比JBOSS3要容易。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1444169

public Book(String name,String author,String price){
this.bookname=name;
this.author=author;
this.price=price;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public String getBookname() {
return bookname;
}

public void setBookname(String bookname) {
this.bookname = bookname;
}

public String getPrice(){
return this.price;
}

public void setPrice(String price){
this.price=price;
}

public static ArrayList getAllBook(Connection connection){
String sql="select * from book";
ArrayList arrayList = new ArrayList();
try{
Statement statement = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
ResultSet resultSet = statement.executeQuery(sql);
System.out.println("BookBean 数据查询已完成！");
while(resultSet.next())
{
String name = resultSet.getString("name");
String author = resultSet.getString("author");
String price = resultSet.getString("price");
System.out.println("开始数据封装：name="+name+"author="+author+"price="+price);
Book book = new Book(name,author,price);
arrayList.add(book);
}
connection.close();
resultSet.close();
}catch(SQLException e)
{
System.out.println("数据库异常"+e.toString());
}

return arrayList;
}
}

2 PageBean.java
package page;
import bean.Book;
import java.util.*;
/**
* Struts分页显示逻辑Bean
*/
public class PageBean {

int currentPage=1;　//当前页
public int totalPages=0;　//总页数
int pageRecorders=5;//每页5条数据
int totalRows=0;　//总数据数
int pageStartRow=0;//每页的起始数
int pageEndRow=0;　//每页显示数据的终止数
boolean hasNextPage=false; //是否有下一页
boolean hasPreviousPage=false; //是否有前一页
ArrayList arrayList;
Iterator it;
public PageBean(){}

public PageBean(ArrayList arrayList){
this.arrayList=arrayList;
totalRows=arrayList.size();
it=arrayList.iterator();
hasPreviousPage=false;
currentPage=1;
if((totalRows%pageRecorders)==0)
{
totalPages=totalRows/pageRecorders;
}
else
{
totalPages=totalRows/pageRecorders+1;
}

if(currentPage>=totalPages)
{
hasNextPage=false;
}
else
{
hasNextPage=true;
}

if(totalRows<pageRecorders)
{
this.pageStartRow=0;
this.pageEndRow=totalRows;
}
else
{
this.pageStartRow=0;
this.pageEndRow=pageRecorders;
}

}

/**
* @return Returns the currentPage.
*/
public String getCurrentPage() {
return this.toString(currentPage);
}
/**
* @param currentPage The currentPage to set.
*/
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
/**
* @return Returns the pageRecorders.
*/
public int getPageRecorders() {
return pageRecorders;
}
/**
* @param pageRecorders The pageRecorders to set.
*/
public void setPageRecorders(int pageRecorders) {
this.pageRecorders = pageRecorders;
}
/**
* @return Returns the pageEndRow.
*/
public int getPageEndRow() {
return pageEndRow;
}
/**
* @return Returns the pageStartRow.
*/
public int getPageStartRow() {
return pageStartRow;
}
/**
* @return Returns the totalPages.
*/
public String getTotalPages() {

return this.toString(totalPages);
}
/**
* @return Returns the totalRows.
*/
public String getTotalRows() {
return this.toString(totalRows);
}
/**
* @return Returns the hasNextPage.
*/
public boolean isHasNextPage() {
return hasNextPage;
}
/**
* @param hasNextPage The hasNextPage to set.
*/
public void setHasNextPage(boolean hasNextPage) {
this.hasNextPage = hasNextPage;
}
/**
* @return Returns the hasPreviousPage.
*/
public boolean isHasPreviousPage() {
return hasPreviousPage;
}
/**
* @param hasPreviousPage The hasPreviousPage to set.
*/
public void setHasPreviousPage(boolean hasPreviousPage) {
this.hasPreviousPage = hasPreviousPage;
}
public Book[] getNextPage(){

currentPage=currentPage+1;
System.out.println("PageBean.getNextPage()正在执行；");
System.out.println("参数currentPage="+currentPage);

if((currentPage-1)>0)
{
hasPreviousPage=true;
}
else
{
hasPreviousPage=false;
}
if(currentPage>=totalPages)
{
hasNextPage=false;
}
else
{
hasNextPage=true;
}
System.out.println("参数hasNextPage="+hasNextPage);
System.out.println("准备执行PageBean.getBooks()");
Book[] books=getBooks();
this.description();
return books;
}

public Book[] getPreviouspage(){
currentPage=currentPage-1;

if(currentPage==0){currentPage=1;}

if(currentPage>=totalPages)
{
hasNextPage=false;
}
else
{
hasNextPage=true;
}
if((currentPage-1)>0)
{
hasPreviousPage=true;
}
else
{
hasPreviousPage=false;
}
Book[] books=getBooks();
this.description();
return books;
}

public Book[] getBooks(){
System.out.println("pageBean.getBooks（）开始执行；");
if(currentPage*pageRecorders<totalRows){//判断是否为最后一页
pageEndRow=currentPage*pageRecorders;
pageStartRow=pageEndRow-pageRecorders;
}
else{
pageEndRow=totalRows;
pageStartRow=pageRecorders*(totalPages-1);
}
Book[] books=new Book[pageEndRow-pageStartRow+1];

System.out.println("pageStartRow="+pageStartRow);
System.out.println("pageEndRow="+pageEndRow);
int j=0;
for(int i=pageStartRow;i<pageEndRow;i++)
{
Book book=(Book)arrayList.get(i);
books[j++]=book;

}
System.out.println("要显示的页面数据已经封装,具体信息如下：");
this.description();
return books;
}

public String toString(int temp)
{
String str=Integer.toString(temp);
return str;
}

public void description()
{
String description="共有数据数:"+this.getTotalRows()+"共有页数: "+this.getTotalPages() +"当前页数为:"+this.getCurrentPage()+" 是否有前一页: "+this.isHasPreviousPage() +" 是否有下一页:"+this.isHasNextPage()+" 开始行数:"+this.getPageStartRow()+" 终止行数:"+this.getPageEndRow();
System.out.println(description);
}
}
3　PageListAction.java
package page;
import org.apache.struts.action.*;
import javax.servlet.http.*;
import comm.Constants;
import bean.Book;
import java.util.*;
import javax.sql.DataSource;
/**
* Struts分页显示Action
*/
public class PageListAction extends Action {

public PageListAction(){}
ArrayList arrayList=new ArrayList();
PageBean pb;

public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
String action;
action=request.getParameter("action");
if(action==null || action.equals("null")){ //第一次读取数据
try{
DataSource datasource=this.getDataSource(request,Constants.DATASOURCE_KEY);
arrayList=Book.getAllBook(datasource.getConnection());
System.out.println("第一步，数据已经成功传递到Action，action="+action);
}catch(Exception e){
e.printStackTrace();
System.out.println("数据库连接出现异常");
}
pb=new PageBean(arrayList);
Book[] books=pb.getBooks();
pb.description();
request.setAttribute("result",books);
request.setAttribute("page",pb);
}
else
{
if(action=="nextPage" || action.equals("nextPage"))
{
System.out.println("参数action="+action);
System.out.println("函数pb.getNextPage()准备执行");
Book[]books=pb.getNextPage();
request.setAttribute("page",pb);
request.setAttribute("result",books);
}
if(action=="previousPage" || action.equals("previousPage"))
{
System.out.println("参数action="+action);
System.out.println("函数pb.getPreviouspage()准备执行");
Book[] books=pb.getPreviouspage();
request.setAttribute("page",pb);
request.setAttribute("result",books);
}
}
return (mapping.findForward("success"));
}
}
4 pagetest.jsp
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ page contentType="text/html; charset=gb2312" language="java"%>
<html:html locale="true">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
</head>
<body>
<table border="1">
<tr><th>书名</th><th>作者</th><th>价格</th></tr>
<logic:present name="result">
<logic:iterate id="book" name="result"　type="bean.Book" >
<logic:present name="book">
<tr>
<td><bean:write name="book" property="bookname" /></td>
<td> <bean:write name="book" property="author" /></td>
<td><bean:write name="book" property="price" /></td>
</tr>
</logic:present>
</logic:iterate>
</logic:present>
</table>
<logic:equal name="page" property="hasNextPage" value="true">
<html:link page="/page.do?action=nextPage">nextPage</html:link>
</logic:equal>
<logic:equal name="page" property="hasPreviousPage" value="true">
<html:link page="/page.do?action=previousPage">PreviousPage</html:link>
</logic:equal>
共有数据总数<bean:write name="page" property="totalRows"/>;
共分<bean:write name="page" property="totalPages"/>页,当前是第
<bean:write name="page" property="currentPage"/>页
</body>
</html:html>
5 struts-config.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd";>

<struts-config>
<data-sources>
<data-source key="dataSource" type="org.apache.commons.dbcp.BasicDataSource">
<set-property property="driverClassName" value="com.microsoft.jdbc.sqlserver.SQLServerDriver"/>
<set-property property="url" value="jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=eBookStore;SelectMethod=cursor"/>
<set-property property="username" value="limq"/>
<set-property property="password" value="1"/>
<set-property property="maxActive" value="10"/>
<set-property property="maxWait" value="5000"/>
<set-property property="defaultAutoCommit" value="true"/>
<set-property property="defaultReadOnly" value="false"/>
</data-source>
</data-sources>
<form-beans>
</form-beans>
<global-forwards>
</global-forwards>
<action-mappings>
<action path="/page" type="page.PageListAction" scope="request">
<forward name="success" path="/pagetest.jsp"/>
</action>
</action-mappings>
<controller>
</controller>
</struts-config>
6 建立eBookStore数据库，以及表book（name,author,parce）;其中数据的配置可以根据你的不同情况在struts-config.xml中而定。
7 Constants.java
package comm;

/**
* this interface provides the constant string for applicator constant
*/
public class Constants {
/**
* name of the User Object in HttpSession
*/
public static String USER_KEY="user";
/**
* dataSource name
*/
public static String DATASOURCE_KEY="dataSource";
}

方案<二>

●struts中的分页实例- -

这仅是一个入门实例，简洁实用，从网上整理而来，供参考。这里仅列出部分文件，其它文件、数据库及目录结构请从本站下载。下载源文件

一、struts-config.xml配置，主要是配数据库,这里用access。
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd">


<struts-config>
<data-sources>
   <data-source key="dataSource" type="org.apache.commons.dbcp.BasicDataSource">
            <set-property property="driverClassName" value="sun.jdbc.odbc.JdbcOdbcDriver" />
            <set-property property="url" value="jdbc:odbc:page" />
            <set-property property="username" value="admin" />
            <set-property property="password" value="" />
            <set-property property="maxActive" value="20" />
            <set-property property="maxWait" value="5000" />
            <set-property property="defaultAutoCommit" value="true" />
            <set-property property="defaultReadOnly" value="false" />
            <set-property property="validationQuery" value="SELECT 1" />
            <set-property property="removeAbandoned" value="true" />
            <set-property property="removeAbandonedTimeout" value="120" />            
            <set-property property="encoding" value="false" />            
        </data-source>

 </data-sources>
  <form-beans>
  </form-beans>
  <global-forwards>
  </global-forwards>

  <action-mappings>
  <action path="/page" type="page.DataSourceAction" scope="request">
  <forward name="success" path="/pagetest.jsp"/>
  </action>
  </action-mappings>

  <controller>
  </controller>
</struts-config>

二、Action类
用 page.do?start=1 来显示第一个页面 
参数说明： 
  list：信息列表 
  start：开始位置 
  page：每页显示的信息数目 
  pages: 总页数
  previous：上页开始位置 
  next：下页开始位置 

package page;
import org.apache.struts.action.*;
import javax.servlet.http.*;

import java.util.*;
import javax.sql.*;
import java.sql.*;
import bean.*;

public class DataSourceAction extends Action {

 public DataSourceAction(){}
 
 public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {   
  try{
      DataSource ds=this.getDataSource(request,"dataSource");   
      Connection con = ds.getConnection();
      Statement stmt = con.createStatement();
      ResultSet resultSet = stmt.executeQuery("select count(*) from book" ); 
      resultSet.next(); 
      int data_num=resultSet.getInt(1); 
      int start=1;
      int page = 4; //每页的记录数。
      int pages=data_num/page;
      if(data_num%page!=0)
         pages++;
      if(request.getParameter("start")!=null)
          start = Integer.parseInt(request.getParameter("start")); 
      if(request.getParameter("go")!=null){
                int go = Integer.parseInt(request.getParameter("go")); 
                if(go<=1)
                  start=1;
                else if(go>pages)
                  start=(pages-1)*page+1;
                else 
                   start=(go-1)*page+1;
       } 
     
      String sql = "SELECT * FROM book where id>="+start+" and id<"+(start+page);
      resultSet = stmt.executeQuery(sql);  
      ArrayList list = new java.util.ArrayList(); 
      while(resultSet.next())
      {  
        int id=resultSet.getInt("id");
        String name = resultSet.getString("name");
        String author = resultSet.getString("author");
        String price = resultSet.getString("price");
        System.out.println("开始数据封装：name="+name+"author="+author+"price="+price);
        Book book= new Book(id,name,author,price);       
        list.add(book);
      }
    con.close();
    request.setAttribute("pages",new Integer(pages));
    request.setAttribute("list",list);
    //request.setAttribute("start", new Integer(start)); 
    request.setAttribute("page", new Integer(page)); 

        // if there is a previous page, set the previous variable 
        int previous = start-page; 
        if ( previous>=0 ){ 
            request.setAttribute("previous", new Integer(previous)); 
            System.out.println ("previous:" + previous); 
        } 

        // if there is a next page, set the next variable 
        int next = start+page; 
        if ( next<=data_num ){ 
            request.setAttribute("next", new Integer(next)); 
            System.out.println ("next:" + next); 
        } 

   }catch(SQLException e){
          e.printStackTrace();
          System.out.println("数据库连接出现异常");
      } 
   
             return (mapping.findForward("success"));
  } 
}


三、bean类Book.java
package bean;
import java.sql.*;
import java.util.ArrayList;
public class Book {
 int id;
 private String bookname; //书名
 private String author;   //作者
 private String price;    //价格
 
public Book(int id,String name,String author,String price){
 this.id=id;
 this.bookname=name;
 this.author=author;
 this.price=price;
}

public int getId(){ 
        return id; 
    } 

 public String getAuthor() {
  return author;
 }

 public void setAuthor(String author) {
  this.author = author;
 }

 public String getBookname() {
  return bookname;
 }

 public void setBookname(String bookname) {
  this.bookname = bookname;
 }
 
 public String getPrice(){
     return this.price; 
 }
 
 public void setPrice(String price){
     this.price=price; 
 }
 
}
四、分页的jsp页面pagetest.jsp,用了jstl中的c标记。
<%@ page contentType="text/html; charset=gb2312" language="java"%>
<%@ page import="java.util.*" %>
<%@ page import="bean.*" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<%@ taglib uri="/tags/struts-html" prefix="html" %>
<%@ taglib uri="/tags/struts-logic" prefix="logic" %>

<logic:iterate id="book" name="list" type="bean.Book"> 
            <br><html:link  
                    paramId="id" paramName="book" paramProperty="id" 
                    page="/messagedetail.do"> 
                    <bean:write name="book" property="bookname" /> 
                </html:link> 
</logic:iterate> 

<form action="/TestPage/page.do">
   <logic:present name="previous"> 
            <html:link  
                    paramId="start" paramName="previous" 
                    page="/page.do"> 
                    上一页 
                </html:link> 
   </logic:present> 

   <logic:present name="next"> 
              <html:link  
                    paramId="start" paramName="next" 
                    page="/page.do"> 
                    下一页 
                </html:link> 
   </logic:present> 

每页<c:out value="${page}"/>条记录,共<c:out value="${pages}"/>页  跳到<input type="text"  name="go" size="3" maxlength="30" >
<input type="submit" value="go" >
</form>
         



OK!!!!
五、测试，请下载本实例的目录结构TestPage,放入tomcat的webapps下，在浏览器中输入：
    http://127.0.0.1:8080/TestPage/page.do

这里讨论下 新手学习，高手指教 一起研究下
(以 tomcat mysql 做例子 我推荐所有的编码采用utf-8)

1 工程
工程内所有的 .java .jsp .xml .txt 都有默认的编码 默认的是系统环境的编码
我们中文系统通常是GBK 推荐都采用utf-8
utf-8 的时候 你编译 生成doc 可能会遇到乱码（特别是采用ant 的时候,生成doc你几乎100%会遇到）

解决方法 以ant 为例子
编译 注意 encoding 参数
<target name="build" >
       <mkdir dir="${build.dir}" />
       <javac encoding="utf-8" destdir="${build.dir}" target="1.3" debug="true" deprecation="false" optimize="false" failonerror="true">
           <src path="${src.dir}" />
           <classpath refid="master-classpath" />
       </javac>
   </target>

生成doc 注意 encoding 和 charset
<target name="doc">
<mkdir dir="doc" />
<javadoc charset="utf-8" encoding="utf-8" packagenames="${packages}" sourcepath="src" destdir="doc" author="true" version="true" use="true" splitindex="true" >
<classpath refid="master-classpath" />
</javadoc>
</target>

这里 的encoding 就是指的你 java 文件的编码格式 javac 和javadoc 都有这个参数
charset 指的是 生成 doc 后的编码方式 javadoc 的参数

2 数据库
mysql 的编码最复杂 从4以后 mysql 号称支持多编码 它更灵活了 我们也更麻烦了
mysql 有4个级别的编码
系统级
库级
表级
sql语句级
请保持采用统一的编码 推荐utf-8
其它数据库要简单的多 一般都是一种编码

3 web server
tomcat 为例
tomcat server.xml 中一个参数
<Connectorport="8080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" URIncoding="utf-8"/>
经测试 这个URIncoding 参数主要是 get 方法中采用编码

4 jsp 显示层
第1条中说明了 jsp 文件本身的格式
很多朋友采用eclipse +myeclipse 生成jsp
它自动生成一个头<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
不要误解 这句话不能保证你在ie里看到的不是乱码
pageEncoding它的意思是 这个页面本身采用的是 utf-8 (似乎只在eclipse 里有效果 ，我不确定)
为了在ie 里不乱码  你还得加一句 <%@ page contentType="text/html; charset=UTF-8"%>
它不能在(myeclispe)自动生成  推荐修改 myeclipse的模板 在下边的目录里
MyEclipse\eclipse\plugins\com.genuitec.eclipse.wizards_4.0.1\Templates
里边的jsp模版 你加上<%@ page contentType="text/html; charset=${encoding}"%>

5 filter
自从tomcat 4 以后 网上就流传了一个SetCharacterEncodingFilter 过滤器 搜一下有很多
很好用 web.xml 中加入
<filter>
?? <filter-name>Set Character Encoding</filter-name>
?? <filter-class>filters.SetCharacterEncodingFilter</filter-class>
?? <init-param>
?? <param-name>encoding</param-name>
?? <param-value>utf-8</param-value>
?? </init-param>
</filter>
?? <filter-mapping>
?? <filter-name>Set Character Encoding</filter-name>
?? <url-pattern>/*</url-pattern>
?? </filter-mapping>

6 资源文件
首先保证 文件本身是utf-8
然后部署的时候用 native2ascii 转换
这里给出 ant 里的例子
<native2ascii encoding="utf-8" dest="${web.dir}/WEB-INF/classes" src="${src.dir}" includes="**/*.properties" />

　　我们先来看一个简单的例子，它是一个用Java实现的客户/服务器网络程序。刚开始我们不使用Log4j，而是使用了一系列的打印语句，然后我们将使用Log4j来实现它的日志功能。这样，大家就可以清楚地比较出前后两个代码的差别。
　　
　　2.1. 不使用Log4j
　　
　　2.1.1. 客户程序
　　package log4j ;
　　
　　import java.io.* ;
　　import java.net.* ;
　　
　　/**
　　 *
　　 * <p> Client Without Log4j </p>
　　 * <p> Description: a sample with log4j</p>
　　 * @version 1.0
　　 */
　　public class ClientWithoutLog4j {
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args [] ) {
　　
　　　　　　String welcome = null;
　　　　　　String response = null;
　　　　　　BufferedReader reader = null;
　　　　　　PrintWriter writer = null;
　　　　　　InputStream in = null;
　　　　　　OutputStream out = null;
　　　　　　Socket client = null;
　　
　　　　　　try {
　　　　　　　　client = new Socket ( "localhost", 8001 ) ;
　　　　　　　　System.out.println ( "info: Client socket: " + client ) ;
　　　　　　　　in = client.getInputStream () ;
　　　　　　　　out = client.getOutputStream () ;
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println ( "error: IOException : " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　
　　　　　　try{
　　　　　　　　reader = new BufferedReader( new InputStreamReader ( in ) ) ;
　　　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　　　welcome = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server says: '" + welcome + "'" ) ;
　　
　　　　　　　　System.out.println ( "debug: HELLO" ) ;
　　　　　　　　writer.println ( "HELLO" ) ;
　　　　　　　　response = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server responds: '" + response + "'") ;
　　
　　　　　　　　System.out.println ( "debug: HELP" ) ;
　　　　　　　　writer.println ( "HELP" ) ;
　　　　　　　　response = reader.readLine () ;
　　　　　　　　System.out.println ( "debug: Server responds: '" + response + "'" ) ;
　　
　　　　　　　　System.out.println ( "debug: QUIT" ) ;
　　　　　　　　writer.println ( "QUIT" ) ;
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println ( "warn: IOException in client.in.readln()" ) ;
　　　　　　　　System.out.println ( e ) ;
　　　　　　}
　　　　　　try{
　　　　　　　　Thread.sleep ( 2000 ) ;
　　　　　　} catch ( Exception ignored ) {}
　　　　}
　　}
　　
　　2.1.2. 服务器程序
　　package log4j ;
　　
　　import java.util.* ;
　　import java.io.* ;
　　import java.net.* ;
　　
　　/**
　　 *
　　 * <p> Server Without Log4j </p>
　　 * <p> Description: a sample with log4j</p>
　　 * @version 1.0
　　 */
　　public class ServerWithoutLog4j {
　　
　　　　final static int SERVER_PORT = 8001 ; // this server's port
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args [] ) {
　　　　　　String clientRequest = null;
　　　　　　BufferedReader reader = null;
　　　　　　PrintWriter writer = null;
　　　　　　ServerSocket server = null;
　　　　　　Socket socket = null;
　　　　　　InputStream in = null;
　　　　　　OutputStream out = null;
　　
　　　　　　try {
　　　　　　　　server = new ServerSocket ( SERVER_PORT ) ;
　　　　　　　　System.out.println ( "info: ServerSocket before accept: " + server ) ;
　　　　　　　　System.out.println ( "info: Java server without log4j, on-line!" ) ;
　　
　　　　　　　　// wait for client's connection
　　　　　　　　socket = server.accept () ;
　　　　　　　　System.out.println ( "info: ServerSocket after accept: " + server )　;
　　
　　　　　　　　in = socket.getInputStream () ;
　　　　　　　　out = socket.getOutputStream () ;
　　
　　　　　　} catch ( IOException e ) {
　　　　　　　　System.out.println( "error: Server constructor IOException: " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ) , true ) ;
　　
　　　　　　// send welcome string to client
　　　　　　writer.println ( "Java server without log4j, " + new Date () ) ;
　　
　　　　　　while ( true ) {
　　　　　　　　try {
　　　　　　　　　　// read from client
　　　　　　　　　　clientRequest = reader.readLine () ;
　　　　　　　　　　System.out.println ( "debug: Client says: " + clientRequest ) ;
　　　　　　　　　　if ( clientRequest.startsWith ( "HELP" ) ) {
　　　　　　　　　　　　System.out.println ( "debug: OK!" ) ;
　　　　　　　　　　　　writer.println ( "Vocabulary: HELP QUIT" ) ;
　　　　　　　　　　}
　　　　　　　　　　else {
　　　　　　　　　　　　if ( clientRequest.startsWith ( "QUIT" ) ) {
　　　　　　　　　　　　　　System.out.println ( "debug: OK!" ) ;
　　　　　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　　　　　}
　　　　　　　　　　　　else{
　　　　　　　　　　　　　　System.out.println ( "warn: Command '" +
　　 clientRequest + "' not understood." ) ;
　　　　　　　　　　　　　　writer.println ( "Command '" + clientRequest
　　 + "' not understood." ) ;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　} catch ( IOException e ) {
　　　　　　　　　　System.out.println ( "error: IOException in Server " + e ) ;
　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
　　
　　2.2. 迁移到Log4j
　　
　　2.2.1. 客户程序
　　
　　package log4j ;
　　
　　import java.io.* ;
　　import java.net.* ;
　　
　　// add for log4j: import some package
　　import org.apache.log4j.PropertyConfigurator ;
　　import org.apache.log4j.Logger ;
　　import org.apache.log4j.Level ;
　　
　　/**
　　 *
　　 * <p> Client With Log4j </p>
　　 * <p> Description: a sample with log4j</p>
　　 * @version 1.0
　　 */
　　public class ClientWithLog4j {
　　
　　　　/*
　　　　add for log4j: class Logger is the central class in the log4j package.
　　　　we can do most logging operations by Logger except configuration.
　　　　getLogger(...): retrieve a logger by name, if not then create for it.
　　　　*/
　　　　static Logger logger = Logger.getLogger
　　 ( ClientWithLog4j.class.getName () ) ;
　　
　　　　/**
　　　　 *
　　　　 * @param args : configuration file name
　　　　 */
　　　　public static void main ( String args [] ) {
　　
　　　　　　String welcome = null ;
　　　　　　String response = null ;
　　　　　　BufferedReader reader = null ;
　　　　　　PrintWriter writer = null ;
　　　　　　InputStream in = null ;
　　　　　　OutputStream out = null ;
　　　　　　Socket client = null ;
　　
　　　　　　/*
　　　　　　add for log4j: class BasicConfigurator can quickly configure the package.
　　　　　　print the information to console.
　　　　　　*/
　　　　　　PropertyConfigurator.configure ( "ClientWithLog4j.properties" ) ;
　　
　　　　　　// add for log4j: set the level
　　//　　　　logger.setLevel ( ( Level ) Level.DEBUG ) ;
　　
　　　　　　try{
　　　　　　　　client = new Socket( "localhost" , 8001 ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "Client socket: " + client ) ;
　　
　　　　　　　　in = client.getInputStream () ;
　　　　　　　　out = client.getOutputStream () ;
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　logger.error ( "IOException : " + e ) ;
　　
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　
　　　　　　try{
　　　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　　　welcome = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server says: '" + welcome + "'" ) ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "HELLO" ) ;
　　
　　　　　　　　writer.println ( "HELLO" ) ;
　　　　　　　　response = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server responds: '" + response + "'" ) ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "HELP" ) ;
　　
　　　　　　　　writer.println ( "HELP" ) ;
　　　　　　　　response = reader.readLine () ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "Server responds: '" + response + "'") ;
　　
　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　logger.debug ( "QUIT" ) ;
　　
　　　　　　　　writer.println ( "QUIT" ) ;
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the warn level
　　　　　　　　logger.warn ( "IOException in client.in.readln()" ) ;
　　
　　　　　　　　System.out.println ( e ) ;
　　　　　　}
　　　　　　try {
　　　　　　　　Thread.sleep ( 2000 ) ;
　　　　　　} catch ( Exception ignored ) {}
　　　　}
　　}
　　
　　2.2.2. 服务器程序
　　
　　package log4j;
　　
　　import java.util.* ;
　　import java.io.* ;
　　import java.net.* ;
　　
　　// add for log4j: import some package
　　import org.apache.log4j.PropertyConfigurator ;
　　import org.apache.log4j.Logger ;
　　import org.apache.log4j.Level ;
　　
　　/**
　　 *
　　 * <p> Server With Log4j </p>
　　 * <p> Description: a sample with log4j</p>
　　 * @version 1.0
　　 */
　　public class ServerWithLog4j {
　　
　　　　final static int SERVER_PORT = 8001 ; // this server's port
　　
　　　　/*
　　　　add for log4j: class Logger is the central class in the log4j package.
　　　　we can do most logging operations by Logger except configuration.
　　　　getLogger(...): retrieve a logger by name, if not then create for it.
　　　　*/
　　　　static Logger logger = Logger.getLogger
　　 ( ServerWithLog4j.class.getName () ) ;
　　
　　　　/**
　　　　 *
　　　　 * @param args
　　　　 */
　　　　public static void main ( String args[]) {
　　　　　　String clientRequest = null ;
　　　　　　BufferedReader reader = null ;
　　　　　　PrintWriter writer = null ;
　　　　　　ServerSocket server = null ;
　　　　　　Socket socket = null ;
　　
　　　　　　InputStream in = null ;
　　　　　　OutputStream out = null ;
　　
　　　　　　/*
　　　　　　add for log4j: class BasicConfigurator can quickly configure the package.
　　　　　　print the information to console.
　　　　　　*/
　　　　　　PropertyConfigurator.configure ( "ServerWithLog4j.properties" ) ;
　　
　　　　　　// add for log4j: set the level
　　//　　　　logger.setLevel ( ( Level ) Level.DEBUG ) ;
　　
　　　　　　try{
　　　　　　　　server = new ServerSocket ( SERVER_PORT ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "ServerSocket before accept: " + server ) ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "Java server with log4j, on-line!" ) ;
　　
　　　　　　　　// wait for client's connection
　　　　　　　　socket = server.accept() ;
　　
　　　　　　　　// add for log4j: log a message with the info level
　　　　　　　　logger.info ( "ServerSocket after accept: " + server ) ;
　　
　　　　　　　　in = socket.getInputStream() ;
　　　　　　　　out = socket.getOutputStream() ;
　　
　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　logger.error ( "Server constructor IOException: " + e ) ;
　　　　　　　　System.exit ( 0 ) ;
　　　　　　}
　　　　　　reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
　　　　　　writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;
　　
　　　　　　// send welcome string to client
　　　　　　writer.println ( "Java server with log4j, " + new Date () ) ;
　　
　　　　　　while ( true ) {
　　　　　　　　try {
　　　　　　　　　　// read from client
　　　　　　　　　　clientRequest = reader.readLine () ;
　　
　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　logger.debug ( "Client says: " + clientRequest ) ;
　　
　　　　　　　　　　if ( clientRequest.startsWith ( "HELP" ) ) {
　　
　　　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　　　logger.debug ( "OK!" ) ;
　　
　　　　　　　　　　　　writer.println ( "Vocabulary: HELP QUIT" ) ;
　　　　　　　　　　}
　　　　　　　　　　else {
　　　　　　　　　　　　if ( clientRequest.startsWith ( "QUIT" ) ) {
　　
　　　　　　　　　　　　　　// add for log4j: log a message with the debug level
　　　　　　　　　　　　　　logger.debug ( "OK!" ) ;
　　
　　　　　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　　　　　}
　　　　　　　　　　　　else {
　　
　　　　　　　　　　　　　　// add for log4j: log a message with the warn level
　　　　　　　　　　　　　　logger.warn ( "Command '"
　　 + clientRequest + "' not understood." ) ;
　　
　　　　　　　　　　　　　　writer.println ( "Command '"
　　 + clientRequest + "' not understood." ) ;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　} catch ( IOException e ) {
　　
　　　　　　　　　　// add for log4j: log a message with the error level
　　　　　　　　　　logger.error( "IOException in Server " + e ) ;
　　
　　　　　　　　　　System.exit ( 0 ) ;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
　　
　　2.2.3. 配置文件
　　
　　2.2.3.1. 客户程序配置文件
　　
　　log4j.rootLogger=INFO, A1
　　
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
　　
　　2.2.3.2. 服务器程序配置文件
　　
　　log4j.rootLogger=INFO, A1
　　
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n
　　
　　2.3. 比较
　　
　 　比较这两个应用可以看出，采用Log4j进行日志操作的整个过程相当简单明了，与直接使用System.out.println语句进行日志信息输出的 方式相比，基本上没有增加代码量，同时能够清楚地理解每一条日志信息的重要程度。通过控制配置文件，我们还可以灵活地修改日志信息的格式，输出目的地等等 方面，而单纯依靠System.out.println语句，显然需要做更多的工作。

>>>> 3 . Log4j日志管理系统简单使用说明 <<<<

    通常，我们都提供一个名为 log4j.properties的文件，在第一次调用到Log4J时，Log4J会在类路径（../web-inf/class/当然也可以放到其它任何目录，只要该目录被包含到类路径中即可）中定位这个文件，并读入这个文件完成的配置。这个配置文件告 诉Log4J以什么样的格式、把什么样的信息、输出到什么地方。
　　Log4j有三个主要的组件：Loggers(记录器)，Appenders(输出源)和Layouts(布局)，这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松的记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。下面对三个组件分别进行说明：
　　
　　1、 Loggers
　 　Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < WARN < ERROR < FATAL，分别用来指定这条日志信息的重要程度,明白这一点很重要，这里Log4j有一个规则：假设Loggers级别为P，如果在Loggers中发生了一个级别Q比P高，则可以启动，否则屏蔽掉。
假设你定义的级别是info，那么error和warn的日志可以显示而比他低的debug信息就不显示了。
 　
　　Java程序举例来说：
　　
　　//建立Logger的一个实例，命名为“com.foo”
　　　Logger　logger = Logger.getLogger("com.foo"); //"com.foo"是实例进行命名，也可以任意
　　//设置logger的级别。通常不在程序中设置logger的级别。一般在配置文件中设置。
　　logger.setLevel(Level.INFO);
　　Logger barlogger = Logger.getLogger("com.foo.Bar");
　　//下面这个请求可用，因为WARN >= INFO
　　logger.warn("Low fuel level.");
　　//下面这个请求不可用，因为DEBUG < INFO
　　logger.debug("Starting search for nearest gas station.");
　　//命名为“com.foo.bar”的实例barlogger会继承实例“com.foo”的级别。因此，下面这个请求可用，因为INFO >= INFO
　　barlogger.info("Located nearest gas station.");
　　//下面这个请求不可用，因为DEBUG < INFO
　　barlogger.debug("Exiting gas station search");
　　这里“是否可用”的意思是能否输出Logger信息。
　　　　在对Logger实例进行命名时，没有限制，可以取任意自己感兴趣的名字。一般情况下建议以类的所在位置来命名Logger实例，这是目前来讲比较有效的Logger命名方式。这样可以使得每个类建立自己的日志信息，便于管理。比如：
　　
　　static Logger logger = Logger.getLogger(ClientWithLog4j.class.getName());
　　
　　2、Appenders
　　禁用与使用日志请求只是Log4j其中的一个小小的地方，Log4j日志系统允许把日志输出到不同的地方，如控制台（Console）、文件（Files）、根据天数或者文件大小产生新的文件、以流的形式发送到其它地方等等。
　　
　　其语法表示为：
　　
　　org.apache.log4j.ConsoleAppender（控制台）
　　org.apache.log4j.FileAppender（文件）
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
    org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
　　
　　配置时使用方式为：
　　log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
    log4j.appender.appenderName.option = valueN
　　这样就为日志的输出提供了相当大的便利。
　　
　　3、Layouts
　 　有时用户希望根据自己的喜好格式化自己的日志输出。Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供了 四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式等等。
　　
　　其语法表示为：
　　
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
　　
　　配置时使用方式为：
　　
　　log4j.appender.appenderName.layout =fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

>>>>  4 . Log4j的配置 <<<<　 　
　　
　　以上是从原理方面说明Log4j的使用方法，在具体Java编程使用Log4j可以参照以下示例：
　　
　　1、 建立Logger实例：
　　语法表示：public static Logger getLogger( String name)
　　实际使用：static Logger logger = Logger.getLogger(ServerWithLog4j.class.getName ()) ;
　　
　　2、 读取配置文件：
　　获得了Logger的实例之后，接下来将配置Log4j使用环境：
　　语法表示：
　　BasicConfigurator.configure()：自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure(String configFilename)：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure(String filename)：读取XML形式的配置文件。
　　实际使用：
    PropertyConfigurator.configure("ServerWithLog4j.properties");
　　
　　3、 插入日志信息
　　完成了以上连个步骤以后，下面就可以按日志的不同级别插入到你要记录日志的任何地方了。
　　语法表示：
　　Logger.debug(Object message);//调试信息
　　Logger.info(Object message);//一般信息
　　Logger.warn(Object message);//警告信息
　　Logger.error(Object message);//错误信息
　　Logger.fatal(Object message);//致命错误信息

　　实际使用：logger.info("ServerSocket before accept: " + server);
　　
　>>>> 5. 配置过程 <<<<

　在实际编程时，要使Log4j真正在系统中运行事先还要对配置文件进行定义。定义步骤就是对Logger、Appender及Layout的分别使用。
    Log4j支持两种配置文件格式，一种是XML格式的文件，一种是java properties（key=value）【Java特性文件（键=值）】。下面我们介绍使用Java特性文件做为配置文件的方法
   具体如下：
　　
　　1、配置根Logger，其语法为：
　　log4j.rootLogger = [ level ] , appenderName1, appenderName2, …
         level : 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定 义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。
　　     appenderName:就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。
   例如：log4j.rootLogger＝info,A1,B2,C3
　　
　　2、配置日志信息输出目的地，其语法为：
　　log4j.appender.appenderName = fully.qualified.name.of.appender.class  //
　　  "fully.qualified.name.of.appender.class" 可以指定下面五个目的地中的一个：
          1.org.apache.log4j.ConsoleAppender（控制台）
          2.org.apache.log4j.FileAppender（文件）
          3.org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
          4.org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
          5.org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
             1.ConsoleAppender选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    Target=System.err：默认情况下是：System.out,指定输出控制台
              2.FileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
            3.DailyRollingFileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
                    DatePattern='.'yyyy-ww:每周滚动一次文件，即每周产生一个新的文件。当然也可以指定按月、周、天、时和分。即对应的格式如下：
                    1)'.'yyyy-MM: 每月
                    2)'.'yyyy-ww: 每周 
                    3)'.'yyyy-MM-dd: 每天
                    4)'.'yyyy-MM-dd-a: 每天两次
                    5)'.'yyyy-MM-dd-HH: 每小时
                    6)'.'yyyy-MM-dd-HH-mm: 每分钟
            4.RollingFileAppender 选项
                    Threshold=WARN:指定日志消息的输出最低层次。
                    ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。
                    File=mylog.txt:指定消息输出到mylog.txt文件。
                    Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
                    MaxFileSize=100KB: 后缀可以是KB, MB 或者是 GB. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。
                    MaxBackupIndex=2:指定可以产生的滚动文件的最大数。

实际应用：
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender //这里指定了日志输出的第一个位置A1是控制台ConsoleAppender
　　
　　3、配置日志信息的格式，其语法为：
　　A.log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
              "fully.qualified.name.of.layout.class" 可以指定下面4个格式中的一个：
               1.org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　       2.org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　       3.org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　       4.org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
                   1.HTMLLayout 选项
                      LocationInfo=true:默认值是false,输出java文件名称和行号
                      Title=my app file: 默认值是 Log4J Log Messages.
                   2.PatternLayout 选项
                      ConversionPattern=%m%n :指定怎样格式化指定的消息。
                   3.XMLLayout  选项
                      LocationInfo=true:默认值是false,输出java文件和行号
   实际应用：
   　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout

       B. log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
           这里需要说明的就是日志信息格式中几个符号所代表的含义：
　　         －X号: X信息输出时左对齐；
                   %p: 输出日志信息优先级，即DEBUG，INFO，WARN，ERROR，FATAL,
                   %d: 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
                   %r: 输出自应用启动到输出该log信息耗费的毫秒数
                   %c: 输出日志信息所属的类目，通常就是所在类的全名
                   %t: 输出产生该日志事件的线程名
                   %l: 输出日志事件的发生位置，相当于%C.%M(%F:%L)的组合,包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)
                   %x: 输出和当前线程相关联的NDC(嵌套诊断环境),尤其用到像java servlets这样的多客户多线程的应用中。
                   %%: 输出一个"%"字符
                   %F: 输出日志消息产生时所在的文件名称
                   %L: 输出代码中的行号
                   %m: 输出代码中指定的消息,产生的日志具体信息
                   %n: 输出一个回车换行符，Windows平台为"\r\n"，Unix平台为"\n"输出日志信息换行
            可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
                     1)%20c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
                     2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
                     3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
                     4)%20.30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边交远销出的字符截掉。

　　这里上面三个步骤是对前面Log4j组件说明的一个简化；下面给出一个具体配置例子，在程序中可以参照执行：
　　log4j.rootLogger=INFO,A1，B2
　　log4j.appender.A1=org.apache.log4j.ConsoleAppender
　　log4j.appender.A1.layout=org.apache.log4j.PatternLayout
　　log4j.appender.A1.layout.ConversionPattern=%-4r %-5p %d{yyyy-MM-dd HH:mm:ssS} %c %m%n
 　　根据上面的日志格式，某一个程序的输出结果如下：
　　0　　INFO　2003-06-13 13:23:46968 ClientWithLog4j Client socket: Socket[addr=localhost/127.0.0.1,port=8002,localport=2014]
         16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server says: 'Java server with log4j, Fri Jun 13 13:23:46 CST 2003'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j GOOD
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server responds: 'Command 'HELLO' not understood.'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j HELP
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j Server responds: 'Vocabulary: HELP QUIT'
　　16　 DEBUG 2003-06-13 13:23:46984 ClientWithLog4j QUIT
 
      4. # 当输出信息于回滚文件时

          log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender   //指定以文件的方式输出日志
           log4j.appender.ROLLING_FILE.Threshold=ERROR 
           log4j.appender.ROLLING_FILE.File=rolling.log  //文件位置,也可以用变量${java.home}、rolling.log
           log4j.appender.ROLLING_FILE.Append=true 
           log4j.appender.ROLLING_FILE.MaxFileSize=10KB  //文件最大尺寸
           log4j.appender.ROLLING_FILE.MaxBackupIndex=1  //备份数
           log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout 
           log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n  　　

××××××××××××××××××××××××××××××××××××××××××××××××
 
>>>> 6. Log4j比较全面的配置 <<<<

 LOG4J的配置之简单使它遍及于越来越多的应用中了：Log4J配置文件实现了输出到控制台、文件、回滚文件、发送日志邮件、输出到数据库日志表、自定义标签等全套功能。择其一二使用就够用了，

 log4j.rootLogger=DEBUG,CONSOLE,A1,im
 log4j.addivity.org.apache=true

 # 应用于控制台

 log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
 log4j.appender.Threshold=DEBUG
 log4j.appender.CONSOLE.Target=System.out
 log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
 log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
 #log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

 #应用于文件

 log4j.appender.FILE=org.apache.log4j.FileAppender
 log4j.appender.FILE.File=file.log
 log4j.appender.FILE.Append=false
 log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
 log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
 # Use this layout for LogFactor 5 analysis

 # 应用于文件回滚

 log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
 log4j.appender.ROLLING_FILE.Threshold=ERROR
 log4j.appender.ROLLING_FILE.File=rolling.log  //文件位置,也可以用变量${java.home}、rolling.log
 log4j.appender.ROLLING_FILE.Append=true       //true:添加  false:覆盖
 log4j.appender.ROLLING_FILE.MaxFileSize=10KB   //文件最大尺寸
 log4j.appender.ROLLING_FILE.MaxBackupIndex=1  //备份数
 log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
 log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

 #应用于socket
 log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
 log4j.appender.SOCKET.RemoteHost=localhost
 log4j.appender.SOCKET.Port=5001
 log4j.appender.SOCKET.LocationInfo=true
 # Set up for Log Facter 5
 log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
 log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

 # Log Factor 5 Appender
 log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
 log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

 # 发送日志给邮件

 log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
 log4j.appender.MAIL.Threshold=FATAL
 log4j.appender.MAIL.BufferSize=10
 log4j.appender.MAIL.From=web@www.wuset.com
 log4j.appender.MAIL.SMTPHost=www.wusetu.com
 log4j.appender.MAIL.Subject=Log4J Message
 log4j.appender.MAIL.To=web@www.wusetu.com
 log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
 log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

 # 用于数据库
 log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
 log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
 log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
 log4j.appender.DATABASE.user=root
 log4j.appender.DATABASE.password=
 log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
 log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
 log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

 log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
 log4j.appender.A1.File=SampleMessages.log4j
 log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
 log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

 #自定义Appender

 log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

 log4j.appender.im.host = mail.cybercorlin.net
 log4j.appender.im.username = username
 log4j.appender.im.password = password
 log4j.appender.im.recipient = corlin@cybercorlin.net

 log4j.appender.im.layout=org.apache.log4j.PatternLayout
 log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=488099

　　看来，现在大多数人倾向于更加突出Java了，J2EE容易让初学者误解是独立于一套Java的技术方案。

　　从更深层次来看，Java诞生十年来，很多近十年前的业务组件至今还可以使用，软件应用不再由于语言的更迭革命带来毁灭的打击了。

　　但是，随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。

　　笔者曾经在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出：我们需要一个跨J2SE/WEB/EJB的微容器，保护我们的业务核心组件（中间件），以延续它的生命力，而不是依赖J2SE/J2EE版本，如下图：

　　此次J2EE改名为Java EE，实际也反映出业界这种共同心声。

　　让我们看看Java EE 5有哪些新的功能或规定，我们可以从SUN网站下载Java EE 5规范。其架构图如下：

　　图中灰色加黑部分是Java EE 5新的功能，我们看到，在WEB层主要加入了JSF这个新的表现层框架，和我们日常开发关系密切的是，引入了新的Java Persistence标准，这个标准正在由EJB 3.0专家组制定。

　　值得指出的是，这个Java持久化标准也可以嵌入在WEB层调用，所以，它肯定不会从属于EJB标准，这样，当前所有的Java持久层标准如：JDBC/JDO/Hibernate/Entity Bean将可能统一，减少用户的架构选择 痛苦。

　　从架构图可以看出，无论Web结构或EJB结构，提供实现的功能相差不多，这样，我们的业务核心组件就可以根据需要部署在Web或EJB中运行，而不依赖具体的Java EE容器了。前面一章图的目标在Java EE 5中可以实现了。

　　当然，Java EE 5重要改变还是：Java EE不再象以前那样只注重大型商业系统的开发，而是更关注小到中型系统的开发，简化这部分系统开发步骤。

　　落实这一简化行动的最大特征是在Java 5.0(Java 1.5)中加入Annotations，通过Annotations引入，降低Java EE开发时，既要写code，又要写XML配置文件之苦，来回照顾，疲于奔命，Annotations既是得益于C++语言，也是从开源项目xDoclet实践中获得经验。

　　但是Annotations是一把双刃剑，初学者用得不好，将会使得原本在XML中的Hard code（硬编码） 写进入代码Annotations，破坏代码的简洁和灵活性，Annotations讨论按这里。

　　当然，Annotations的引入不只是解决XML配置，从大的概念说，是解决一个资源注射问题(XML属于其中一个资源)，在原理J2EE中，容器管理的资源都是由JNDI向应用程序提供的，现在通过Annotations可以方便实现注射。

　　资源注射（Resource injection）设计概念其实是来自Ioc模式(Dependency Injection )，笔者设计开发的Jdon框架其实已经将Annotations这一宗旨的目的实现，在Jdon框架应用演示源码SimpleJdonFrameworkTest中，在jdonframework.xml中有一段如下配置：

<pojoService class="com.jdon.framework.test.dao.JdbcDAO" name="jdbcDAO">
　　<constructor value="java:/TestDS"/>
</pojoService>

　　这段配置是将数据库的JNDI名java:/TestDS注射到JdbcDAO中。Jdon Framework下一个版本将是基于Java 5.0，这行配置 将可通过 Annotations写在jdbcDAO代码中，方便程序员开发。

　　从这里，大家也可以知道EJB 3.0和EJB 2.0的区别了，有的人疑惑，是学习EJB 3.0还是学习EJB 2.0，其实EJB 3.0并没有在原理机制上对EJB有多大改动，只是做了编程方面的简化，另外EJB CMP参考了Hibernate新特点，EJB 3.0最大简化变动是CMP编程方法上。所以，无论学习EJb 3.0/2.0，EJB原理和运行机制都是一样，这部分才是学习EJB最大的困难处，而不是因为到了EJB 3.0，理解EJB就会容易。

　　初学者可从Eclipse+Xdoclet开发EJB 2.0开始学习， EJB 3.0 = EJB 2.0 + xDoclet，这里有一篇Eclipse开发EJB教程，使用JBossIDE非常简单，无需Lomboz等插件。

　　Security安全是Java EE的一个重要特点，也就是基于容器的安全访问，无需自己手工编码，具体实现可参考Jdon框架应用演示源码JdonNews。这虽然是基于J2EE 1.3编写，但是和Java EE 5区别不是很大。

　　事务管理Transaction Management也是Java EE 5的一个重要部分，该标准文档 从几个方面阐述了事务管理的要点，标准中规定了在WEB层中使用事务和线程的处理关系，标准中规定：Web服务器如Tomcat无需在Web层提供事务支持，因为Web组件根本不支持事务繁衍/传递。

　　因为目前一些架构如Struts+Spring+Hibernate/Struts+Hibernate是标准中的Web结构，因此Java EE 5在J2EE 4.2.2规定了 Web组件事务的生命周期，如果Web组件直接调用JTA，事务就不可以跨一个客户端的多个请求，事务只能在一个请求(Servlet/Jsp)中完成，这个标准规定了我们在Web架构中（如上述架构）无法使用长事务(如工作流/状态图中跨页面请求事务)，针对一个客户端跨请求的事务目前只有唯一解决方案：只有使用EJB的有态Session。参考文章：I manage long duration transactions?

　　以上是Java EE 5主要部分，Java EE包含更多其他技术部分如Jdbc JMS JCA JNDI 等等，需要用户在实践中摸索。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=821836

下表是Java和Java应用经常出现的关键词,其中绝大多数都是和J2EE相关的。

1 31498 (38.50 %) J2EE
2 21368 (26.12 %) XML
3 13380 (16.35 %) .NET
4 11514 (14.07 %) JSP
5 9895 (12.09 %) HTML
6 8217 (10.04 %) WebSphere
7 6583 (8.05 %) Struts
8 6295 (7.69 %) EJB
9 6068 (7.42 %) Servlets
10 5182 (6.33 %) WebServices
11 4998 (6.11 %) Hibernate
12 4447 (5.44 %) JDBC

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1406718

F3 是一个声明式的Java脚本语言，它使用静态类型以获得更好的IDE支持和编译时错误（这和Javascript不同），还支持类型引用，申明式语法和自动数据绑定，完全支持2D图像接口和标准的Swing组件，以及声明式的动画。你还可以在里面引用java类，创建新的java对象，调用它们的方法和实现Java接口。

该项目还同时设计了Netbeans和Eclipse的插件来支持代码即使检查，代码自动完成，语法高亮，和超链接导航。

F3 向我们展示了，我们尚未完全挖掘Java平台在GUI开发方面的能力，有了工具支持的F3，使Java平台在GUI开发上比Macromedia Flash/Flex/Open Laszlo, Adobe Apollo, Microsoft WPF/XAML, Mozilla XUL, AJAX/DHMTL.更具有竞争力。

Example

import f3.ui.*;
import f3.ui.canvas.*;
import f3.ui.filter.*;
 
Canvas{
    content: Text {
        x: 20
        y: 20
        content: "Welcome to F3"
        font: Font{ face: VERDANA, style: [ITALIC, BOLD], size: 80}
        fill: LinearGradient {
            x1: 0, y1: 0, x2: 0, y2: 1
            stops:
            [Stop {
                offset: 0
                color: blue
            },
            Stop {
                offset: 0.5
                color: dodgerblue
            },
            Stop {
                offset: 1
                color: blue
            }]
        }
        filter: [Glow {amount: 0.1}, Noise {monochrome: true, distribution: 0}]
    }
}

would produce:

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1378821

    文章来源：互联网   

点击数：
 
 
我们现在大部分人做网页，都是直接用DW插入flash，

而且DW也是所见即所得，直接生成了相应的flash显示代码。

可是我们又有多少人了解这些直接由DW生成的代码呢？

其实我接触flash player标签，是在刚学习html的时候，

那时书中插入flash只有最简单的<embed src="" width=""

 height=""></embed>一句,而且在很长一段时间里，

只要网页中插入flash我也都是这样写的，

当时认为，这样写即简单好记，又节省代码，反倒对DW起疑问，

为什么这么简单的代码，它要搞得这么复杂呢。但仔细想想，

DW生成的代码必有他的道理。而在后来的应用中，

也应证了我的判断（呵呵，也许想法本来就菜）。
    这几个星期，一直在做flash与JS及.NET交互相关的应用，

所以对OBJECT、EMBED标签有了更深的了解。就这两天，

在做flash实现网页拖块布局功能（类似QQ空间的JS布局），

由于要根据不同用户，载入及输出不同的用户配置文件，

所以我想到了由.NET生成的相应用户的配置文件名，

而用<param name="FlashVars"

value="import=userimport1.txt&output=useroutput1.txt">

来传递相关的文件变量给flash。但在实际应用中，

发现Firefox及opera等浏览器并不能识变这样的变量传递，

更确切地说，它们并不支持<param>标签。所以今天抽空，

上MM网收集整合了一下相关的内容。

    一、介绍：
    我们要在网页中正常显示flash内容，

那么页面中必须要有指定flash路径的标签。也就是OBJECT

和EMBED标签。OBJECT标签是用于windows平台的IE浏览器的，

而EMBED是用于windows和Macintosh平台下的Netscape Navigator浏览

器以及Macintosh平

台下的IE浏览器。windows平台的IE利用Activex控件来播放

flash而其它的浏览器则使用Netscape插件技术来播放flash。

    下面是简单的网页中插入flash的代码示例：

    Code:

<OBJECT classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
codebase="http://download.macromedia.com/pub/sho
ckwave/cabs/flash/swflash.cab#version=6,0,40,0"
WIDTH="550" HEIGHT="400" id="myMovieName">
<PARAM NAME=movie VALUE="myFlashMovie.swf">
<PARAM NAME=quality VALUE=high>
<PARAM NAME=bgcolor VALUE=#FFFFFF>
<EMBED src="/support/flash/ts/docum
ents/myFlashMovie.swf" quality=high bgcolor=#FFFFFF WIDTH="550"
 HEIGHT="400"
NAME="myMovieName" ALIGN="" TYPE="application/x-shockwave-flash"
PLUGINSPAGE="http://www.macromedia.com/go/getflashplayer">
</EMBED>
</OBJECT>

    二、为什么要使用以上全部的标签？能省略某些标签不？
    OBJECT标签是用于windows IE3.0及以后浏览器或者其

它支持Activex控件的浏览器。“classid”和“codebase”

属性必须要精确地按上例所示的写法写，它们告诉浏览器自动下

载flash player的地址。如果你没有安装过flash player

那么IE3.0以后的浏览器会跳出一个提示框访问是否要自动安装

flash player。当然，如果你不想让那些没有安装flash

player的用户自动下载播放器，或许你可以省略掉这些代码。
 
    EMBED标签是用于Netscape Navigator2.0及以后的浏

览器或其它支持Netscape插件的浏览器。“pluginspage”

属性告诉浏览器下载flash player的地址，如果还没有安装

flash player的话，用户安装完后需要重启浏览器才能正常

使用。
  为了确保大多数浏览器能正常显示flash，你需要把EMBED

标签嵌套放在OBJECT标签内，就如上面代码例子一样。

支持Activex控件的浏览器将会忽略OBJECT标签内的EMBED标签。

Netscape和使用插件的IE浏览器将只

读取EMBED标签而不会识别OBJECT标签。也就是说，如果你省

略了EMBED标签，那firefox就不能识别你的flash了

（不过纳闷的是，省略了object只写embed，IE也能正常显示

flash，呵呵，具体的再仔细看看了）。
本文列出了用于发布影片的OBJECT和EMBED标签的必要以及可选属性。

    一、必需属性：
  ·CLASSID-设置浏览器的Activex控件，仅用于OBJECT标

签。
  ·CODEBASE-设置flash Activex控件的位置，因而如果

浏览器如果没有安装的话，可以自动下载安装。仅用于OBJECT

标签。
  ·WIDTH-以百分比或象素指定flash影片的宽度。
  ·HEIGHT-以百分比或象素指定flash影片的高度。
  ·SRC-指定影片的下载地址。仅用于EMBED标签。
  ·PLUGINSPAGE-设置flash 插件的位置，因而如果浏览器

如果没有安装的话，可以自动下载安装。仅用于EMBED标签。
  ·MOVIE-指定影片的下载地址。仅用于OBJECT标签。

二、可选属性及可用的值：
  ·ID-设定变量名，用于脚本代码的引用。仅用于OBJECT。
  ·NAME -设定变量名，用于脚本代码（如javascript）的

引用。仅用于EMBED。
  ·SWLIVECONNECT - （true或false）指定当flash

player第一次下载时，是否启用java。如果些属性省略，

默认值为false。你果你在相同页同使用javascript和flash，

java必须使用FSCommand来工作。
  ·PLAY -（true或false）指定flash影片是否在下载完成

后就自动播放，如果省略此属性，则默认为true。
  ·LOOP - （true或false）指定影片播放完最后一帧后是

停止还是继续循环播放，如果省略此属性，则默认为true。
  ·MENU - （true或false）
    ·True 显示全部的菜单，允许用户放大，缩小等控制影

片播放等操作。
    ·False 显示只包含设置选项和关于flash的菜单。
  ·QUALITY - (low, high, autolow, autohigh, best )
     ·Low 速度优于美观，而且不应用反锯齿。
   ·Autolow 刚开始着重于速度，但当需要时随时提升美观。
   ·Autohigh 同时着重播放速度和美观，但需要时则牺牲美

观来保证播放速度。
   ·Medium 应用一些反锯齿而不平滑位图。它质量高于low

设置而低于high设置。
   ·High 美观优于播放速度，而且一直应用反锯齿。

如果影片不包含动画，位图会被平滑化;而如果影片包含动画，

位图将不变平滑。
   ·Best 提供最好的显示质量而不考虑播放速度。

所有输出都应用反锯齿及所有位图都被平滑化。
  ·SCALE - (showall, noborder, exactfit)
     ·Default(Show all)影片在指定的区域内显示，

但保持原始的比例。影片两侧将会出现边框。
   ·No Boder 收缩影片以适合指定的区域，保持影片不失真，

但部分影片将可能将裁切。然而保持影片的原始比例。
   ·Exact Fit 使整个影片在指定的区域内显示，影片有可

能变形失真，而且不保持原始的比例。
  ·ALIGN - (l, t, r, b)
   ·默认为居中，当浏览器窗口小于影片时，边缘会被裁切。
   ·Left,Right,Top,Bottom按照相应的设置沿浏览器的边

缘对齐。如果需要，另外三边将被裁切。
  ·SALIGN - (l, t, r, b, tl, tr, bl, br)
   ·L,R,T,B
   ·TL,TR
   ·BL,BR
  ·WMODE- (window, opaque, transparent)

设置flash影片的window mode属性，指定flash在浏览器中

的透明，层叠及位置。
   ·Window 影片在浏览器中自己的矩形窗口内播放。
   ·Opaque 影片隐藏了所有在它后面的内容。
   ·Transparent 使flash影片透明，显示透明影片后

面的网页内容。这将会降低动画的性能。而且这个属性不是在所

有浏览器中都可用的。
  ·BGCOLOR - （#RRGGBB, 十六进制RGB值。）指定影片的

背景颜色。使用这个属性覆盖flash中设定的背景颜色。
  ·BASE - 设定基准目录或URL，用来解决所以flash中的相

对路径。类似网页中的<base>标签。
  ·FLASHVARS 传递变量到flash player，需要flash

player6及以后的版本。
   ·传递root级变量到影片。字符串的格式是用“&”分

隔的name=value集。
   ·浏览器支持64kB大小的字符串长度。
   ·更多关于FlashVars的信息，请查看相关文档。
 

class  CreditDAoImpl implements CreditDAO  {
    Connection conn  =  getConnection();
     public   void  transfer(Currency amount, Account fromAccount, Account toAccount) throws CreditException  {
         try   {
             conn.setAutoCommit( false );
             depositToAccount(conn, toAccount, amount);
             withdrawFromAccount(conn, fromAccount, amount);     
             conn.commit();
        }   catch  (Exception e)  {
             try   {
                 conn.rollback();
                  throw   new  CreditException(e.getMessage());
            }   catch  (SQLException e1)  {
                  throw   new  CreditException(e.getMessage());
            }                        
        }  
    }
}

        4.什么是JTA Transaction？它有怎样的特点呢？JTA Transaction是指由J2EE Transaction manager去管理的事务。其最大的特点是调用UserTransaction接口的begin，commit和rollback方法来完成事务范围的界定，事务的提交和回滚。JTA Transaction可以实现同一事务对应不同的数据库，但是它仍然无法实现事务的嵌套。具体的代码如下^[1]：

public   void  withdrawCash( double  amount)  {
   UserTransaction ut  =  context.getUserTransaction();
    try   {
      ut.begin();
      updateChecking(amount);
      machineBalance  -=  amount;
      insertMachine(machineBalance);
      ut.commit();
   }   catch  (Exception ex)  {
        try   {
          ut.rollback();
       }   catch  (SystemException syex)  {
            throw   new  EJBException
              ( " Rollback failed:  "   +  syex.getMessage());
       }
        throw   new  EJBException 
          ( " Transaction failed:  "   +  ex.getMessage());
    }
}

        5.什么是Container-Managed Transaction？它又有怎样的特点呢？Container-Managed Transaction，顾名思义，就是由Container负责管理的Transaction，当然这样Transaction是出现在EJB的范畴中。Container-Managed Transaction最大的特点是不需要显式界定事务的边界，也不需要显式的提交或者回滚事务，这一切都由Container来替我们完成。我们需要做的就是设定在一个Bean中，哪些方法是跟事务相关的，同时设定它们的Transaction Attribute既可。
        Transaction的Scope是相当重要的，特别是在一个Bean的方法中调用另外一个Bean的方法。为了便于说明问题，我们把这两个方法分别称为methodA和methodB。当methodA调用methodB的时候，methodB在事务的层面上对调用者methodA有怎样的限制(methodB中是否存在事务)以及methodA如何在事务的层面上实现对methodB的调用(是否需要重新创建一个新的事务来处理methodB的调用)都需要通过Transaction Attribute来设定的。具体的Transaction Attribute有以下六种：Required，RequiresNew，Mandatory，NotSupported，Supports和Never。有关Transaction Attribute的介绍，可以参阅J2EE Tutorial中关于Container-Managed Transaction的介绍。

        [1] 代码来自SUN的J2EE Tutorial中关于Bean-Managed Transaction的介绍

作者：佚名    来自：未知

您现在可能已在使用 JavaBean，但还不了解它。如果有支持 Java 的浏览器，那么，在桌面上使用 JavaBean 就没有限制。使用的 Web 页面可以将 bean 作为小应用程序的一部分。您很快就会和作为浏览器可视部分的 JavaBean 交互，然后，那些 JavaBean 将与服务器上的 EJB 接口。这种能力也可以扩展到因特网和内部网。

　　JavaBean 和 Server Bean（通常称为 Enterprise JavaBean (EJB)）有一些基本相同之处。它们都是用一组特性创建，以执行其特定任务的对象或组件。它们还有从当前所驻留服务器上的容器获得其它特性的能力。这使得 bean 的行为根据特定任务和所在环境的不同而有所不同。

　　这开辟了巨大商机。因为 JavaBean 是与平台无关的，所以对于将来的解决方案，供应商可以轻易向不同用户推出其客户机方的 JavaBean，而不必创建或维护不同的版本。这些 JavaBean 可以与执行商业功能（例如订购、信用卡处理、电子汇款、存货分配、运输等）的 EJB 配合使用。这里有巨大潜力，而这正是组件代理（WebSphere Application Server 企业版）设计提供的那种潜力。

　　JavaBean 是一种组件，它在内部有接口或有与其相关的属性，以便不同人在不同时间开发的 bean 可以询问和集成。可以构建一个 bean，而在以后构造时将其与其它 bean 绑定。这种过程提供了先构建，然后重复使用的方法，这就是组件的概念。可以将这种单一应用程序部署成独立程序、ActiveX 组件或在浏览器中。

　　JavaBean 因其外部接口（即属性接口）而与纯对象不同。这种接口允许工具读取组件要执行的功能，将其与其它 bean 挂钩，以及将其插入其它环境。JavaBean 设计成对单一进程而言是本地的，它们在运行时通常可视。这种可视组件可能是按钮、列表框、图形或图表 - 但这不是必需的。

　　可执行组件

　　Server Bean 或 EJB 是部署在服务器上的可执行组件或商业对象。有一个协议允许对其进行远程访问或在特定服务器上安装或部署它们。有一系列机制允许它们将服务安全性、事务行为、并发性（由多个客户机同时访问的能力）和持久性（其状态可以保存多久）的主要方面授权给 EJB 服务器上其所在的容器。当安装在容器中时，它们获得各自的行为，该行为提供不同质量的服务，因此，选择正确的 EJB 服务器至关重要。这正是 IBM WebSphere 企业版的优势所在。

　　EJB 是设计成运行在服务器上，并由客户机调用的非可视远程对象。可通过多个非可视 JavaBean 构建 EJB。它们有一个部署描述符，其目的与 JavaBean 属性相同：它是以后可由工具读取的 bean 的描述。EJB 还独立于平台，一旦编写好，还可以在任何支持 Java 的平台（包括客户机和服务器）上使用。

　　因为 EJB 由诸如 IBM VisualAge for Java 这样的工具集生成，所以，它是基于服务器的对象，并用于远程调用。它们安装在 EJB 服务器上，并象调用其它 CORBA 远程对象那样获得进行调用的远程接口。

　　ActiveX 对象

　　可以将 JavaBean 部署成 ActiveX 对象，虽然 EJB 的代理也可以这样做，但是，因为 ActiveX 运行在桌面上，所以，EJB 本身不能成为 ActiveX 对象。要在与平台相关的、仅 Windows 平台上做到这一点，开发人员可以将 JavaBean 变换成 ActiveX 组件。

　　好处

　　EJB 的主要好处在于：构建 bean 时，bean 开发人员可以规定需要什么类型的行为，而不必规定如何去做。开发分为两部分：程序员开发 bean，然后验证：它可与构建工具一起工作，并包括标识所需服务质量行为种类的部署描述符。下一步，另一个程序员可以采用这个 bean，并使用读取 EJB 部署描述符的部署工具，然后将该 bean 安装到 Enterprise Java Server 上的容器中。在第二步中，部署工具采取一些操作 - 这可能意味着生成如状态保存代码，放入事务挂钩，或执行安全性检查这样的代码。所有这些操作由部署工具生成，bean 开发人员和部署人员可以是不同的人。

　　可以通过使用部署工具，将任何独立于平台的 JavaBean 改写成具有可靠服务质量、特定于平台的 EJB，以满足现有商业系统和应用程序的特定需求。这就是 EJB 服务器对集成系统、网络和体系结构如此重要的原因所在。

　　EJB 与 IBM WebSphere 企业版

　　在 IBM WebSphere 企业版中使用时，可以将 EJB 配置成被管理的商业对象。接受它们授权服务的容器是其安装到的容器。将 EJB 的持久性部分映射在数据或状态对象中。EJB 服务器为 EJB 提供不同的服务质量，选择正确的 EJB 服务器可能对满足完整的商业需求至关重要。“组件代理”功能极其健壮，该功能提供如负载均衡和支持服务器组中多台机器的高级功能。它还有大大超出 Enterprise Java Server (EJS) 规范所倡导的系统管理功能。因此，按照基本标准编写的 JavaBean 或 EJB 可以运行在使用“组件代理”功能的 WebSphere 企业版上，并获得那些所有的附加功能。

　　EJB 服务器还提供独特的特性和服务质量，而且不完全相同。IBM“组件代理”有一些强大特性 - 例如，可伸缩性，它允许开发人员将 EJB 部署到从小型系统到大型网络的不同类型服务器。开发人员可以从小处入手，例如，在一个部门中，首先在 LAN 的 Java 服务器上部署，一旦准备好，就知道可以将在那里创建的 JavaBean 和 EJB 部署到全球网络。然后，开发人员可以测试并熟悉这些 bean，试运行，制作样本等等。满意之后，开发人员可以通过将其移至高性能服务器，来大幅度扩大其规模。JavaBean 和 EJB 不受任何计算机体系结构边界的限制。它们用 Java 编写，可以运行在任何具有 Java 虚拟机的系统上，并可以使用任何 Enterprise Java Server (EJS) 来部署对象。因此，开发人员现在可以在方便的系统上构建，以后在方便的系统上部署，而不必是同一台或同样类型的机器。

　　IBM WebSphere 企业版支持将商业对象部署到多台服务器。EJB 作为商业对象集成到“组件代理”功能，并作为任何其它商业对象处理。因此，EJB 可以连接到所选的后端系统，并执行任何所需操作，以满足其商业需求。这就成为“组件代理”为 EJB 提供的基础设施。通过将“组件代理”用作 EJB 服务器，开发人员将能够继续使用当前旧有系统，并将其与电子商务接口一起提供。

　　为使 EJB 能在 WebSphere“组件代理”环境中工作，可以使用“组件代理”部署工具将其安装在一台或多台服务器上，然后将其添加到命名服务器，以便可以全局查找到它。任何可以访问公共命名服务器的人都可以找到它，找到其宿主，并可以在宿主上执行方法，同时创建 EJB。这就是“代理组件”要做的事。

　　示例

　　让我们举一个在 Web 购物站点上可以看到的电子购物车的例子。用户的购物车是一个 JavaBean。用户将货架上的商品放入购物车，这些商品本身是 JavaBean。它们全部可视，并且面向用户。结帐时，将用户购物车中的商品发送到服务器上的 EJB，该 EJB 执行一些必要的操作，如检查信用卡授权和可用额度，生成封条，或生成给发货部门的有关提什么货和发货地点的特殊指示 - 这就是商业程序已在进行的活动。

　　结束语

　　Bean 的全部意义不只是其现有能力，更在于其可以为商业提供的有竞争力的潜在能力。IT 设计师和应用开发人员现在可以将精力完全集中在商业逻辑，而将如事务、持久性和安全性的底层工作留给服务器。WebSphere 的“组件代理”功能将提供所有这些（还有后端访问）和对象事务管理器。

public class Foo {
    
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public bar () {
      // do something ...
    }    
}

@SecurityDomain("other")
public class Foo {
    
    @RolesAllowed({"managers"})
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public bar () {
      // do something ...
    }   
}

<!-- Setup the transaction interceptor -->
<bean id="foo" 
  class="org.springframework.transaction
        .interceptor.TransactionProxyFactoryBean">
    
    <property name="target">
        <bean class="Foo"/>
    </property>
    
    <property name="transactionManager">
        <ref bean="transactionManager"/>
    </property>
    
    <property name="transactionAttributeSource">
        <ref bean="attributeSource"/>
    </property>
</bean>

<!-- Setup the transaction manager for Hibernate -->
<bean id="transactionManager" 
  class="org.springframework.orm
         .hibernate.HibernateTransactionManager">
    
    <property name="sessionFactory">
        <!-- you need to setup the sessionFactory bean in 
             yet another XML element -- omitted here -->
        <ref bean="sessionFactory"/>
    </property>
</bean>

<!-- Specify which methods to apply transaction -->
<bean id="transactionAttributeSource"
  class="org.springframework.transaction
         .interceptor.NameMatchTransactionAttributeSource">
  
    <property name="properties">
        <props>
            <prop key="bar">
        </props>
    </property>
</bean>

    class="org.springframework.aop.framework.autoproxy
           .DefaultAdvisorAutoProxyCreator"/>
<bean id="transactionAttributeSource"
    class="org.springframework.transaction.interceptor
           .AttributesTransactionAttributeSource"
    autowire="constructor"/>
<bean id="transactionInterceptor"
    class="org.springframework.transaction.interceptor
           .TransactionInterceptor"
    autowire="byType"/>
<bean id="transactionAdvisor"
    class="org.springframework.transaction.interceptor
           .TransactionAttributeSourceAdvisor"
    autowire="constructor"/>
<bean id="attributes"
    class="org.springframework.metadata.commons
           .CommonsAttributes"/>

public class FooDao {

    @Resource (name="DefaultDS")
    DataSource myDb;
    
    // Use myDb to get JDBC connection to the database
}

@Resource 
public void setSessionContext (SessionContext ctx) { 
    sessionCtx = ctx; 
} 

@Stateful
public class FooBean implements Foo, Serializable {

    @PersistenceContext(
      type=PersistenceContextType.EXTENDED
    )
    protected EntityManager em;
    
    public Foo getFoo (Integer id) {
        return (Foo) em.find(Foo.class, id);
    }
}

public class FooDao {
    
    HibernateTemplate hibernateTemplate;
    
    public void setHibernateTemplate (HibernateTemplate ht) {
        hibernateTemplate = ht;
    }
    
    // Use hibernateTemplate to access data via Hibernate
    public Foo getFoo (Integer id) {
        return (Foo) hibernateTemplate.load (Foo.class, id);
    }
}

<bean id="dataSource" 
  class="org.springframework
         .jndi.JndiObjectFactoryBean">
    <property name="jndiname">
        <value>java:comp/env/jdbc/MyDataSource</value>
    </property>
</bean>

<bean id="sessionFactory" 
  class="org.springframework.orm
         .hibernate.LocalSessionFactoryBean">
    <property name="dataSource">
        <ref bean="dataSource"/>
    </property>
</bean>

<bean id="hibernateTemplate" 
  class="org.springframework.orm
         .hibernate.HibernateTemplate">
    <property name="sessionFactory">
        <ref bean="sessionFactory"/>
    </property>    
</bean>

<bean id="fooDao" class="FooDao">
    <property name="hibernateTemplate">
        <ref bean="hibernateTemplate"/>
    </property>
</bean>

<!-- The hibernateTemplate can be injected
        into more DAO objects -->

    Hadoop 是 Google labs 的MapReduce的一个实现，Nutch项目的全部数据处理都构建在其之上。MapReduce是一种简化的分布式编程模式，让程序可以自动在普通机器组成的集群中以并行方式分布执行。

    就如同java程序员可以不考虑内存泄露一样，MapReduce程序员也不许要关心海量数据如何被分配到多台机器上，不需要考虑机器失效的处理，不需要考虑这些机器间如何协作共同完成工作，程序员不需要什么并发处理或者分布式系统的经验，就可以进行分布式的编程。

   MapReduce来源于函数式编程的Map,Reduce概念，Map是映射，Reduce是规约。说了非常简单，就真的是非常简单的，先看Hadoop自带的sample-WordCount ，再看Nutch里的Indexer,Fetcher两个实战的例子，最后阅读Hadoop wiki 上的HadoopMapReduce，很快就可以上手：
 
   MapReduce过程简记:
    1.根据输入路径，先用FileSplit把输入的文件剁碎，根据InputFormat(读入资料的格式)内含的RecordReader把资料读入成一组(key,value)对，然后按mapper count平均分给不同的Mapper处理。(这段因为没看过源码，还有点模糊)
    2.Mapper进行Map操作 :: (InitialKey, IntialValue) -> [(InterKey, InterValue)] 从Inupt key,value 产生中间数据集。
    3.Reducer进行Reduce操作:: (Interkey, InterValuesIterator) -> [(InterKey, InterValue)]，Reducer遍历所有节点取得需要的中间数据集，再对其进行去重、过滤等后期处理，得到结果。
    4.最后由OutputFormat类（输出资料的格式）内含的RecordWriter，将最终结果输出。结果输出可以是文件，也可以是其他形式，比如Nutch的Indexer，output时并不是去写文件，而是调用Lucene的IndexWriter将作为中间数据集的Lucene Document存盘。

  一段典型的Hadoop代码:

     这就是一段hadoop式程序的主代码，用户自行实现四个内部类，MyInputFormat，MyOutputFormat，MyMapper和MyReducer，然后一一在jobConf里配置，最后执行runJob()即可。对比一下Nutch的源码就知道，只要把原来一段顺序执行的代码，拆分到上面四个类里面去，再在jobConf里进行指定，就可以拥有分布式执行的能力，无须要处理分布式编程的代码。配置一下服务器列表，在每台服务器上执行nutch/bin/start-all.sh，你的代码就分布式地执行了。

   最后看一下Hadoop的结构，除了MapReduce的分发外，还有两个很重要的部分：

   Hadoop的快速接口反射式RPC系统：IPC。

   Hadoop的分布式文件系统NDFS：见 CSharpProgrammer blog上的文章。

   注1：笔记中部分句子直接从网上文章摘录，不一一声明。

   注2：Hadoop 目前版本为0.5，还不够成熟，看过源码的Donald对其源码评价一般，值得继续等待。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1063315

SQLExplorer是Eclipse集成开发环境的一种插件，它可以被用来从Eclipse连接到一个数据库。SQLExplorer插件提供了一个使用SQL语句访问数据库的图形用户接口（GUI）。通过使用SQLExplorer，你能够显示表格、表格结构和表格中的数据，以及提取、添加、更新或删除表格数据。SQLExplorer同样能够生成SQL脚本来创建和查询表格。所以，与命令行客户端相比，使用SQLExplorer可能是更优越的选择。在这篇指南中，我们将使用SQLExplorer插件建立一个从Eclipse3.0到开源数据库MySQL的JDBC连接。

这篇指南有如下章节：

1.概览
2.预备安装
3.配置 SQLExplorer
4.访问数据库数据

概   览
通过在集成开发环境中加入一个SQLExplorer视窗，SQLExplorer插件为Eclipse配置了一个访问数据库的SQL客户端。

为了演示SQLExplorer插件的使用，我们将在开源数据库MySQL中创建一个示例表，并且建立一个从Eclipse到MySQL数据库的JDBC连接。接着，我们将在SQLExplorer的图形SQL客户端中提取和显示示例数据。同样，我们也将通过更新和删除示例表中的数据来演示SQLExplorer插件的不同特点。

预 备 安 装

1. 下载并安装 Eclipse 3.02
2. 下载SQLExplorer文件 net.sourceforge.sqlexplorer_2.2.3.zip.
3. 解压 SQLExplorer .zip 文件到 <Eclipse>/eclipse 目录。 <Eclipse> 是Eclipse安装的目录。 这将把SQLExplorer插件的 features 和 plugins 目录添加到Eclipse中的 features 和 plugins 目录。（译者注：这里说得不是十分清楚，其实是先将SQLExplorer .zip文件解压，然后分别把features 和 plugins 目录中的所有文件拷贝到Eclipse中对应的features 和 plugins 目录中，这是安装Eclipse插件的常用方法，当然也可以使用link方式安装插件，请参阅网上相应文档）
4. 重启Eclipse.
5. 安装MySQL数据库。
6. 下载Connector/J，通过使用包含在其中的一个 .jar文件中的JDBC驱动来连接MySQL数据库。
7. 作为一个root用户登陆到MySQL数据库，命令如下：
  
   >mysql -u root

   root用户没有设定密码。需要通过密码登陆到数据库时，指定如下命令：

   >mysql -u root -p

8. 使用如下命令连接到test数据库，这是一个示例数据库实例：

   >use test

9. 在test数据库中创建一个示例表。示例表 Catalog 由ONJava上的文章名称组成。用来创建示例表的SQL脚本列在下面：

  

CREATE TABLE Catalog(CatalogId INTEGER, Journal VARCHAR(25),
      Publisher Varchar(25), 
      Date VARCHAR(25), Title Varchar(45), Author Varchar(25));

   INSERT INTO Catalog VALUES('1', 'onjava',  
      'OReilly', 'April 2005', 'Five Favorite Features from 5.0', 
      'David Flanagan');

   INSERT INTO Catalog VALUES('2', 'onjava',    
      'OReilly', 'Feb 2005', 'Introducing JBoss Remoting', 
      'John Mazzitelli');

   INSERT INTO Catalog VALUES('3', 'onjava',   
      'OReilly', 'March 2005', 'Aspect-Oriented Annotations', 
      'Bill Burke');

配置 SQLExplorer

安装了SQLExplorer插件后，我们将要在Eclipse 3.02中配置SQLExplorer.首先，在Eclipse中打开SQLExplorer视窗。在Eclipse 集成开发环境中单击 “Open a perspective”按扭来打开一个视窗。图1说明了“Open a perspective”按扭。

在条目列表中，选择“Other...”来显示SQLExplorer插件，如图2所示。

在 Select Perspective框中，选择SQLExplorer视窗，如图3所示。通过选择SQLExplorer视窗，SQLExplorer插件的功能部件在Eclipse中变得可用。

Drivers 标签显示了不同的数据库驱动，它们被用来连接不同的数据库。现在可用的数据库包括DB2, MySQL, Oracle, Sybase, HSQLDB, SQLServer 和 PostgreSQL。针对MySQL，我们需要配置SQLExplorer。为了配置MySQL驱动，右击 MMMySQL Driver 结点， 并且选择 Change the Selected Driver, 如图4所示。

在 Modify Driver框中，选择 Extra Class Path 标签，并且单击 Add 按扭将 MySQL 驱动 .jar 文件（为下载的 Connector/J 的一部分）添加到类路径中。图5阐明了将MySQL 的 JDBC 驱动加到 Eclipse 的类路径中。

添加 MySQL Connector/J 驱动 .jar 文件，mysql-connector-java-3.0.16-ga-bin.jar，到类路径中。在 Example URL 域中， 指定连接到数据库的 URL。一个连接到 test 数据库的JDBC连接将被创建，test数据库已经在MySQL安装的时候预先创建了。连接到 test 数据库的 URL 为 jdbc:mysql://localhost/test。在 Driver Class Name 域中，指定MySQL JDBC 驱动为 com.mysql.jdbc.Driver。MMMySQL 驱动按如图6所示的设置配置。

想要连接到 MySQL 数据库并提取其中的表格，我们需要为连接建立一个别名。一个连接的别名说明了连接设置，JDBC 驱动，URL，用户名和密码。在SQLExplorer视窗中选择 Aliases 标签。单击 “Create new Alias” 按扭来创建一个新的别名，如图7所示。

在“Create new Alias"框中，指定一个别名。选择MMMySQL Driver 来为MySQL数据库创建一个别名。在 URL 域中指定 test 数据库的连接 URL, jdbc:mysql://localhost/test。图8展示了MySQL 别名的设置。

以上操作将一个MySQL的别名加入到 Aliases 标签中，正如图9所示。想要修改一个别名，右击别名结点并选择 “Change the selected Alias.”

MySQL 别名用来连接到 MySQL 数据库并且从中提取数据。要想打开数据库连接，右击 MySQL 别名结点并选择 Open，如图10所示。

在 Connection 框中，指定登陆到 MySQL 数据库使用的用户名和密码，然后单击 OK 按扭。图11展示了登陆的设置。缺省情况下，对于 root 用户不需要密码。

一个与 MySQL 数据库的 JDBC 连接就这样建立了。一旦连接上了，Eclipse 就会显示 MySQL 数据库中的不同的数据库模式，如图12所示。

对其他数据库的支持

这个 JDBC 连接的例子是关于配置与 MySQL 数据库连接的。通过在 Drivers 标签中为数据库选择合适的驱动，可以配置与其他数据库的 JDBC 连接。只需为选定的数据库指定驱动类和连接URL，就可以配置与该数据库的 JDBC 连接。以下列出的是其他数据库的驱动类、连接URL和驱动 .jar 文件。

DB2
o        Driver Class: COM.ibm.db2.jdbc.app.DB2Driver
o        Connection URL: jdbc:db2:<database>
o        Driver .jar/.zip: db2java.zip

Sybase
o        Driver Class: com.sybase.jdbc2.jdbc.SybDriver
o        Connection URL: jdbc:sybase:Tds:<host>:<port>/<database>
o        Driver .jar/.zip: jconn2.jar

Oracle
o        Driver Class: oracle.jdbc.driver.OracleDriver
o        Connection URL: jdbc:oracle:thin:@ <host>:<port>:<sid>
o        Driver .jar/.zip: classes12.zip

SQLServer
o        Driver Class: com.microsoft.jdbc.sqlserver.SQLServerDriver
o        Connection URL: jdbc:microsoft:sqlserver://localhost:1433
o        Driver .jar/.zip: mssqlserver.jar, msbase.jar, msutil.jar

PostgreSQL
o        Driver Class: org.postgresql.Driver
o        Connection URL: jdbc:postgresql://<server>:<port>/<database>
o        Driver .jar/.zip: postgresql.jar

在如上列表中，<database> 是指数据库实例，<port> 是数据库连接端口，<sid> 是数据库的SID，<server> 是数据库服务器。

访问数据库数据
在上一节中我们在 Eclipse 中配置了 SQLExplorer 插件。下面，我们将从示例表 Catalog 中提取并修改数据。如果是从一个命令行 SQL 客户端访问数据库，则使用如下命令来提取数据（在一行中）：

SQL>SELECT catalogId, journal, publisher, date,
title, author from Catalog;

这将以文本表的形式显示数据。使用图形 SQL 客户端 SQLExplorer,数据将以结构表的形式显示。SQLExplorer 同样也会生成创建表和从中提取数据的 SQL 脚本。如果使用 DESC 命令在一个命令行客户端中显示表格的结构，只有列名，列数据的类型，列数据的长度大小以及非空的值会被显示。有了 SQLExplorer, 索引、主键和外键值都会被显示。

在 Eclipse 的 SQLExplorer 视窗中选择 Database Structure View 标签。为了显示表 Catalog 的结构，在 Database Structure View 中选择 Database>test>TABLE>Catalog 结点。图13显示了表 Catalog 的结构。

Columns 标签显示了下表中列出的列：

为了显示选中的表格中的数据，请选择 Preview 标签。图14显示了表 Catalog 中的数据。关于表格的其他的信息分别在 Indexes, Primary Key, Foreign Key 和 Row Count 标签中显示。

若想得到创建表格的 SQL 脚本，右击表结点并且选择 Create Table Script,如图15所示。

如图16所示，这将生成创建被选表格的 SQL 脚本， 并将其显示在 SQLExplorer 视窗中的 SQL Editor 中。

Database Structure View 的 Preview 标签中的数据是使用缺省的 Select 查询提取的，它包括了表格中所有的列。要想显示缺省的 Select 查询语句，右击表结点并且选择 “Generate Select in Sql Editor”，如图17所示。

如图18所示，SQL Editor 中显示了从表 Catalog 中提取数据的缺省查询语句。注意：显示在 SQL Editor 中的 SELECT 查询语句的结尾没有分号（；）。

查询语句可能被定制为只显示表格中的几列数据。比如，修改 Select 语句使其显示除了 CatalogId 列的其他所有列。选择 Execute SQL 按扭来运行 SQL 脚本。由修改后的 select 语句得到的数据显示在 SQL Results 框中，如图19所示。

接下来，SQL Editor 中的一条 SQL 脚本将会更新表 Catalog。例如，把标题“Five Favorite Features from 5.0”修改为“New Features in JDK 5.0”。如图20所示，在 SQL Editor 中运行更新表 Catalog 的脚本

表格中数据被更新了。在修改后的表格上运行缺省的 select 查询，修改后的数据将被显示在 SQL Results 框中。图21显示了表 Catalog 修改后的数据。

接着，使用 DELETE SQL语句从表中删除一行数据，如图22所示。CatalogId='3'的行将从表中删除。

运行缺省的 select 查询语句来显示修改后的表中的数据。SQL Results 框中的表格不再包括被删除的行了，如图23所示。

通过在 Eclipse 中配置 SQLExplorer 插件，该集成开发环境获得了图形用户界面（GUI）较之命令行客户端的许多优点。


总   结

例子中，我们与 MySQL 数据库建立了一个 JDBC 连接，并访问其中的一个示例数据库。SQL Explorer 同样可以被用来配置与其他数据库的连接，包括 DB2, Sybase, Oracle, HSQLDB, SQL Server 和 PostgreSQL。 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1175433

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1155150

Patrick Gan (patgan@us.ibm.com), 应用程序卓越创新服务中心的高级 IT 专家, IBM

Asynchronous JavaScript + XML （Ajax）是个相当新的术语（有些人说它是旧酒装新瓶），在不同的 Web 开发社区中，都引起了很大的争议，其中包括 Java EE 社区。Ajax 技术通过消除过多的 Web 页面刷新，提高了应用程序的可用性。而且 Ajax 二者通吃的技术，同时利用了客户端和服务器端代码，向 Web 用户呈现了几乎无缝的用户界面。Ajax 被鼓吹成 Web 开发复兴（或称为 Web 2.0）的一个主要推动者。

作为用心的 Java EE 开发人员，您可能已经阅读了许多关于 Ajax 的 how-to 文章，并对它会给应用程序带来的可能改进而兴奋。但是 Ajax 基于异步通信的模式要怎样才适合您的 Java EE 应用程序呢？这篇文章通过研究在 Java EE 应用程序的设计、开发、执行和测试各阶段引入 Ajax 会带来的影响，将帮助您回答这个问题。我的目的不是不鼓励使用 Ajax 或者暗示您可能遇到的问题是 Ajax 技术固有的问题。相反，我是为了帮助您规划并减轻这些问题，好让您更有效而顺利地利用 Ajax。

解决设计缺陷

相当一段时间以来，Java 社区一直在努力把好的设计模式应用到与 Web 有关的应用程序开发上。其中使用最广泛的一个模式就是模型-视图-控制器（MVC）。一些开放源码框架，例如 Apache Struts，就基于这个设计模式/架构（请参阅 参考资料）。MVC 的众多优势包括：问题隔离 和减少冗余代码。

问题隔离在整个应用程序架构中使用预先协商好的接口，从而让应用程序开发项目中的每个开发人员都专注于自己特定的角色。例如，模型层的开发人员侧重于 JDBC、企业 JavaBean（EJB）组件或者与底层数据持久技术接口的 Java 类这一类的技术。视图层开发人员侧重于 Java 服务器页面（JSP）技术、标记库和其他与表示有关的技术。控制器层隔离及协调模型和视图，把进入的请求路由到后端持久性调用，同时维护问题的清晰隔离。图 1 演示了 MVC 架构：

图 1. MVC 架构

把 Ajax 引入 Java EE Web 应用程序对于问题的隔离（以及开发人员角色的隔离）是有意义的。在某些情况下，Ajax 会把大量 JavaScript 代码带回视图层（JSP）页面。表 1 描述了没有 Ajax 的视图层，还指出了需要的代码（假设控制器层由 servlet 实现，视图层由 JSP 技术实现。（在下一节 处理开发困境 我将解释同步和异步请求的区别。）

表 1. 没有 Ajax 的 MVC：与典型的视图层序列有关的代码数量

对比表 1 和表 2，表 2 描述了有 Ajax 的 MVC 视图层，同样假设控制层由 servlet 实现，视图层由 JSP 技术实现。

表 2. 有 Ajax 的 MVC：与典型的视图层序列有关的代码数量

可以看出，由于使用了 Ajax，视图层的脚本编写量增加了，从而导致三个明显缺陷：

• JSP 要求大量的 JavaScript 代码。
• 这个设计破坏了角色问题的隔离。
• 设计重新带回了单一 JSP（模式 1 方法：一堆 HTML、CSS 代码、图片和脚本代码），这是一种反模式，极难阅读和维护（请参阅 参考资料）。

有几个选项可以避免或者至少减轻这些设计缺陷：

• 设计时脑子里记着重用：不幸的是，编写特定于 Ajax 支持的代码通常很难避免。请计划和设计脚本代码，以便能够最大限度地重用它。
  
  
• 采用客户端 MVC 方法：可以合并使用客户端 MVC 方法，详见 Dave Crane 等编写的 Ajax in Action（请参阅 参考资料）。这种方法可以促进问题的隔离，但是增加了复杂性，所以使用的时候要仔细考虑。
  
  
• 使用 Ajax 框架：存在多个开放源码的 Ajax 框架，例如 Direct Web Remoting （DWR）（请参阅 参考资料），它们做了很好的工作，可以用最少的编码，就把 Ajax 模式集成到 Java EE 应用程序。
  
  
• 重新评估设计的正确性：实际上，Ajax 为 Web 应用程序提供了桌面应用程序的属性。如果一个 Web 应用程序中大多数客户端交互都利用 Ajax，那么这个应用程序可能最好设计成桌面应用程序。

处理开发困境

在 Java Web 开发中使用 Ajax 时，重要的是完整理解同步 和异步 通信模型的区别（请参阅 参考资料）。对异步通信模型支持的缺乏，会对客户端开发、与 Web 框架的集成、标记库的使用、IDE 的使用以及线程的行为有影响。

在同步请求/响应通信模型中，总是浏览器（与 Web 服务器、应用服务器或 Web 应用程序相对）发起请求（通过 Web 用户）。接着，Web 服务器、应用服务器或 Web 应用程序响应进入的请求。在处理同步请求/响应对期间，用户不能继续使用浏览器。

图 2 中的序列图演示了传统 Web 应用程序的同步通信模型。请注意在服务器的生命线上，来自客户机的数据提交和服务器端的处理是紧密耦合的。

图 2. 同步通信序列

在异步请求/响应通信模型中，浏览器（通过 Web 用户）到 Web 服务器、应用服务器或 Web 应用程序的通信（以及反过来）是解耦的。在异步请求/响应对的处理中，Web 用户在当前异步请求被处理时还可以继续使用浏览器。一旦异步请求处理完成，异步响应就被通信（从 Web 服务器、应用服务器或 Web 应用程序）回客户机页面。典型情况下，在这个过程中，调用对 Web 用户没有影响；他们不需要等候响应。

图 3 的序列图演示了异步通信模型。请注意第一个 dataSubmission （由服务器端处理）和第一个返回的 dataSubmission，两个都用红圈圈上了。这些序列是解耦的。这个图示还强调了一个重要方面（后面将详细介绍，请参阅 线程问题）：在这个模型中，可以发生多个提交（线程）。

图 3. 异步通信序列

客户端影响

在向 Web 应用程序引入 Ajax 时，开发团队需要注意几个风险，主要与生成的 HTML 页面及其与浏览器的交互方式有关。这些问题在 Chris Laffra 两部分的 Considering Ajax 系列中有详细介绍（请参阅 参考资料）。有些需要记住的要点是：

• 可能没打开脚本功能：出于各种原因，在许多用户的浏览器上禁止了 JavaScript 支持。
  
  
• 跨浏览器支持增加了代码需求：支持多种浏览器和多个浏览器版本的应用程序，要求的脚本代码可能会增多，因为浏览器解释 DOM 对象的方式有细微的差异（所以操作这些元素的 JavaScript 代码也有差异）。
  
  
• JavaScript 不安全：在多数浏览器中，可以选择查看源代码选项，查看到与 HTML 页面关联的 JavaScript 源代码。在使用 Ajax 模式时，要确保脚本代码中实现的逻辑不是敏感逻辑。

与 Web 框架集成

试着把 Ajax 开发与所选的 Java EE Web 框架集成，是很自然的。但是有些 Java EE Web 框架对异步通信模型提供直接可以使用的支持。要体会这个事实的意义，需要理解 servlet 处理同步和异步通信的方式。图 4 显示了处理同步请求的传统 servlet 序列：

图 4. 处理同步请求的 Servlet 序列

图 4 对于 Java EE Web 开发人员来说应当相当熟悉。来自浏览器的请求先由控制器 servlet 的 service() 处理。servlet 可以从 HttpRequest 检索到需要的任何值（以参数的形式或者以属性的形式）。一旦控制器处理完成，结果就发送回 HttpRequest （或 HttpSession），而 RequestDispatcher 则把控制转发（或包含）回页面。

图 5 显示了处理异步请求的 servlet 序列：

图 5. 处理异步请求的 Servlet 序列

图 5 中的序列与同步序列略有不同。来自浏览器的请求先由控制器 servlet 的 service() 处理。servlet 可以从 HttpRequest 检索到需要的任何值（以参数的形式或者以属性的形式）。一旦控制器处理完成，HttpServletResponse 的内容类型必须设置成 XML。而且，控制器逻辑的结果要用 PrintWriter 写入。这时，RequestDispatcher 的使用被越过。

这个（异步序列）恰恰是多数 Java EE Web 框架不支持的，从而造成与 Ajax 的集成非常困难。不支持异步通信模型的 Portlet 和 JavaServer Faces （JSF）框架面临着同样的问题。

克服这个问题也有一些选项：

• 与 Web 框架并存： 不必等待内置的 Ajax 支持或者在所选的框架中强行实现 Ajax 支持，可以使用独立的 servlet 来处理全部异步请求。DWR 就使用了这种方式。这种方式的不足在于 Ajax 请求不能方便地利用框架的特性。
  
  
• 与 Web 框架集成：通过使用免费的扩展或编写定制的扩展，可以设计出与所选 Web 框架集成的途径。
  
  
• 迁移到支持 Ajax 的框架：更新的框架开始支持异步通信模型。其中一个是 Apache Shale（请参阅 参考资料）。

使用标记库

大量使用标记库（taglib）在 Java 的 Web 应用程序开发中是很普遍的。像许多 Java EE Web 框架一样，有些标记库现在也不支持异步通信模型，没有把通过 XMLHttpRequest 提交的数据转换成 HttpServletRequest （以及反过来）的途径。实际上，不支持异步通信的标记库，在 Ajax XMLHttpRequest 调用期间不工作。可用的选项有：

• 放弃使用不支持异步模型的标记库：把现在由标记库生成的代码迁移到 HTML/JavaScript 代码。（如果 Web 应用程序高度依赖标记库，这种方式最终会造成视图层页面尺寸的增大。）
  
  
• 解决问题：使用已经解决了这个问题的 Ajax 框架。示例之一就是 DWR（请参阅 ExecutionContext.forwardToString()）。 在这种情况下，可以继续使用以前一直使用的标记库。
  
  
• 使用支持 Ajax 的标记库：使用支持异步模型的标记库，例如 Ajax JSP 标记库（AjaxTags）（请参阅 参考资料）。

用 IDE 进行开发与调试

有许多 JavaScript 调试工具可以帮助开发人员开发 JavaScript 解决方案。但是，传统的 Java 开发环境不允许检查 XMLHTTPRequest 和与 Ajax 相关的其他东西的值。

一个解决方案是利用 AJAX Toolkit Framework（ATF）（请参阅 参考资料）。ATF 是个 Eclipse 插件，带有增强的 JavaScript 编辑特性，例如编辑时语法检查，内嵌的 Mozilla Web 浏览器，内嵌的 DOM 浏览器，内嵌的 JavaScript 调试器。ATF 还包含 Personality Builder 功能，这个功能可以帮助任何 Ajax 运行时框架构建 IDE 特性，从而加入到 ATF 支持的运行时环境集中。

线程问题

在典型的同步 Web 应用程序中，有些领域对按钮或链接点击要求更长一点的处理时间。没有耐心和没经验的 Web 用户通常会不止一次地点击按钮或链接，以为可以帮助加快处理速度，从而引发多重表单提交。其他时候，用户认为需要双击（就像桌面应用程序那样）。Web 应用程序中的多重表单提交在某些情况下是无害的。而在其他情况下，副作用可能造成严重的线程问题或争用情况（此时多个线程竞争执行一个代码块）。例如，在银行应用程序中多次点击转帐按钮，可能造成不希望的多次转帐。

既支持同步通信模型又支持异步通信模型的 Web 应用程序会发现，如果它的功能没有正确分析和规划，那么自己就处在了相似的困境中。支持两种通信模型的应用程序在某个页面上可能混合了服务器端调用（即，或者同步，或者异步，或者混合了同步和异步）。就像在多重点击场景中一样，异步调用可能处理得慢些。如果应用程序不做预防，用户可能会在异步线程正在处理时又调用了一个同步调用，因为页面没有刷新，所以无法阻止页面上的进一步活动。结果是两个线程并发处理。虽然不是由 Web 页面上的同一按钮或链接引发，这类情况还是会造成服务器端的线程问题（与多重点击问题类似）。

例如，以图 6 所示的银行应用程序的转账页面为例：

图 6. 转帐示例

对于这个示例，用红色表示的转账按钮引发一个 Ajax 调用。退出链接（黄色）引发同步调用。如果不耐烦或没有经验的用户点击了红色按钮之后接着又点击黄色链接（假设两个链接在代码中有共同的路径），就会发生争用情况。

一般来说，有两种方式可以避免这类情况发生。第一种方式是客户端解决方案。一旦点击了一个链接或按钮，就用 JavaScript 确保禁止后续的页面提交，直到当前线程执行完成。第二个解决方案是允许多线程提交，但是依赖于服务器端代码中的同步来避免争用情况。如果引入同步来解决这个问题，请记住 Java EE Web 组件（servlet、portlet、JSF 等）是多线程的。要当心大段代码的同步（特别是与请求/响应生命周期处理有关的代码）。在效果上，同步的误用，会把应用程序变成单线程应用程序，从而降低吞吐率。

克服性能缺陷

使用 Ajax 还有可能影响基于 Java EE Web 的应用程序的性能。允许每个请求上有额外线程的可能性，可能会影响两个资源。

首先，servlet 容器的线程池 可能受到影响。线程池指定 Web 容器中允许并发运行的线程的最大数量。每个客户机请求需要一个线程。但是，一个客户机请求不一定等于一个用户请求。浏览器可能为一个用户请求要求多个客户机请求。例如，提交表单的一个用户可能要求多个客户机请求（其中包含提交表单的值、检索 GIF 文件、检索 JavaScript 文件、检索 CSS 文件）。如果允许并发地提交同步和异步请求，就意味着每个用户请求至少要支持多出一个的线程消耗（用于 Ajax 请求）。虽然为每个用户请求多增加一个线程的可能性看起来不多，但是当应用程序处在负载之下时，影响就明显了（这时每个用户请求多出的一个额外线程乘上平均用户数量）。显示，这种情况有可能影响 servlet 容器的性能。

另一个可能受影响的资源是数据库连接池。典型的 Java EE Web 应用程序支持一个用户请求的两类序列：浅（shallow）请求和 深（deep）请求。浅请求是执行服务器端代码但是不访问持久性存储（例如数据库）就完成请求的 Web 页面发出的请求。深请求是执行服务器端代码并访问持久性存储才能完成请求的 Web 页面发出的请求。

在深请求序列中（假设需要数据库连接），数据库连接池的这些方面可能会由于允许多个线程而受到影响：

• 等待连接的线程的平均数量
• 以毫秒为单位的连接的平均等候时间
• 连接被使用的平均时间

所以，可能需要提高连接池的平均大小或连接数量。

对付测试

Java 开发人员一直在不断地努力为 Java SE 和 Java EE 代码提供单元测试工具。由于 Ajax 的引入造成浏览器内的 JavaScript 增多，对可靠的 JavaScript 单元测试框架也提出了要求。现在可用的框架有 JsUnit、Selenium 和 HttpUnit（请参阅 参考资料）。

这些框架提供了为 JavaScript 函数开发单元测试的工具，可以操纵 Web 页面上的 DOM 元素。它们允许把单元测试组织成测试套件。Selenium 的浏览器兼容性测试特性允许在不同的浏览器和操作系统上测试 JavaScript 函数。它利用 JavaScript 和 Iframe 在浏览器中嵌入了测试自动引擎。这项技术应当可以在任何支持 JavaScript 的浏览器中工作，对于支持多个浏览器和浏览器版本的应用程序来说特别有用。Selenium 和 JsUnit 都支持持续集成：可以把 JavaScript 单元测试和测试套件集成到自动构建过程。

结束语

把 Ajax —— 就像其他技术或模式一样 —— 引入 Java EE 应用程序，也有它的优势和不足。本文提供了把 Ajax 集成到 Java EE Web 应用程序的概述。Ajax 的异步通信模型与传统 Java EE Web 应用程序内置就支持的同步模型有很大不同。为了避免盲目，请确保在采用 Ajax 之前对潜在的问题领域有全面的事前规划。

Java EE 框架对 Ajax 的支持和工具在不断改进。未来有望会有框架自带的 Ajax 支持来降低集成的复杂性。基于 JSF 的 Apache Shale 和基于 servlet 的 DWR 是两个希望您保持关注的框架。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1155119

 这里需要注意的就是把<client-jndi>的注释去掉，并修改provider-url为服务器实际地址，此处为例为192.168.2.240:2908，注意2908是此Server提供的JNDI服务端口，因为JMS服务是绑定到server的JNDI服务上的，客户端需要查询JNDI。再修改run-resources.xml添加测试的JMS队列(也可以通过JRun控制台添加)

<jms-destination>                
    <jndi-name>jms/queue/testQueue</jndi-name>                    
    <destination-name>testQueue</destination-name>
    <destination-type>javax.jms.Queue</destination-type>    
</jms-destination>

再添加QueueConnectionFactory

<jms-connection-factory>
    <factory-name>QueueConnectionFactory</factory-name>
    <jndi-name>jms/jndi-QueueConnectionFactory</jndi-name>
    <type>javax.jms.QueueConnectionFactory</type>
    <transport>RMI</transport>
    <username>guest</username>
    <password>guest</password>
</jms-connection-factory>

上面transport是指传输消息所用的协议，RMI：java远程方法调用，TCP：TCP/IP协议，Intra-VM：只在本虚拟机传输消息，用户名/密码是服务验证客户端调用时使用。服务器端JMS的设置基本完成了，还需要设置jrun的安全策略。

修改{JRun-Home}/server/security.properties,有两项jrun.subnet.restriction：子网掩码，jrun.trusted.hosts：信任主机的IP，否则远程调用可能会被拒绝。再到{JRun-Home}/bin下修改jvm.config,添加java虚拟机启动参数-Djava.rmi.server.hostname=192.168.2.240，其中192.168.2.240为主机的实际IP，不要写localhost，否则RMI的远程调用会被拒绝。也可以写一个新配置文件new-server.conf，启动时用命令jrun –config new-server.conf –start XXX指定配置文件。服务器端的设置完成。当然如果客户端程序也在此JRun中运行，可以忽略这些参数的修改和设置。

    客户端的代码基本与调用其他JMS服务类似。注意要取得{JRun-Home}/lib/jrun.jar并放入到客户端环境的classpath中，代码示例

public class JmsQueueTest...{        
    private Context context = null;        
    private QueueConnection connection  = null;        
    private QueueSession session = null;        
    private Queue queue = null;        
    private QueueSender sender  = null;        
    private String connectionFactory;        
    private String queueJndiName;        
    public void setConnectionFactory(String connectionFactory)...{
        this.connectionFactory = connectionFactory;
    }        
    public void setQueueJndiName(String queueJndiName)...{
        this.queueJndiName = queueJndiName;        
    }        
    /** *//**         
    * 初始化JMS队列         
    * @param ctxFactory         
    * @param url         
    * @param user         
    * @param pwd         
    * @throws Exception         
    */        
    public void init(String ctxFactory,String url,String user,String pwd)throws Exception ...{
        Properties p = new Properties();
        p.put(Context.INITIAL_CONTEXT_FACTORY,ctxFactory);
        p.put(Context.PROVIDER_URL,url);
        p.put(Context.SECURITY_PRINCIPAL,user);
        p.put(Context.SECURITY_CREDENTIALS,pwd);
        context = new InitialContext(p);
        QueueConnectionFactory factory = (QueueConnectionFactory)context.lookup(connectionFactory);
        connection = factory.createQueueConnection();
        queue = (Queue)context.lookup(queueJndiName);
        session = connection.createQueueSession(false,Session.AUTO_ACKNOWLEDGE);
        sender = session.createSender(queue);
        connection.start();        
    }        
    /** *//**         
    * 发送文本消息         
    * @param txt         
    * @throws Exception         
    */        
    public void send(String txt)throws Exception ...{
        TextMessage tmsg = session.createTextMessage();        
        tmsg.setText(txt); sender.send(tmsg);        
    }        
    /** *//**         
    * 查询队列中保存的消息         
    * @throws Exception         
    */        
    public void browser()throws Exception...{
        QueueBrowser browser = session.createBrowser(queue);
        Enumeration enum = browser.getEnumeration();System.out.println("QueueBrowser");
        while (enum.hasMoreElements())...{        
            System.out.println(enum.nextElement());
        }
        browser.close();        
    }        
    /** *//**         
    * 接收消息         
    * @throws Exception         
    */        
    public void receive()throws Exception...{
        QueueReceiver receiver = session.createReceiver(queue);
        while(true)...{
            TextMessage message = (TextMessage)receiver.receiveNoWait();        
            if(message == null)break;        
            System.out.println("receive message:" + message.getText());
        }
        receiver.close();        
    }        
    public void close()throws Exception...{
        sender.close();
        session.close();
        connection.close();
        context.close();        
    }
    public static void main(String[] args)throws Exception ...{
        String ctxFactory = "jrun.naming.JRunContextFactory";
        String url = "192.168.2.240:2908";
        String user = "guest";
        String pwd = "guest";
        String connectionFactoryJndi = "jms/jndi-QueueConnectionFactory";
        String queueJndi = "jms/queue/testQueue";
        JmsQueueTest test = new JmsQueueTest();
        test.setConnectionFactory(connectionFactoryJndi);
        test.setQueueJndiName(queueJndi);
        test.init(ctxFactory,url,user,pwd);
        test.send("java共舞JMS消息");
        test.browser();
        test.receive();
        test.close();        
    }

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1151182

Uche Ogbuji (uche@ogbuji.net), 首席顾问, Fourthougth, Inc.

2006 年 7 月 31 日

拥有大量预算作为后盾的 Web 设计人员可以获得任何所需的资源，从而可以把他们的想像力付诸于 Web 体验。他们可以聘请专业摄像师来制作引人注目的照片；可以请最好的 HTML 和 CSS 专家来创建适用于多种浏览器的复杂布局；可以指导图形艺术家根据企业服装来创作华丽的装饰物；可以聘请专业文案人员起草迷人的散文。最大的好处是，他们能雇佣大量测试用户和关注小组来确保网站吸引人、便于使用并能按照预期进行工作。

但是，并不是所有的 Web 设计人员都这样幸运！不幸的是，有些设计人员必须用很少的钱来创建网站，并且对 Web 体验的预期并不见得很低。在这种情况下，您必须寻求一切可以获得的帮助。多半来说，Web 开发人员和设计人员在与同事共享知识和成就方面是非常慷慨的。当您共享时，同事们通常会努力地纠正并增强您的作品，使其变得更加精致、bug 更少，并会提供您自己的关注小组和质量保证。这意味着您可以找到大量免费材料。如果您知道去哪里找的话，就可以填补低预算 Web 开发运营情况下的一些漏洞。在本文中，我将介绍各类免费的 Web 资源，以及对一些貌似免费，实其不然的 Web 资源的警告。

创造性的公用

首先介绍 Creative Commons(CC)，它本身不是免费资源的来源，而是提供免费资源的人们所使用的许可证的来源。用他们自己的话说：CC 是一个非营利性组织，为创造性作品提供灵活的版权许可。您可以选择一个 CC 许可，以允许所有者要求您在使用所有者的作品或修改他们的作品时给予他们荣誉（归属条款）；可以限制自己作品仅用于非营利性组织；可以要求任何对您作品所作的更改必须在与原条款相同的条款下共享（类似共享的条款）。还有其他条款，您可以组合这些条款。例如，一个常见的 CC 许可是Attribution Share Alike 许可。

CC 已取得了巨大成功 —— 来自 CC 许可的作品主体十分庞大，并且每天都在扩大。文学、图像、音乐等作品都可以在 CC 许可下提供。只要满足限制，您可以自由地在网站上使用任何这些作品。要了解如何找到 Web 设计的任何免费产品，第一步是了解如何搜索在 CC 许可下提供的材料。您可以使用 CC 搜索引擎页面直接获得来源，这允许您利用搜索引擎（如 Google 和 Flickr）和免费资源收集（如 Flick 和 DMusic) 的专业搜索功能。

样式元素

好的样式表是好网站的骨架 —— 尤其是层叠样式表 (CSS)。不幸的是，浏览器中多变的支持意味着很难开发好的样式表。依靠免费样式表，至少是样式元素的免费模块，您可以省去大量精力和测试工作。许多站点提供 CSS 说明和示例，但我的关注点是我找到的站点，大多数都有 CSS 材料，您可以用于快速地组装成自己的站点。有一个由顶级 Web 专业人士开办的以期刊形式出现的站点：A List Apart，着重于 Code 和 Design 主题。CSS Intensivstation Templates 专注于几个用于结构化站点的主要的布局样式。

最有名的 CSS 交换地是 CSS Zen Garden，但您在使用此网站时必须格外小心。CSS Zen Garden 旨在展示 CSS 的强大功能。CSS 是分离内容和形式的好方法。但起初许多 Web 开发人员回避 CSS，因为他们认为如果不用传统的 HTML 技巧（如布局表格和隐藏图像），就创建不出同样令人难忘的效果。CSS Zen Garden 通过漂亮的样式证明这一认识是错误的。其中有一个单独且共享的内容片段，Web 设计人员创建了页面来以某种独特方式显示这些内容。他们使用巧妙的布局、迷人的图像和颜色，通常创作出某种主题，如大海或博物馆风格的主题。CSS Zen Garden 不能作为模板的集合。您可以在大多数 CSS 贡献中显示的警告中看到以下说明：

此设计不是模板。未经设计者的书面许可，不得复制。但是，可以随意研究 CSS 并在其他地方使用学到的技术。

此外，许多贡献者使用非免费的图像。站点维护人员请求贡献者在非商业 Creative Commons 许可下提供他们的 CSS（参见 参考资料），所以复制 CSS 通常是安全的做法，但要确保检查贡献者 CSS 文件的开头部分。

图像

专业网站会使用各种图像，从照片到艺术家的绘画到图标和符号，等等。一些站点提供免版税的图像。有一个项目值得您关注，即 Open Clip Art Library，它是一个贡献的、可下载的剪贴画的集合。图像的范围包括从小而简单的图像到大而复杂的图像。大多数图像是可缩放矢量图形 (SVG) 格式，它是一种开放的、基于 XML 的格式。SVG 增强了对浏览器的支持，但它尚不通用，所以 Open Clip Art Library 包括每个图像的 PNG 版本。您可以浏览或搜索网站上的图像，但可能只想下载一个发行版，所以可以脱机浏览。图形的质量类似于您在商店购买的许多剪贴画集合中找到的图像的质量。当我需要符号、图标和其他资源（如高亮显示）时，通常会浏览 Open Clip Art Library，但 MaxPower Free Icons 是一组很好的到免费图标集合的链接。说到商店里的剪贴画集合，即使已经购买，仍有许多限制。一些剪贴画需要商业使用版税。如果购买此类集合，请确保检查 End User License Agreements。

当需要照片时，我经常会访问前面提到过的 Flickr 的 CC 照片库，但是我通常是通过 Yotophoto 到达那里的，Yotophoto 是从 CC 变体到 Public Domain 的一个免费许可照片的搜索聚合地。我最喜欢的一个资源站点是 stock.xchng。此站点包括大量极高品质的照片，并有一个非常好用的搜索引擎。不是所有的照片都是免版税的，但大多数是！您甚至可以查看是否有照片的模型发行，这是决定使用包含人像的照片时要考虑的一个重要因素。一个规模较小、尚不精致，但仍十分有用的站点是 Open Photo，它只包含经 CC 许可的照片。我还使用 MorgueFile，这个站点类似于 stock.xchng 站点，具有搜索和丰富元数据方面的类似优点。MorgueFile 上的所有图像受到专门许可（不基于 CC）的约束，但免除了个人或商业作品的版税。我喜欢 MorgueFile FAQ 中针对他们为什么提供免费图像的解答： 此网站遵循传统的万维网。它致力于倡导自由观点和交换。

设计工具

一些 Web 设计人员和公司提供联机工具来帮助其他用户并提高他们自己的社区形象。最常用的是颜色方案工具，它允许您为自己的站点选择富有美感的、令人愉快的一组颜色。在搭配颜色方面，我的确没有世上最好的眼力，所以我感谢诸如 Wellstyled.com 的 Color Scheme Generator 这样的网站。另一个提供更多有关如何组装方案的站点是 SiteProCentral.com's HTML Color Code Combination Chooser。

最流行的 Web 浏览器也是最奇怪的浏览器。多年来，Web 设计人员不得不应对 Microsoft Internet Explorer 5 和 6，包括 Macintosh 和 Windows 版本之间的差异。Microsoft 正在开发 7 版浏览器，他们承诺新版本具有更好的标准兼容性，但是另一方面 Dean Edwards 已经开发了 JavaScript 解决方案。引用该网站的话：

[Dean Edwards'] IE7 是一个 JavaScript 库，使 IE 的行为像标准兼容的浏览器。它修复了许多 CSS 问题并使透明 PNG 在 IE5 和 IE6 下正常工作。

当您设计网站时，记住 Macintosh 用户是十分重要的。如果购买测试用的 Mac 机不是一个选择的话，您应感谢 Daniel Vine，因为他创建了 iCapture。您可以在此站点指定 URL、搜索看上去像 Mac 机上的 Safari Web 浏览器显示的 PNG 图像。Edwards 还提供 ieCapture，允许查看您的站点在 Macintosh IE7 beta 中的显示效果。

完全 Web 布局和模板

有时即使获得以上所有帮助，我还是不能创建引人注目的网页。我可能想要一切，幸运的是可以在一些网站中找到免费的完整页面布局，包含 HTML（经常是 XHTML）模板、图形、样式表、高亮显示等。Open Web Design 有近 2000 个各种品质的完整模板。该网站有一个评级系统，有时会进行设计人员竞赛来扩大其收集量。Open Source Web Design 是一个具有类似规模的网站。 

结束语

在本文中，您了解了许多资源，可以从中获得免费资料和工具以改进您的网站。即使您有预算来得到顶级的专业帮助，如果熟悉 Web 设计的最新技术，还是会很有帮助的。所幸的是，最新技术几乎不被隐藏或无法访问，它们总是免费的。如果有机会，我还鼓励您进行共享，比如为我提到的网站做贡献。毕竟，Web 美学的浪潮会水涨船高

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1009638