posts - 120,  comments - 19,  trackbacks - 0
  2006年4月5日
北京英语角
北京英语角(BeiJing)www.52en.com
=================================
北大英语角：每周六晚7:00 俄文楼前空地
清华英语角：每周三晚7:00-10:00 西阶（west of Great Hall）
人大英语角：每周五晚 人大东门花园，老外多，质量不错
北外英语角：每周五晚6:30-8:30外研社后花园
朝阳文化馆：每周六下午3：00-5:00 门票6元地点在小庄，收费，但质量好
posted @ 2007-04-25 09:29 阿成 阅读(2113) | 评论 (6) | 编辑 收藏
男孩如何追女孩
1.未到火候，千万别说。有些男孩才跟人家约过几次，就提出要建立“更进一步”的关系，这十有八九要坏汤。爱情上的事妙就妙在一切尽在不言中。说清楚了，话挑明了，反而不美。本来人家肯单独出来跟你说话，这说明女孩对你不无好感。但是这种好感有时连她们自己都说不清，你却急于挑明，破坏了这种朦胧美，那就别怪人家敬而远之以致退避三舍了。看看周围那些还没开始就夭折的爱情，许多都是由男孩没有掌握好火候造成的。

　　2.收起拳头是为了更好的出击。被女孩拒绝了怎么办呢？有人说应该穷追猛打、坚持不懈。其实不然。除非你是一个啥也不在乎的人，否则你很难承受女孩的白眼和同伴们嘲弄的目光。倒不如偃旗息鼓、暂时撤退。这不仅保护了你的尊严而且还留了条后路，从而为日后反攻创造机会。就让她在人群里闯荡。等她碰得头破血流时，你再去找她，她才能认识到原来你才是最爱她的人。即使实在割舍不下，要去找她，也应注意方式方法。千万别让她觉得你讨厌。而这一点往往是很难做到的。 

　　3.不要太露骨。要学会不声不响地关心她，用你的诚实和善意对待她。只有这样你才能在一大帮围着她呱呱乱叫的男孩当中引起她的注意。记住，只有特别的你才会引起她特别的关注。 

　　4.非请勿入。一个老是往女孩寝室跑的男孩是不会引起女孩太多的好感的。有些学生会干部借口工作常往女生寝室跑，去了后就老赖在那不走，结果给人家带来了诸多不便，效果只会适得其反。产生这种结果的根本原因还是因为太露骨。

　　5.战略上藐视...，战术上重视...。有时你喜爱的女孩会和你有些接触，比如谈谈话、聊聊天、一起工作等等。你最好能以平常的心态看待这些事情，不要背上包袱、患得患失。例如不要太在意她无意中说的话，有些男孩容易自作多情，源出于此。但对每一次这样的机会则应引起足够的重视，例如初次谈话要注意掌握好分寸，最好不要涉及情爱范畴，不妨说说小时候的事。你如果只奔主体那就要糟！女孩非得象警惕狼一样地警惕你。 

　　6.马屁最好少拍。你夸她长得漂亮，如果她真的漂亮，那么你不过是第七百个夸她漂亮的人，而她映象最深的恐怕是第一个这样夸她的人；如果她相貌普通，你这样夸她能产生什么样的结果谁也说不准。要是让她发现你言不由衷，那你就死定了。记住，哄女孩只有在女孩成为你的女朋友之后才能哄，还没追到手就开始哄是没有掌握好火候的表现。 

　　7.少来点大男子主义。有个男孩好不容易请得他倾慕已久的女孩去吃饭，花了他半个月生活费。后来他去付账时发现女孩已经替他付了，他就要还她钱。女孩不愿意。他觉得女孩剥了他的面子，大为光火。女孩气得哭了。本来女孩替他付账这说明她对他有好感，他不思讨好反而发脾气，如此就难怪他要打光棍了。几乎没有一个女孩会对那些不尊重女性的男孩有好感，切记！切记！。 

　　8.团结大多数。几乎每个女孩都有一两个最知心的女友，当其他道路都不通时，她们是你通往胜利的成功之路。你可以通过她们了解女孩到底对你有没有意思，还可以通过她们传达你的意思。这比你直接说要好得多。可千万别忽视这一支生力军，我不止一次地看到男孩通过这个方法大功告成的。 

　　最后要提醒大家的是，爱情从来都没有固定的公式。别人成功的方法也许正是你的败着；别人失败的方法也许恰是你的妙着。我这里只提一点原则性的东西，切不可生搬硬套。如果因此而坏了你的好事切莫来找我。女孩要是不喜欢你，就是玉皇大帝也没有法子。还是古人说的好：不战而屈人之兵，上之上策也。
posted @ 2007-04-23 19:12 阿成 阅读(494) | 评论 (0) | 编辑 收藏
什么是线程局部变量（thread-local variable）？轻松使用线程: 不共享有时是最好的
ThreadLocal 类是悄悄地出现在 Java 平台版本 1.2 中的。虽然支持线程局部变量早就是许多线程工具（例如 Posix pthreads 工具）的一部分，但 Java Threads API 的最初设计却没有这项有用的功能。而且，最初的实现也相当低效。由于这些原因， ThreadLocal 极少受到关注，但对简化线程安全并发程序的开发来说，它却是很方便的。在 轻松使用线程的第 3 部分，Java 软件顾问 Brian Goetz 研究了 ThreadLocal 并提供了一些使用技巧。

参加 Brian 的 多线程 Java 编程讨论论坛以获得您工程中的线程和并发问题的帮助。

编写线程安全类是困难的。它不但要求仔细分析在什么条件可以对变量进行读写，而且要求仔细分析其它类能如何使用某个类。 有时，要在不影响类的功能、易用性或性能的情况下使类成为线程安全的是很困难的。有些类保留从一个方法调用到下一个方法调用的状态信息，要在实践中使这样的类成为线程安全的是困难的。

管理非线程安全类的使用比试图使类成为线程安全的要更容易些。非线程安全类通常可以安全地在多线程程序中使用，只要您能确保一个线程所用的类的实例不被其它线程使用。例如，JDBC Connection 类是非线程安全的 — 两个线程不能在小粒度级上安全地共享一个 Connection — 但如果每个线程都有它自己的 Connection ，那么多个线程就可以同时安全地进行数据库操作。

不使用 ThreadLocal 为每个线程维护一个单独的 JDBC 连接（或任何其它对象）当然是可能的；Thread API 给了我们把对象和线程联系起来所需的所有工具。而 ThreadLocal 则使我们能更容易地把线程和它的每线程（per-thread）数据成功地联系起来。

什么是线程局部变量（thread-local variable）？

线程局部变量高效地为每个使用它的线程提供单独的线程局部变量值的副本。每个线程只能看到与自己相联系的值，而不知道别的线程可能正在使用或修改它们自己的副本。一些编译器（例如 Microsoft Visual C++ 编译器或 IBM XL FORTRAN 编译器）用存储类别修饰符（像 static 或 volatile ）把对线程局部变量的支持集成到了其语言中。Java 编译器对线程局部变量不提供特别的语言支持；相反地，它用 ThreadLocal 类实现这些支持， 核心 Thread 类中有这个类的特别支持。

因为线程局部变量是通过一个类来实现的，而不是作为 Java 语言本身的一部分，所以 Java 语言线程局部变量的使用语法比内建线程局部变量语言的使用语法要笨拙一些。要创建一个线程局部变量，请实例化类 ThreadLocal 的一个对象。 ThreadLocal 类的行为与 java.lang.ref 中的各种 Reference 类的行为很相似； ThreadLocal 类充当存储或检索一个值时的间接句柄。清单 1 显示了 ThreadLocal 接口。


清单 1. ThreadLocal 接口

            public class ThreadLocal {
            public Object get();
            public void set(Object newValue);
            public Object initialValue();
            }

get() 访问器检索变量的当前线程的值； set() 访问器修改当前线程的值。 initialValue() 方法是可选的，如果线程未使用过某个变量，那么您可以用这个方法来设置这个变量的初始值；它允许延迟初始化。用一个示例实现来说明 ThreadLocal 的工作方式是最好的方法。清单 2 显示了 ThreadLocal 的一个实现方式。它不是一个特别好的实现（虽然它与最初实现非常相似），所以很可能性能不佳，但它清楚地说明了 ThreadLocal 的工作方式。


清单 2. ThreadLocal 的糟糕实现

            public class ThreadLocal {
            private Map values = Collections.synchronizedMap(new HashMap());
            public Object get() {
            Thread curThread = Thread.currentThread();
            Object o = values.get(curThread);
            if (o == null && !values.containsKey(curThread)) {
            o = initialValue();
            values.put(curThread, o);
            }
            return o;
            }
            public void set(Object newValue) {
            values.put(Thread.currentThread(), newValue);
            }
            public Object initialValue() {
            return null;
            }
            }

这个实现的性能不会很好，因为每个 get() 和 set() 操作都需要 values 映射表上的同步，而且如果多个线程同时访问同一个 ThreadLocal ，那么将发生争用。此外，这个实现也是不切实际的，因为用 Thread 对象做 values 映射表中的关键字将导致无法在线程退出后对 Thread 进行垃圾回收，而且也无法对死线程的 ThreadLocal 的特定于线程的值进行垃圾回收。





回页首


用 ThreadLocal 实现每线程 Singleton

线程局部变量常被用来描绘有状态“单子”（Singleton） 或线程安全的共享对象，或者是通过把不安全的整个变量封装进 ThreadLocal ，或者是通过把对象的特定于线程的状态封装进 ThreadLocal 。例如，在与数据库有紧密联系的应用程序中，程序的很多方法可能都需要访问数据库。在系统的每个方法中都包含一个 Connection 作为参数是不方便的 — 用“单子”来访问连接可能是一个虽然更粗糙，但却方便得多的技术。然而，多个线程不能安全地共享一个 JDBC Connection 。如清单 3 所示，通过使用“单子”中的 ThreadLocal ，我们就能让我们的程序中的任何类容易地获取每线程 Connection 的一个引用。这样，我们可以认为 ThreadLocal 允许我们创建 每线程单子。


清单 3. 把一个 JDBC 连接存储到一个每线程 Singleton 中

            public class ConnectionDispenser {
            private static class ThreadLocalConnection extends ThreadLocal {
            public Object initialValue() {
            return DriverManager.getConnection(ConfigurationSingleton.getDbUrl());
            }
            }
            private ThreadLocalConnection conn = new ThreadLocalConnection();
            public static Connection getConnection() {
            return (Connection) conn.get();
            }
            }

任何创建的花费比使用的花费相对昂贵些的有状态或非线程安全的对象，例如 JDBC Connection 或正则表达式匹配器，都是可以使用每线程单子（singleton）技术的好地方。当然，在类似这样的地方，您可以使用其它技术，例如用池，来安全地管理共享访问。然而，从可伸缩性角度看，即使是用池也存在一些潜在缺陷。因为池实现必须使用同步，以维护池数据结构的完整性，如果所有线程使用同一个池，那么在有很多线程频繁地对池进行访问的系统中，程序性能将因争用而降低。





回页首


用 ThreadLocal 简化调试日志纪录

其它适合使用 ThreadLocal 但用池却不能成为很好的替代技术的应用程序包括存储或累积每线程上下文信息以备稍后检索之用这样的应用程序。例如，假设您想创建一个用于管理多线程应用程序调试信息的工具。您可以用如清单 4 所示的 DebugLogger 类作为线程局部容器来累积调试信息。在一个工作单元的开头，您清空容器，而当一个错误出现时，您查询该容器以检索这个工作单元迄今为止生成的所有调试信息。


清单 4. 用 ThreadLocal 管理每线程调试日志

            public class DebugLogger {
            private static class ThreadLocalList extends ThreadLocal {
            public Object initialValue() {
            return new ArrayList();
            }
            public List getList() {
            return (List) super.get();
            }
            }
            private ThreadLocalList list = new ThreadLocalList();
            private static String[] stringArray = new String[0];
            public void clear() {
            list.getList().clear();
            }
            public void put(String text) {
            list.getList().add(text);
            }
            public String[] get() {
            return list.getList().toArray(stringArray);
            }
            }

在您的代码中，您可以调用 DebugLogger.put() 来保存您的程序正在做什么的信息，而且，稍后如果有必要（例如发生了一个错误），您能够容易地检索与某个特定线程相关的调试信息。 与简单地把所有信息转储到一个日志文件，然后努力找出哪个日志记录来自哪个线程（还要担心线程争用日志纪录对象）相比，这种技术简便得多，也有效得多。

ThreadLocal 在基于 servlet 的应用程序或工作单元是一个整体请求的任何多线程应用程序服务器中也是很有用的，因为在处理请求的整个过程中将要用到单个线程。您可以通过前面讲述的每线程单子技术用 ThreadLocal 变量来存储各种每请求（per-request）上下文信息。





回页首


ThreadLocal 的线程安全性稍差的堂兄弟，InheritableThreadLocal

ThreadLocal 类有一个亲戚，InheritableThreadLocal，它以相似的方式工作，但适用于种类完全不同的应用程序。创建一个线程时如果保存了所有 InheritableThreadLocal 对象的值，那么这些值也将自动传递给子线程。如果一个子线程调用 InheritableThreadLocal 的 get() ，那么它将与它的父线程看到同一个对象。为保护线程安全性，您应该只对不可变对象（一旦创建，其状态就永远不会被改变的对象）使用 InheritableThreadLocal ，因为对象被多个线程共享。 InheritableThreadLocal 很合适用于把数据从父线程传到子线程，例如用户标识（user id）或事务标识（transaction id），但不能是有状态对象，例如 JDBC Connection 。





回页首


ThreadLocal 的性能

虽然线程局部变量早已赫赫有名并被包括 Posix pthreads 规范在内的很多线程框架支持，但最初的 Java 线程设计中却省略了它，只是在 Java 平台的版本 1.2 中才添加上去。在很多方面， ThreadLocal 仍在发展之中；在版本 1.3 中它被重写，版本 1.4 中又重写了一次，两次都专门是为了性能问题。

在 JDK 1.2 中， ThreadLocal 的实现方式与清单 2 中的方式非常相似，除了用同步 WeakHashMap 代替 HashMap 来存储 values 之外。（以一些额外的性能开销为代价，使用 WeakHashMap 解决了无法对 Thread 对象进行垃圾回收的问题。）不用说， ThreadLocal 的性能是相当差的。

Java 平台版本 1.3 提供的 ThreadLocal 版本已经尽量更好了；它不使用任何同步，从而不存在可伸缩性问题，而且它也不使用弱引用。相反地，人们通过给 Thread 添加一个实例变量（该变量用于保存当前线程的从线程局部变量到它的值的映射的 HashMap ）来修改 Thread 类以支持 ThreadLocal 。因为检索或设置一个线程局部变量的过程不涉及对可能被另一个线程读写的数据的读写操作，所以您可以不用任何同步就实现 ThreadLocal.get() 和 set() 。而且，因为每线程值的引用被存储在自已的 Thread 对象中，所以当对 Thread 进行垃圾回收时，也能对该 Thread 的每线程值进行垃圾回收。

不幸的是，即使有了这些改进，Java 1.3 中的 ThreadLocal 的性能仍然出奇地慢。据我的粗略测量，在双处理器 Linux 系统上的 Sun 1.3 JDK 中进行 ThreadLocal.get() 操作，所耗费的时间大约是无争用同步的两倍。性能这么差的原因是 Thread.currentThread() 方法的花费非常大，占了 ThreadLocal.get() 运行时间的三分之二还多。虽然有这些缺点，JDK 1.3 ThreadLocal.get() 仍然比争用同步快得多，所以如果在任何存在严重争用的地方（可能是有非常多的线程，或者同步块被频繁地执行，或者同步块很大）， ThreadLocal 可能仍然要高效得多。

在 Java 平台的最新版本，即版本 1.4b2 中， ThreadLocal 和 Thread.currentThread() 的性能都有了很大提高。有了这些提高， ThreadLocal 应该比其它技术，如用池，更快。由于它比其它技术更简单，也更不易出错，人们最终将发现它是避免线程间出现不希望的交互的有效途径。





回页首


ThreadLocal 的好处

ThreadLocal 能带来很多好处。它常常是把有状态类描绘成线程安全的，或者封装非线程安全类以使它们能够在多线程环境中安全地使用的最容易的方式。使用 ThreadLocal 使我们可以绕过为实现线程安全而对何时需要同步进行判断的复杂过程，而且因为它不需要任何同步，所以也改善了可伸缩性。除简单之外，用 ThreadLocal 存储每线程单子或每线程上下文信息在归档方面还有一个颇有价值好处 — 通过使用 ThreadLocal ，存储在 ThreadLocal 中的对象都是 不被线程共享的是清晰的，从而简化了判断一个类是否线程安全的工作。

我希望您从这个系列中得到了乐趣，也学到了知识，我也鼓励您到我的 讨论论坛中来深入研究多线程问题。

posted @ 2007-04-09 20:52 阿成 阅读(2406) | 评论 (1) | 编辑 收藏
Web服务器开发环境下的线程安全问题

Servlet是在多线程环境下的。即可能有多个请求发给一个servelt实例，每个请求是一个线程。
struts下的action也类似，同样在多线程环境下。可以参考struts user guide: http://struts.apache.org/struts-action/userGuide/building_controller.html 中的Action Class Design Guidelines一节: Write code for a multi-threaded environment - Our controller servlet creates only one instance of your Action class, and uses this one instance to service all requests. Thus, you need to write thread-safe Action classes. Follow the same guidelines you would use to write thread-safe Servlets.
译:为多线程环境编写代码。我们的controller servlet指挥创建你的Action 类的一个实例，用此实例来服务所有的请求。因此，你必须编写线程安全的Action类。遵循与写线程安全的servlet同样的方针。

1.什么是线程安全的代码
在多线程环境下能正确执行的代码就是线程安全的。
安全的意思是能正确执行，否则后果是程序执行错误，可能出现各种异常情况。

2.如何编写线程安全的代码
很多书籍里都详细讲解了如何这方面的问题，他们主要讲解的是如何同步线程对共享资源的使用的问题。主要是对synchronized关键字的各种用法，以及锁的概念。
Java1.5中也提供了如读写锁这类的工具类。这些都需要较高的技巧，而且相对难于调试。

但是，线程同步是不得以的方法,是比较复杂的,而且会带来性能的损失。等效的代码中，不需要同步在编写容易度和性能上会更好些。
我这里强调的是什么代码是始终为线程安全的、是不需要同步的。如下:
1)常量始终是线程安全的，因为只存在读操作。
2)对构造器的访问(new 操作)是线程安全的，因为每次都新建一个实例，不会访问共享的资源。
3)最重要的是:局部变量是线程安全的。因为每执行一个方法，都会在独立的空间创建局部变量，它不是共享的资源。局部变量包括方法的参数变量。
struts user guide里有：
Only Use Local Variables - The most important principle that aids in thread-safe coding is to use only local variables, not instance variables , in your Action class.
译:只使用用局部变量。--编写线程安全的代码最重要的原则就是，在Action类中只使用局部变量，不使用实例变量。


总结：
在Java的Web服务器环境下开发，要注意线程安全的问题。最简单的实现方式就是在Servlet和Struts Action里不要使用类变量、实例变量，但可以使用类常量和实例常量。
如果有这些变量，可以将它们转换为方法的参数传入，以消除它们。
注意一个容易混淆的地方：被Servlet或Action调用的类中(如值对象、领域模型类)中是否可以安全的使用实例变量？如果你在每次方法调用时
新建一个对象，再调用它们的方法，则不存在同步问题---因为它们不是多个线程共享的资源，只有共享的资源才需要同步---而Servlet和Action的实例对于多个线程是共享的。
换句话说，Servlet和Action的实例会被多个线程同时调用，而过了这一层,如果在你自己的代码中没有另外启动线程，且每次调用后续业务对象时都是先新建一个实例再调用，则都是线程安全的。

posted @ 2007-04-09 20:31 阿成 阅读(473) | 评论 (0) | 编辑 收藏
ActionServlet深入探讨
java.lang.Object
  |
  +--javax.servlet.GenericServlet
        |
        +--javax.servlet.http.HttpServlet
              |
              +--org.apache.struts.action.ActionServlet

Struts提供了一个缺省版本的ActionServlet类，你可以继承这个类，覆盖其中的一些方法来达到你的特殊处理的需要。ActionServlet继承与javax.servlet.http.HttpServlet，所以在本质上它和一个普通的servlet没有区别，你完全可以把它当做一个servlet来看待，只是在其中完成的功能不同罢了。ActionServlet主要完成如下功能：

将一个来自客户端的URI映射到一个相应的Action类
  • 如果是这个Action类是第一次被调用，那么实例化一个并放入缓存
  • 如果在配置文件(struts-config.xml)中指定了相应的ActionForm，那么从Request中抓取数据填充FormBean
  • 调用这个Action类的perform()方法，传入ActionMapping的一个引用，对应的ActionForm、以及由容器传给ActionServlet的HttpServletRequest、HttpServletResponse对象。


确省版本的ActionServlet会从配置文件web.xml中读取如下初始化参数：
  • application
    应用使用的资源包(resources bundle)的基类
  • factory
    用于创建应用的MessageResources对象的MessageResourcesFactory的类名。确省是org.apache.struts.util.PropertyMessageResourcesFactory。
  • config
    Struts的配置文件，确省是/WEB-INF/struts-config.xml。注意这儿是与应用Context关联的相对路径。
  • content
    定义了确省的内容类型和编码格式，它会被自动地被设置到每个response中，如果JSP/Servlet中没有明确的设置。确省是text/html。
  • debug
    调试信息的级别。默认为0，比当前级别高的调试信息会被log到日志文件中。
  • detail
    与debug的作用类似，只是这个detail是initMapping()时专用的。调试信息会被打印到System.out，而不是日志文件。
  • formBean
    ActionFormBean的实现类，确省为org.apache.struts.action.ActionFormBean
  • forward
    应用中使用的ActionForward类，确省是org.apache.struts.action.ActionForward。
  • locale
    指定了确省使用的Locale对象。设为true，当得到一个session时，会自动在session中存储一个以Action.LOCALE_KEY标示的Locale对象，如果session中还没有与Action.LOCALE_KEY绑定的Locale对象。
  • mapping
    应用中使用的ActionMapping类，确省是org.apache.struts.action.ActionMapping。
  • multipartClass
    文件上传使用的MutipartRequestHandler的实现类。确省为org.apache.struts.upload.DiskMultipartRequestHandler
  • nocache
    如果设为true，那么ActionServlet会自动在每个到客户端的响应中添加nocache的HTML头，这样客户端就不会对应用中的页面进行缓存。确省为false
  • null
    如果设置为true，那么应用在得到一个未定义的message资源时，会返回null，而不是返回一个错误信息。确省是true。
  • maxFileSize
    文件上传的大小上限，确省为250M
  • bufferSize
    文件上传时的缓冲区的大小，确省为4M
  • tempDir
    设置用于上传时的临时目录。工作目录会作为一个Servlet环境（Context）的属性提供。
  • validate
    Are we using the new configuration file format?确省为true。
  • validating

在解析配置XML文件是是否进行有效性的验证。确省为true

ActionServlet中应用了命令设计模式。

一个Servlet在由容器生成时，首先会调用init()方法进行初始化，在接到一个HTTP请求时，调用相应的方法进行处理；比如GET请求调用doGet()方法，POST请求调用doPost()方法。所以首先看看ActionServlet的init()方法，你就会很清楚为什么ActionServlet可以完成这些功能了。

init()


在它的init()方法中，ActionServlet依次调用如下protected的方法完成初始化：
  • initActions() －     大家可能还曾有这个疑问：Struts为什么可以找到一个请求URI对应的action类呢？答案就在这儿，ActionServlet有一个actions属性，类型为org.apache.struts.util.FastHashMap，用于存储以类的全名为key的已实例化的Action类。在init()时首先调用的就是initActions()方法，在这个方法中只是简单的清除map中的所有的名值对，
    2.         synchronized (actions) {
    3.             actions.setFast(false);
    4.             actions.clear();
    5.             actions.setFast(true);
    6.         }

    首先把actions设为slow模式，这时对FastHashMap的访问是线程同步的，然后清除actions中的所有的已存在的名/值对，最后再把actions的模式设为fast。由于FastHashMap是struts在java.util.HashMap的基础上的一个扩展类，是为了适应多线程、并且对HashMap的访问大部分是只读的特殊环境的需要。大家知道java.util.HashMap是非线程安全的，所以HashMap一般适用于单线程环境下。org.apache.struts.FastHashMap就是继承于java.util.HashMap，在其中添加多线程的支持产生的。在fast模式下的工作方式是这样的：读取是非线程同步的；写入时首先克隆当前map，然后在这个克隆上做写入操做，完成后用这个修改后的克隆版本替换原来的map。那么在什么时候会把Actions类添加到这个map中呢？我们已经提到了struts是动态的生成Action类的实例的，在每次ActionServlet接收到一个GET或POST的HTTP请求时，会在这个map中查找对应的Action类的实例，如果不存在，那么就实例化一个，并放入map中。可见这个actions属性起到了对Action类实例的缓存的作用。
  • initInternal() －     初始化ActionServlet内部使用的资源包MessageResources，使用MessageResources.getMessageResources(internalName)得到    internalName为"org.apache.struts.action.ActionResources"对应的ActionResources.properties文件。这个资源包主要用于ActionServlet处理过程中的用到的提示信息，这儿不展开讨论。
  • initDebug() －     从web.xml中读取本应用的debug级别参数getServletConfig().getInitParameter("debug")，然后赋给debug属性。
  • initApplication()－    初始化应用资源包，并放置入ServletContext中。
    2.         String factory =getServletConfig().getInitParameter(“factory”);    
    3.         String oldFacory = MessageResourcesFactory.getFactoryClass();
    4.         if (factory !=null)
    5.                 MessageResourcesFactory.setFactoryClass(factory);
    6.         String value = getServletConfig().getInitParameter("application");
    7.         MessageResourcesFactory factoryObject =
    8.                 MessageResourcesFactory.createFactory();
    9.         application = factoryObject.createResources(value);
    10.         MessageResourcesFactory.setFactory(oldFactory); 
    11.         getServletContext().setAttribute(Action.MESSAGES_KEY, application);

    说明：文中引用的代码片断可能会省略了一些例外检查等非主线的内容，敬请注意。

    首先从配置文件中读取factory参数，如果这个参数不为空，那么就在MessageResourcesFactory中使用这个指定的Factory类；否则，使用默认的工厂类org.apche.struts.util.PropertyMessageResourceFactory。然后调用MessageResourcesFactory的静态createFactory()方法，生成一个具体的MessageResourceFactory对象（注意：MessageResourcesFactory是抽象类）。这样就可以调用这个具体的MessageResourceFactory的createResource()方法得到配置文件(web.xml)中定义的资源文件了。
    上面的application对象类型为MessageResources。在web.xml中在配置ActionServlet时可以指定一个特定的工厂类。不能直接MessageResourcesFactory的createResources()方法，因为这个方法是abstract的。创建factoryObject的过程如下：
    1.     
    2.         MessageResourceFactory factoryObject=
    3.                 MessageResourcesFactory.createFactory();
    4.         application = factoryObject.createResources(value);

    <li>initMapping() －    为应用初始化mapping信息ActionServlet有一个protected的属性：mapping，封装了一个ActionMapping的对象集合，以便于管理、查找ActionMapping。mappings是org.apache.struts.action.ActionMappings类的实例。主要有两个方法：addMapping(ActionMapping mapping)和findMapping(String path)。ActionMapping也是使用上面提到的org.apache.struts.util.FastHashMap类来存储所有的ActionMapping对象。
    2.         mappings.setServlet(this);
    3.         ……
    4.         // Initialize the name of our ActionFormBean implementation class
    5.         value = getServletConfig().getInitParameter("formBean");
    6.         if (value != null)
    7.             formBeanClass = value;
    8.     
    9.         // Initialize the name of our ActionForward implementation class
    10.         value = getServletConfig().getInitParameter("forward");
    11.         if (value != null)
    12.                 forwardClass = value;
    14.         // Initialize the name of our ActionMapping implementation class
    15.         value = getServletConfig().getInitParameter("mapping");
    16.         if (value != null)
    17.                 mappingClass = value;

    在initMapping()中，首先链接mappings对象到本servlet实例。其实这句话的作用很简单，在ActionMappings中会有一个ActionServlet类型的属性，这个属性就界定了这个ActionMappings对象所属的ActionServlet。Struts的实现比较灵活，其中的ActionFormBean、ActionForward、ActionMapping类你完全可以使用自己实现的子类，来定制Struts的工作方式。上面的代码就从配置文件（web.xml）中读取formBean、forward、mapping参数，这些参数就是你定制的ActionFormBean、ActionForward、ActionMapping类名。
    2.         // Initialize the context-relative path to our configuration resources
    3.         value = getServletConfig().getInitParameter("config");
    4.         if (value != null)
    5.                 config = value;
    6.                 // Acquire an input stream to our configuration resource
    7.         InputStream input = getServletContext().getResourceAsStream(config);
    8.         Digester digester = null;
    9.                 digester = initDigester(detail);
    10.         try {
    11.                 formBeans.setFast(false);
    12.                 forwards.setFast(false);
    13.                 mappings.setFast(false);
    14.                 digester.parse(input);
    15.                 mappings.setFast(true);
    16.                 forwards.setFast(true);
    17.                 formBeans.setFast(true);
    18.         } catch (SAXException e) {
    19.                 throw new ServletException
    20.         (internal.getMessage("configParse", config), e);
    21.         } finally {
    22.                 input.close();
    23.         }

    从web.xml读取Struts的配置文件的位置。使用org.apache.struts.digester.Digester解析config参数标示的配置文件，通常为“/WEB-INF/struts-config.xml”，解析出所有的data-source、form-bean、action-mapping、forward。从上面的程序片断看到，Digester仅仅调用了一个parse()方法，那么，Digester是怎样把解析struts-config.xml文件并把解析的结果form-bean等信息存储到属性变量formBeans等中的呢？你可以注意到在调用digester.parse(InputStream)之前，首先调用了initDigester()方法：
    2.         Digester digester = new Digester();
    3.         digester.push(this);
    4.         digester.addObjectCreate("struts-config/action-mappings/action",
    5.                                  mappingClass, "className");
    6.         digester.addSetProperties("struts-config/action-mappings/action");
    7.         digester.addSetNext("struts-config/action-mappings/action",
    8.                             "addMapping",
    9.                             "org.apache.struts.action.ActionMapping");
    11.         digester.addSetProperty
    12.             ("struts-config/action-mappings/action/set-property",
    13.              "property", "value");

    在这个方法中首先生成一个Digester对象，然后设置解析的规则和回调，如果你对XML、SAX不是很熟，这儿不必纠缠太深。要注意的是addSetNext()方法，设置了每一个要解析元素的Set Next回调方法，而这个方法就是由digester解析器的父提供的。上面的片断中的“addMapping”就是ActionServlet本身定义的一个方法，将由Digester回调。Digester就是籍此把解析出的每一个FormBean、ActionForward、ActionMapping等存储到属性变量formBeans、forwards、mappings等中的。
  • initUpload() －    初始化有关Upload的一些参数，比如：bufferSize、tempDir。
  • initDataSource() －取出在initMapping()中从配置文件中读取的每一个DataSource，设置LogWriter，如果为GenericDataSource的实例，则打开数据源。然后，把每个dataSource放入Context中。
    dataSource.setLogWriter(scw)；
    ((GenericDataSource)dataSource).open();
    getServletContext().setAttribute(key,dataSource);
  • initOther() －        设置其它尚未初始化的的参数（content、locale、nocache），并发布formBeans、forwards、mappings到Context：
    getServletContext().setAttribute(Action.FORM_BEANS_KEY, formBeans);
    getServletContext().setAttribute(Action.FORWARDS_KEY, forwards);
    getServletContext().setAttribute(Action.MAPPINGS_KEY, mappings);
  • initServlet() －    初始化Controller Servlet的Servlet Mapping。这儿也使用了Digester工具，扫描web.xml所有的<web-app/servlet-mapping>，寻找servlet-name与当前Servlet相同的mapping，置入Context。代码如下；
    2.         Digester digester = new Digester();
    3.         digester.push(this);
    4.         digester.setDebug(debug);
    5.         digester.setValidating(validating);
    6.         digester.addCallMethod(“web-appservlet-mapping”,“addServletMapping”, 2);
    7.         digester.addCallParm(“web-appservlet-mappingservlet-name”, 0);
    8.         digester.addCallParm(“web-appservlet-mappingurl-pattern”, 1);
    9.         InputStream is = getServletContext().getResourceAsStream(“/WEB-INFweb.xml”);
    10.         digester.parse(is); 
    11.         getServletContext().setAttribute(Action.SERVLET_KEY,servletMapping);
posted @ 2007-04-06 09:48 阿成 阅读(435) | 评论 (0) | 编辑 收藏
CSS全攻略－转
关键字:   转贴    

CSS全称Cascading Style Sheet。层叠式样式表。从三年前就开始使用CSS了，但一直以来都小看了它。CSS的出现其实是一次革命，它试图将网站的内容与表现分开。
一、CSS的四种实现方式：
1.内嵌式：

2.外链式：

3.导入式

3.属性式：
二.CSS的定义：
选择对象{属性1:值1;属性2:值2;属性3:值3;属性n:值n……}
如：
td{font-size:12px;color:#FFFF00}
.myname{font-size:12px;color:#FFFF00}
a:hover{font-size:12px;color:#FFFF00;text-decoration: underline;}
三.四种选择对象
1.HTML selector (TagName)
2.class selector (.NAME)
3.ID selector (#IDname)
4.特殊对象 (a:hover　a:link　a:visited　a:active)
1.HTML selector
HTML selector就是HTML的置标符，如：DIV、TD、H1。HTML selector的作用范围是应用了该样式的所有页面中的所有该置标符。
例：
td
{ color: #FF0000;
}
-->
注意：在中没有应用什么，其中文字自动变红色。
2.class selector
定义class selector需要往其名称其加一个点“.”。如“.classname”。class selector的作用范围是所有包含“class="classname"”的置标符。
例：
.fontRed
{ color: #FF0000;
} -->
注意：在第二个中没有“class="fontRed"”，所以文字没有变红色。
3.ID selector
定义ID selector需要往其名称其加一个点“#”。如“#IDname”。ID selector的作用范围是所有包含“ID="classname"”的置标符。
例：

#fontRed
{ color: #FF0000;
} -->
注意：在第二个中没有“ID="fontRed"”，所以文字没有变红色。
4.特殊对象
特殊对象包括四种，是针对链接对象设置的:
a:hover 鼠标移上时的超链接
a:link 常规，非访问超链接
a:visited 访问过的超链接
a:active 鼠标点击时的超链接
特殊对象的作用范围是所有置标符（这句话有待商榷，因为下面很快就有一种方法可以把“所有”两个字推翻）。
例：
a:hover
{ color: #0000FF;
text-decoration: underline;
} -->
注意下面，很有用！！！
a.classname:hover
a#IDname:hover
这两种写法，是分别配合.classname与#IDname使用的。它的作用范围变成了所有包含“class="classname"”或“ID="IDname"”的置标符。这种写法，可以帮助你在同一页面中实现多种a:hover效果，可以看一下艺网的主页上导航栏文字与普通文章标题在鼠标时的区别。
四.应用：
1.置标符　自动应用
2.特制类　class="NAME"
3.ID ID="IDname"
4.特殊对象　自动应用
五.CSS属性
CSS的属性有很多，像上文中用到最多的color，表示文字的颜色。background-color表示背景色。这个是最主要的，但是因为没有什么难度，参考一下相关手册就可以了。

注明两点
第一点：css的方式现在一般都采用外部连接，这个用起来方便，编译起来也方便
第二点：我用的是frontpage2003，很多css的参数都会自动提示，似乎好像以前我没有用到过~~dw有的

CSS 标签属性/属性参考
这里列出了目前支持的样式表(CSS)标签属性。标有星号(*)的标签属性可于 Microsoft® Internet Explorer 5 中使用。标有两个星号(**)的标签属性可于 Internet Explorer 5.5 中使用。带有两个加号(++)的标签属性可于 Internet Explorer 6 中使用。如果某个标签属性或属性已经提交给万维网协会(W3C)但尚未作为标准发布，则标有“已提交”。若某个标签属性或属性既未提交给 W3C 也不是标准，将标有“扩展”。

CSS 标签属性/属性

行为属性 behavior

字体和文本属性 direction*

direction
font
font-family
font-size
font-style
font-variant
font-weight
ime-mode
layout-grid
layout-grid-char
layout-grid-line
layout-grid-mode
layout-grid-type
letter-spacing
line-break
line-height
min-height ++
ruby-align
ruby-overhang
ruby-position
text-align
text-autospace
text-decoration
text-indent
text-justify
text-kashida-space
text-overflow ++
text-transform
text-underline-position
unicode-bidi
vertical-align
white-space**
word-break
word-spacing ++(于 Macintosh 版本 4.0 中可用)
word-wrap
writing-mode

颜色和背景属性 background-attachment
background-color
background-image
background-position
background-position-x
background-position-y
background-repeat
color

版面属性 border
border-bottom
border-bottom-color
border-bottom-style
border-bottom-width
border-collapse*
border-color
border-left
border-left-color
border-left-style
border-left-width
border-right
border-right-color
border-right-style
border-right-width
border-style
border-top
border-top-color
border-top-style
border-top-width
border-width
clear
float
layout-flow
margin
margin-bottom
margin-left
margin-right
margin-top
padding
padding-bottom
padding-left
padding-right
padding-top
scrollbar-3dlight-color
scrollbar-arrow-color
scrollbar-base-color
scrollbar-darkshadow-color
scrollbar-face-color
scrollbar-highlight-color
scrollbar-shadow-color
table-layout*
zoom

分类属性 display

list-style
list-style-image
list-style-position
list-style-type

定位属性 bottom*

clip
height
left
overflow
overflow-x
overflow-y
position
right*
top
visibility
width
z-index

打印属性 page**

pageBreakAfter
pageBreakBefore

滤镜属性 filter

伪类和其它属性 :active

@charset
cursor
:first-letter**
:first-line**
@font-face
:hover
@import
!important
:link
@media*
@page**
:visited
有关表格边框的css语法整理

我们知道Dreamweaver在表格制作方面做得非常出色，但是在某些时候还是必须结合css才能达到一些特定效果，下面我们先把有关表格边框的css语法整理出来，然后另外介绍怎样用css美化表格的边框。

　　有关表格边框的css语法

　　具体内容包括：上边框宽度、右边框宽度、下边框宽度、左边框宽度、边框宽度、边框颜色、边框样式、上边框、下边框、左边框、右边框、边框、宽度、高度、有关标签等。

　　 1.上边框宽度

　　语法: border-top-width: <值>

　　允许值: thin | medium | thick | <长度>

　　初始值: medium

　　适用于: 所有对象

　　向下兼容: 否

　　上边框宽度属性用于指定一个元素上边框的宽度。值可以是三个关键字其中的一个，都不受字体大小或长度的影响，可以用于实现成比例的宽度。不允许使用负值。也可以用在上边框、边框的宽度或边框的属性略写。

　　2.右边框宽度

　　语法: border-right-width: <值>

　　允许值: thin | medium | thick | <长度>

　　初始值: medium

　　适用于: 所有对象

　　向下兼容: 否

　　右边框宽度属性用于指定元素的右边框的宽度。值可以是三个关键字其中的一个，都不受字体大小或长度的影响，可以用于实现成比例的宽度。不允许使用负值。也可以用在右边框、边框的宽度或边框的属性略写。

　　 3.下边框宽度

　　语法: border-bottom-width: <值>

　　允许值: thin | medium | thick | <长度>

　　初始值: medium

　　适用于: 所有对象

　　向下兼容: 否

　　下边框宽度属性用于指定元素的下边框的宽度。值可以是三个关键字其中的一个，都不受字体大小或长度的影响，可以用于实现成比例的宽度。不允许使用负值。也可以用在下边框、边框的宽度或边框的属性略写。

　　 4.左边框宽度

　　语法: border-left-width: <值>

　　允许值: thin | medium | thick | <长度>

　　初始值: medium

　　适用于: 所有对象

　　向下兼容: 否

　　左边框宽度属性用于指定元素的左边框的宽度。值可以是三个关键字其中的一个，都不受字体大小或长度的影响，可以用于实现成比例的宽度。不允许使用负值。也可以用在左边框、边框的宽度或边框的属性略写。

　　5.边框宽度

　　语法: border-width: <值>

　　允许值: [ thin | medium | thick | <长度> ]{1,4}

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　边框宽度属性用一到四个值来设置元素的边界，值是一个关键字或长度。不允许使用负值长度。如果四个值都给出了，它们分别应用于上、右、下和左边框的式样。如果给出一个值，它将被运用到各边上。如果两个或三个值给出了，省略了的值与对边相等。 这个属性是上边框宽度、右边框宽度、下边框宽度和左边框宽度属性的略写。也可以使用略写的边框属性。

　　6.边框颜色

　　语法: border-color: <值>

　　允许值: <颜色>{1,4}

　　初始值: 颜色属性的值

　　适用于: 所有对象

　　向下兼容: 否

　　边框颜色属性设置一个元素的边框颜色。可以使用一到四个关键字。如果四个值都给出了，它们分别应用于上、右、下和左边框的式样。如果给出一个值，它将被运用到各边上。如果两个或三个值给出了，省略了的值与对边相等。也可以使用略写的边框属性。

　　7.边框样式

　　语法: border-style: <值>

　　允许值: [ none | dotted | dashed | solid | double | groove | ridge | inset | outset ]{1,4}

　　初始值: none

　　适用于: 所有对象

　　向下兼容: 否

　　边框样式属性用于设置一个元素边框的样式。这个属性必须用于指定可见的边框。可以使用一到四个关键字。如果四个值都给出了，它们分别应用于上、右、下和左边框的式样。如果给出一个值，它将被运用到各边上。如果两个或三个值给出了，省略了的值与对边相等。也可以使用略写的边框属性。

　　none：无样式；
　　dotted：点线；
　　dashed：虚线；
　　solid：实线；
　　double：双线；
　　groove：槽线；
　　ridge：脊线；
　　inset：内凹；
　　outset：外凸。
8.上边框

　　语法: border-top: <值>

　　允许值: <上边框宽度> || <边框式样> || <颜色>

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　上边框属性是一个用于设置一个元素上边框的宽度、式样和颜色的略写。注意只能给出一个边框式样。也可以使用略写的边框属性。

　　9.右边框

　　语法: border-right: <值>

　　允许值: <右边框宽度> || <边框式样> || <颜色>

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　右边框属性是一个用于设置一个元素右边框的宽度、式样、和颜色的略写。注意只能给出一个边框式样。也可以使用略写的边框属性。　　

　　10.下边框

　　语法: border-bottom: <值>

　　允许值: <下边框宽度> || <边框式样> || <颜色>

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　下边框属性是一个用于设置一个元素的下边框的宽度、式样和颜色的略写。注意只能给出一个边框式样。也可以使用略写的边框属性。

　　11.左边框

　　语法: border-left: <值>

　　允许值: <左边框宽度> || <边框式样> || <颜色>

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　左边框属性是一个用于设置一个元素左边框的宽度、式样和颜色的略写。注意只能给出一个边框式样。也可以使用略写的边框属性。

　　 12.边框

　　语法: border: <值>

　　允许值: <边框宽度> || <边框式样> || <颜色>

　　初始值: 未定义

　　适用于: 所有对象

　　向下兼容: 否

　　边框属性是一个用于设置一个元素边框的宽度、式样和颜色的略写。

　　边框声明的例子包括：

　　H2 { border: groove 3em }
　　A:link { border: solid blue }
　　A:visited { border: thin dotted #800080 }
　　A:active { border: thick double red }

　　边框属性只能设置四种边框；只能给出一组边框的宽度和式样。为了给出一个元素的四种边框的不同的值，网页制作者必须用一个或更多的属性，如：上边框、右边框、下边框、左边框、边框颜色、边框宽度、边框式样、上边框宽度、右边框宽度、下边框宽度或左边框宽度。

　　13.宽度

　　语法: width: <值>

　　允许值: <长度> | <百分比> | auto

　　初始值: auto

　　适用于: 块级和替换元素

　　向下兼容: 否

　　宽度属性的初始值为“auto”，即为该元素的原有宽度(有就是元素自己的宽度)。百分比参考上级元素的宽度。不允许使用负的长度值。

　　14.高度

　　语法: height: <值>

　　允许值: <长度> | auto

　　初始值: auto

　　适用于: 块级和替换元素

　　向下兼容: 否

　　高度属性的初始值为“auto”，即为该元素的原有高度(有就是元素自己的高度，)。百分比参考上级元素的宽度。不允许使用负的长度值。

　　15.有关标签

　　table：表格标签，对整个表格样式的定义要放在table中；
　　td：单元格标签，对单元格样式的定义要放在td中。

css滤镜

随着网页设计技术的发展，人们已经不满足于原有的一些HTML标记，而是希望能够为页面添加一些多媒体属性，例如滤镜的和渐变的效果。CSS技术的飞快发展使这些需求成为了现实。从现在开始我要为大家介绍一个新的CSS扩展部分：CSS滤镜属性（Filter Properties)。使用这种技术可以把可视化的滤镜和转换效果添加到一个标准的HTML元素上，例如图片、文本容器、以及其他一些对象。对于滤镜和渐变效果，前者是基础，因为后者就是滤镜效果的不断变化和演示更替。当滤镜和渐变效果结合到一个基本的SCRIPT小程序中后，网页设计者就可以拥有一个建立动态交互文档的强大工具。也就是CSS FILTER+ SCRIPT， 这就说明想要建立动态的文档还要一些SCRIPT （脚本语言）的基础。
可视化滤镜属性只能用在HTML控件元素上。所谓的HTML空间元素就是它们在页面上定义了一个矩形空间，浏览器的窗口可以显示这些空间。下面列出了HTML合法的控件和它们的说明。

备注：可惜只有IE4.0以上支持，如果是别的浏览器，那就.......

元素 说明
BODY 网页文档的主体元素，所有的可见范围都在<BODY>元素内
BUTTON 表单域的按钮，可以有“发送(submit)”、“重置(reset)”等形式
DIV 定义了网页上的一个区域，这个区域的高度、宽度或者绝对位置都是以知的
IMG 图片元素，通过指定“src"属性来指定图片的来源
INPUT 输入表单域
MARQUEE 移动字幕效果
SPAN 定义了网页上的一个区域，这个区域的高度、宽度或者绝对位置都是以知的
TABLE 表格
TD 表格数据单元格
TEXTAREA 文本区域
TFOOT 多行输入文本框
TH 表格标题单元格
THEAD 表格标题
TR 表格行

　

IE4.0以上支持的滤镜属性表

滤镜效果 描述
Alpha 设置透明度
Blru 建立模糊效果
Chroma 把指定的颜色设置为透明
DropShadow 建立一种偏移的影象轮廓，即投射阴影
FlipH 水平反转
FlipV 垂直反转
Glow 为对象的外边界增加光效
Grayscale 降低图片的彩色度
Invert 将色彩、饱和度以及亮度值完全反转建立底片效果
Light 在一个对象上进行灯光投影
Mask 为一个对象建立透明膜
Shadow 建立一个对象的固体轮廓，即阴影效果
Wave 在X轴和Y轴方向利用正弦波纹打乱图片
Xray 只显示对象的轮廓

1、Alpha 滤镜

语法：{FILTER：ALPHA(opacity=opacity,finishopacity=finishopacity,style=style,startx=startx,
starty=starty,finishx=finishx,finishy=finishy)}

"Alpha"属性是把一个目标元素与背景混合。设计者可以指定数值来控制混合的程度。这种“与背景混合”通俗地说就是一个元素的透明度。通过指定坐标，可以指定点、线、面的透明度。他们的参数含义分别如下：
“opacity"代表透明度水准。默认的范围是从0 到 100，他们其实是百分比的形式。也就是说，0代表完全透明，100代表完全不透明。”finishopacity"是一个可选参数，如果想要设置渐变的透明效果，就可以使用他们来指定结束时的透明度。范围也是0 到 100。“style" 参数指定了透明区域的形状特征。其中0代表统一形状、1代表线形、2代表放射状、3代表长方形。”STARTX“和”STARTY“代表渐变透明效果的开始X和Y坐标。”FINISHX“和”FINISHY“代表渐变透明效果结束X和Y 的坐标。

效果如下：

2、Blur 滤镜

语法：对于HTML：{ilter:blur(add=add,direction=direction,strength=strength)}
对于Script语言： [oblurfilter=] object.filters.blur
用手指在一幅尚未干透的油画上迅速划过时，画面就会变得模糊。”Blur"就是产生同样的模糊效果。
“ADD”参数是一个布尔判断“TRUE（默认）”或者“FALSE”。它指定图片是否被改变成印象派的模糊效果。模糊效果是按顺时针的方向进行的，“DIRECTION”参数用来设置模糊的方向。其中0度代表垂直向上，然后每45度为一个单位。它的默认值是向左的270度。“STRENGTH“值只能使用整数来指定，她代表有多少像素的宽度将受到模糊影响。默认是5个。对于网页上的字体，如果设置他的模糊”ADD=1“，那么这些字体的效果会非常好看的。如下：
filter:blur(add=ture,direction=135,strength=10）

3、FlipH, FlipV 滤镜

语法：{filter:filph} ,{filter:filpv} 分别是水平反转和垂直反转，具体如下：

4、Chroma 滤镜

语法：{filter:chroma(color=color)}
使用”Chroma"属性可以设置一个对象中指定的颜色为透明色，参数COLOR即要透明的颜色。下面是兰色文字，然后用Chroma 滤镜过滤掉兰色，就成了下面的样子。
filter:chroma(color=blue)

滴水檐坊

5、DropShadow 滤镜

语法：{filter:dropshadow(color=color,offx=ofx,offy=offy,positive=positive)}

“DropShaow"顾名思义就是添加对象的阴影效果。其工作原理是建立一个偏移量，加上较深。"Color"代表投射阴影的颜色，"offx"和"offy"分别是X方向和Y方向阴影的饿偏移量。"Positive"参数是一个布尔值，如果为“TRUE（非0）”，那么就为任何的非透明像素建立可见的投影。如果为“FASLE（0）”，那么就为透明的像素部分建立透明效果

6、Glow 滤镜

语法：{filter:glow(color=color,strength)}
当对一个对象使用"glow"属性后，这个对象的边缘就会产生类似发光的效果。“COLOR”是指定发光的颜色，“STRENGTH”则是强度的表现，可以从1到255之间的任何整数来指定这个力度。
filter:glow(color=red,strength=10) 后的效果

7、Gray ,Invert,Xray 滤镜

语法：{filter:gray} ,{filter:invert},{filter:xray}

Gray滤镜是把一张图片变成灰度图；Invert滤镜是把对象的可视化属性全部翻转，包括色彩、饱和度、和亮度值；Xray滤镜是让对象反映出它的轮廓并把这些轮廓加亮，也就是所谓的“X”光片。

效果如下：

、Light 滤镜

语法：Filter{light}

这个属性模拟光源的投射效果。一旦为对象定义了“LIGHT"滤镜属性，那么就可以调用它的“方法(Method)"来设置或者改变属性。“LIGHT"可用的方法有：

AddAmbient 加入包围的光源
AddCone 加入锥形光源
AddPoint 加入点光源
Changcolor 改变光的颜色
Changstrength 改变光源的强度
Clear 清除所有的光源
MoveLight 移动光源
可以定义光源的虚拟位置，以及通过调整X轴和Y轴的数值来控制光源焦点的位置，还可以调整光源的形式（点光源或者锥形光源）指定光源是否模糊边界、光源的颜色、亮度等属性。如果动态的设置光源，可能回产生一些意想不到的效果。后面几页会有具体范例。

9、Mask 滤镜

语法：{filter:mask(color=color)}

使用"MASK"属性可以为对象建立一个覆盖于表面的膜，其效果就象戴者有色眼镜看物体一样。

10、Shadow 滤镜

语法：{filter:shadow(color=color,direction=direction)}

利用“Shadow”属性可以在指定的方向建立物体的投影，COLOR是投影色，DIRECTION是设置投影的方向。其中0度代表垂直向上，然后每45度为一个单位。它的默认值是向左的270度。

filter:shadow(color=red,direction=225)
filter:shadow(color=blue,direction=225)
filter:shadow(color=gray,direction=225)
效果分别如下：

11、Wave 滤镜 语法：{filter:wave(add=add,freq=freq,lightstrength=strength,phase=phase,strength=strength)}
"wave" 属性把对象按垂直的波形样式打乱。默认是“TRUE（非0）”，
“ADD”表示是否要把对象按照波形样式打乱，

“FREQ”是波纹的频率，也就是指定在对象上一共需要产生多少个完整的波纹，

“LIGHTSTRENGTH”参数可以对于波纹增强光影的效果，范围0----100，

“PHASE”参数用来设置正弦波的偏移量。

“STRENGTH”代表振幅大小。
posted @ 2006-10-25 19:11 阿成 阅读(301) | 评论 (0) | 编辑 收藏
Java虚拟机的深入研究--转

Java虚拟机的深入研究

作者：刘学超

1  Java技术与Java虚拟机

说起Java，人们首先想到的是Java编程语言，然而事实上，Java是一种技术，它由四方面组成: Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示：

图1  Java四个方面的关系

运行期环境代表着Java平台，开发人员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)。最后字节码被装入内存，一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成机器码执行。从上图也可以看出Java平台由Java虚拟机和Java应用程序接口搭建，Java语言则是进入这个平台的通道，用Java语言编写并编译的程序可以运行在这个平台上。这个平台的结构如下图所示：

在Java平台的结构中, 可以看出，Java虚拟机(JVM) 处在核心的位置，是程序与底层操作系统和硬件无关的关键。它的下方是移植接口，移植接口由两部分组成：适配器和Java操作系统, 其中依赖于平台的部分称为适配器；JVM 通过移植接口在具体的平台和操作系统上实现；在JVM 的上方是Java的基本类库和扩展类库以及它们的API， 利用Java API编写的应用程序(application) 和小程序(Java applet) 可以在任何Java平台上运行而无需考虑底层平台, 就是因为有Java虚拟机(JVM)实现了程序与操作系统的分离，从而实现了Java 的平台无关性。

那么到底什么是Java虚拟机(JVM)呢？通常我们谈论JVM时，我们的意思可能是：

  1. 对JVM规范的的比较抽象的说明；
  2. 对JVM的具体实现；
  3. 在程序运行期间所生成的一个JVM实例。

对JVM规范的的抽象说明是一些概念的集合，它们已经在书《The Java Virtual Machine Specification》（《Java虚拟机规范》）中被详细地描述了；对JVM的具体实现要么是软件，要么是软件和硬件的组合，它已经被许多生产厂商所实现，并存在于多种平台之上；运行Java程序的任务由JVM的运行期实例单个承担。在本文中我们所讨论的Java虚拟机(JVM)主要针对第三种情况而言。它可以被看成一个想象中的机器，在实际的计算机上通过软件模拟来实现，有自己想象中的硬件，如处理器、堆栈、寄存器等，还有自己相应的指令系统。

JVM在它的生存周期中有一个明确的任务，那就是运行Java程序，因此当Java程序启动的时候，就产生JVM的一个实例；当程序运行结束的时候，该实例也跟着消失了。下面我们从JVM的体系结构和它的运行过程这两个方面来对它进行比较深入的研究。

2  Java虚拟机的体系结构

刚才已经提到，JVM可以由不同的厂商来实现。由于厂商的不同必然导致JVM在实现上的一些不同，然而JVM还是可以实现跨平台的特性，这就要归功于设计JVM时的体系结构了。

我们知道，一个JVM实例的行为不光是它自己的事，还涉及到它的子系统、存储区域、数据类型和指令这些部分，它们描述了JVM的一个抽象的内部体系结构，其目的不光规定实现JVM时它内部的体系结构，更重要的是提供了一种方式，用于严格定义实现时的外部行为。每个JVM都有两种机制，一个是装载具有合适名称的类(类或是接口)，叫做类装载子系统；另外的一个负责执行包含在已装载的类或接口中的指令，叫做运行引擎。每个JVM又包括方法区、堆、Java栈、程序计数器和本地方法栈这五个部分，这几个部分和类装载机制与运行引擎机制一起组成的体系结构图为：

图3  JVM的体系结构

JVM的每个实例都有一个它自己的方法域和一个堆，运行于JVM内的所有的线程都共享这些区域；当虚拟机装载类文件的时候，它解析其中的二进制数据所包含的类信息，并把它们放到方法域中；当程序运行的时候，JVM把程序初始化的所有对象置于堆上；而每个线程创建的时候，都会拥有自己的程序计数器和Java栈，其中程序计数器中的值指向下一条即将被执行的指令，线程的Java栈则存储为该线程调用Java方法的状态；本地方法调用的状态被存储在本地方法栈，该方法栈依赖于具体的实现。

下面分别对这几个部分进行说明。

执行引擎处于JVM的核心位置，在Java虚拟机规范中，它的行为是由指令集所决定的。尽管对于每条指令，规范很详细地说明了当JVM执行字节码遇到指令时，它的实现应该做什么，但对于怎么做却言之甚少。Java虚拟机支持大约248个字节码。每个字节码执行一种基本的CPU运算,例如,把一个整数加到寄存器,子程序转移等。Java指令集相当于Java程序的汇编语言。

Java指令集中的指令包含一个单字节的操作符,用于指定要执行的操作,还有0个或多个操作数,提供操作所需的参数或数据。许多指令没有操作数,仅由一个单字节的操作符构成。

虚拟机的内层循环的执行过程如下: 
do{ 
取一个操作符字节; 
根据操作符的值执行一个动作; 
}while(程序未结束)

由于指令系统的简单性,使得虚拟机执行的过程十分简单,从而有利于提高执行的效率。指令中操作数的数量和大小是由操作符决定的。如果操作数比一个字节大,那么它存储的顺序是高位字节优先。例如,一个16位的参数存放时占用两个字节,其值为:

第一个字节*256+第二个字节字节码。

指令流一般只是字节对齐的。指令tableswitch和lookup是例外,在这两条指令内部要求强制的4字节边界对齐。

对于本地方法接口，实现JVM并不要求一定要有它的支持，甚至可以完全没有。Sun公司实现Java本地接口(JNI)是出于可移植性的考虑，当然我们也可以设计出其它的本地接口来代替Sun公司的JNI。但是这些设计与实现是比较复杂的事情，需要确保垃圾回收器不会将那些正在被本地方法调用的对象释放掉。

Java的堆是一个运行时数据区,类的实例(对象)从中分配空间，它的管理是由垃圾回收来负责的:不给程序员显式释放对象的能力。Java不规定具体使用的垃圾回收算法,可以根据系统的需求使用各种各样的算法。

Java方法区与传统语言中的编译后代码或是Unix进程中的正文段类似。它保存方法代码(编译后的java代码)和符号表。在当前的Java实现中,方法代码不包括在垃圾回收堆中,但计划在将来的版本中实现。每个类文件包含了一个Java类或一个Java界面的编译后的代码。可以说类文件是Java语言的执行代码文件。为了保证类文件的平台无关性,Java虚拟机规范中对类文件的格式也作了详细的说明。其具体细节请参考Sun公司的Java虚拟机规范。

Java虚拟机的寄存器用于保存机器的运行状态,与微处理器中的某些专用寄存器类似。Java虚拟机的寄存器有四种:

  1. pc: Java程序计数器；
  2. optop: 指向操作数栈顶端的指针；
  3. frame: 指向当前执行方法的执行环境的指针；。
  4. vars: 指向当前执行方法的局部变量区第一个变量的指针。

在上述体系结构图中，我们所说的是第一种，即程序计数器，每个线程一旦被创建就拥有了自己的程序计数器。当线程执行Java方法的时候，它包含该线程正在被执行的指令的地址。但是若线程执行的是一个本地的方法，那么程序计数器的值就不会被定义。

Java虚拟机的栈有三个区域:局部变量区、运行环境区、操作数区。

局部变量区

每个Java方法使用一个固定大小的局部变量集。它们按照与vars寄存器的字偏移量来寻址。局部变量都是32位的。长整数和双精度浮点数占据了两个局部变量的空间,却按照第一个局部变量的索引来寻址。(例如,一个具有索引n的局部变量,如果是一个双精度浮点数,那么它实际占据了索引n和n+1所代表的存储空间)虚拟机规范并不要求在局部变量中的64位的值是64位对齐的。虚拟机提供了把局部变量中的值装载到操作数栈的指令,也提供了把操作数栈中的值写入局部变量的指令。

运行环境区

在运行环境中包含的信息用于动态链接,正常的方法返回以及异常捕捉。

动态链接

运行环境包括对指向当前类和当前方法的解释器符号表的指针,用于支持方法代码的动态链接。方法的class文件代码在引用要调用的方法和要访问的变量时使用符号。动态链接把符号形式的方法调用翻译成实际方法调用,装载必要的类以解释还没有定义的符号,并把变量访问翻译成与这些变量运行时的存储结构相应的偏移地址。动态链接方法和变量使得方法中使用的其它类的变化不会影响到本程序的代码。

正常的方法返回

如果当前方法正常地结束了,在执行了一条具有正确类型的返回指令时,调用的方法会得到一个返回值。执行环境在正常返回的情况下用于恢复调用者的寄存器,并把调用者的程序计数器增加一个恰当的数值,以跳过已执行过的方法调用指令,然后在调用者的执行环境中继续执行下去。

异常捕捉

异常情况在Java中被称作Error(错误)或Exception(异常),是Throwable类的子类,在程序中的原因是:①动态链接错,如无法找到所需的class文件。②运行时错,如对一个空指针的引用。程序使用了throw语句。

当异常发生时,Java虚拟机采取如下措施:

  • 检查与当前方法相联系的catch子句表。每个catch子句包含其有效指令范围,能够处理的异常类型,以及处理异常的代码块地址。
  • 与异常相匹配的catch子句应该符合下面的条件:造成异常的指令在其指令范围之内,发生的异常类型是其能处理的异常类型的子类型。如果找到了匹配的catch子句,那么系统转移到指定的异常处理块处执行;如果没有找到异常处理块,重复寻找匹配的catch子句的过程,直到当前方法的所有嵌套的catch子句都被检查过。
  • 由于虚拟机从第一个匹配的catch子句处继续执行,所以catch子句表中的顺序是很重要的。因为Java代码是结构化的,因此总可以把某个方法的所有的异常处理器都按序排列到一个表中,对任意可能的程序计数器的值,都可以用线性的顺序找到合适的异常处理块,以处理在该程序计数器值下发生的异常情况。
  • 如果找不到匹配的catch子句,那么当前方法得到一个"未截获异常"的结果并返回到当前方法的调用者,好像异常刚刚在其调用者中发生一样。如果在调用者中仍然没有找到相应的异常处理块,那么这种错误将被传播下去。如果错误被传播到最顶层,那么系统将调用一个缺省的异常处理块。

操作数栈区

机器指令只从操作数栈中取操作数,对它们进行操作,并把结果返回到栈中。选择栈结构的原因是:在只有少量寄存器或非通用寄存器的机器(如Intel486)上,也能够高效地模拟虚拟机的行为。操作数栈是32位的。它用于给方法传递参数,并从方法接收结果,也用于支持操作的参数,并保存操作的结果。例如,iadd指令将两个整数相加。相加的两个整数应该是操作数栈顶的两个字。这两个字是由先前的指令压进堆栈的。这两个整数将从堆栈弹出、相加,并把结果压回到操作数栈中。

每个原始数据类型都有专门的指令对它们进行必须的操作。每个操作数在栈中需要一个存储位置,除了long和double型,它们需要两个位置。操作数只能被适用于其类型的操作符所操作。例如,压入两个int类型的数,如果把它们当作是一个long类型的数则是非法的。在Sun的虚拟机实现中,这个限制由字节码验证器强制实行。但是,有少数操作(操作符dupe和swap),用于对运行时数据区进行操作时是不考虑类型的。

本地方法栈，当一个线程调用本地方法时，它就不再受到虚拟机关于结构和安全限制方面的约束，它既可以访问虚拟机的运行期数据区，也可以使用本地处理器以及任何类型的栈。例如，本地栈是一个C语言的栈，那么当C程序调用C函数时，函数的参数以某种顺序被压入栈，结果则返回给调用函数。在实现Java虚拟机时，本地方法接口使用的是C语言的模型栈，那么它的本地方法栈的调度与使用则完全与C语言的栈相同。

3  Java虚拟机的运行过程

上面对虚拟机的各个部分进行了比较详细的说明，下面通过一个具体的例子来分析它的运行过程。

虚拟机通过调用某个指定类的方法main启动，传递给main一个字符串数组参数，使指定的类被装载，同时链接该类所使用的其它的类型，并且初始化它们。例如对于程序：

class HelloApp 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!"); 
		for (int i = 0; i < args.length; i++ )
		{
			System.out.println(args[i]);
		}
	}
}

编译后在命令行模式下键入： java HelloApp run virtual machine

将通过调用HelloApp的方法main来启动java虚拟机，传递给main一个包含三个字符串"run"、"virtual"、"machine"的数组。现在我们略述虚拟机在执行HelloApp时可能采取的步骤。

开始试图执行类HelloApp的main方法，发现该类并没有被装载，也就是说虚拟机当前不包含该类的二进制代表，于是虚拟机使用ClassLoader试图寻找这样的二进制代表。如果这个进程失败，则抛出一个异常。类被装载后同时在main方法被调用之前，必须对类HelloApp与其它类型进行链接然后初始化。链接包含三个阶段：检验，准备和解析。检验检查被装载的主类的符号和语义，准备则创建类或接口的静态域以及把这些域初始化为标准的默认值，解析负责检查主类对其它类或接口的符号引用，在这一步它是可选的。类的初始化是对类中声明的静态初始化函数和静态域的初始化构造方法的执行。一个类在初始化之前它的父类必须被初始化。整个过程如下：

图4：虚拟机的运行过程

4  结束语

本文通过对JVM的体系结构的深入研究以及一个Java程序执行时虚拟机的运行过程的详细分析，意在剖析清楚Java虚拟机的机理。

posted @ 2006-10-15 15:39 阿成 阅读(333) | 评论 (0) | 编辑 收藏
正则表达式

struts的validator资料见：struts validator

附一个正则表达式的资料：

正则表达式

　　正则表达式(regular expression)描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。
　　列目录时，　dir *.txt或ls *.txt中的*.txt就

不是一个正则表达式,因为这里*与正则式的*的含义是不同的。

　　为便于理解和记忆，先从一些概念入手，所有特殊字符或字符组合有一个总表在后面，最后一些例子供理解相应的概念。

正则表达式


　　是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。
　　可以通过在一对分隔符之间放入表达式模式的各种组件来构造一个正则表达式，即/expression/

普通字符


　　由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。

非打印字符


字符 含义
\cx 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。

特殊字符


　　所谓特殊字符，就是一些有特殊含义的字符，如上面说的"*.txt"中的*，简单的说就是表示任何字符串的意思。如果要查找文件名中有＊的文件，则需要对＊进行转义，即在其前加一个\。ls \*.txt。正则表达式有以下特殊字符。

特别字符说明
$匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
( )标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
*匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
+匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
.匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。
[ 标记一个中括号表达式的开始。要匹配 [，请使用 \[。
?匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
^匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
{标记限定符表达式的开始。要匹配 {，请使用 \{。
|指明两项之间的一个选择。要匹配 |，请使用 \|。


　　构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与操作符将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。


限定符


　　限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有*或+或?或{n}或{n,}或{n,m}共6种。
*、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。
　　正则表达式的限定符有：

字符 描述
* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。

定位符


　　用来描述字符串或单词的边界，^和$分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。

不能对定位符使用限定符。

选择


　　用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，是相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。
　　其中?:是非捕获元之一，还有两个非捕获元是?=和?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

后向引用


　　对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容存储。存储子匹配的缓冲区编号从 1 开始，连续编号直至最大 99 个子表达式。每个缓冲区都可以使用 '\n' 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
　　可以使用非捕获元字符 '?:', '?=', or '?!' 来忽略对相关匹配的保存。

各种操作符的运算优先级


　　相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下：

操作符 描述
\ 转义符
(), (?:), (?=), [] 圆括号和方括号
*, +, ?, {n}, {n,}, {n,m} 限定符
^, $, \anymetacharacter 位置和顺序
| “或”操作

全部符号解释


字符 描述
\ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
* 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+ 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
? 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n} n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,} n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
(pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern) 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern) 负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y 匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz] 字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz] 负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z] 字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\cx 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
\xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。.
\num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
\n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

部分例子


正则表达式说明
/\b([a-z]+) \1\b/gi一个单词连续出现的位置
/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/ 将一个URL解析为协议、域、端口及相对路径
/^(?:Chapter|Section) [1-9][0-9]{0,1}$/定位章节的位置
/[-a-z]/A至z共26个字母再加一个-号。
/ter\b/可匹配chapter，而不能terminal
/\Bapt/可匹配chapter，而不能aptitude
/Windows(?=95 |98 |NT )/可匹配Windows95或Windows98或WindowsNT,当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。
posted @ 2006-10-13 09:36 阿成 阅读(292) | 评论 (0) | 编辑 收藏
出了点车祸
前两天晚上在经过一个十字路口的时候，不知中了什么邪，跑着横穿马路，正好被一个出租车撞上，

撞的偶pp上，那叫一个险。幸亏是撞的pp上，而且车速不算快。身上是些皮外伤。

所以奉劝大家宁等3小时，别抢1妙。

要是真有急事儿，非要抢那1妙，那就别犹豫，跑快点。
posted @ 2006-10-09 08:57 阿成 阅读(324) | 评论 (0) | 编辑 收藏
101了
真的很快，工作了感觉时间过得太快了。真是time fly啊

明天就101了，感觉刚过完51。

回家修养几天。
posted @ 2006-09-30 17:06 阿成 阅读(260) | 评论 (0) | 编辑 收藏
2006－9－26
现在我最缺什么？最需求在哪些方面改进？
最近一些小事让我逐渐意识到自己这工作一年多来一直没有重视或者说不敢的弱点。我开始问自己现在在社会上混，都需要些什么？我一一列举，作为程序员，我开始想到java、数据库、服务器、、、、、、，发现，都是一些技术方面的。光有这些行吗？肯定不行。开始想到了一些其他的东西，圆滑，这两个字没那么简单，里面有着一系列东西。我问自己，我作为一个写程序的技术人员，他妈的我需要干这个？我做到了吗？我没做做到。而且差的很远很远。说这些不是脑子一热，或者什么凭空想象，是所见所闻。而我得性格似乎与这个东西有隔阂，似乎不太容易做到，而且对它产生了烦感和误解。看着茫茫人海，各奔前程，我也逐渐开始理解了。如果你没有做到或像我一样或不理解，就仔细观察一下周围的环境，会明白的。经过反复的思考，决定该改正一些了。但我不会超越我自己的一些底线，我会对自己认准的朋友保持一颗真诚的心，不敢说已做到仗义，讲义气，但会一直为之努力。也希望每个人在圆滑的同时尽量保留自己的底线。我也会尽快的适应这个所谓的高科技时代。
posted @ 2006-09-26 14:35 阿成 阅读(188) | 评论 (0) | 编辑 收藏
怀柔一日游

部门的经理挺好，周末组织部门同事去怀柔玩了一次，因为国庆、中秋快到了。
这次和上次去秦皇岛还没隔多长时间。

早上7点就起床了，吃完早饭，大家到齐之后就出发了。

先去的红螺寺，这原来是一个皇家寺院。里面的大佛听多。阿弥托佛、释迦摩尼、药师佛等等，

然后又看了500罗汉，据说里面总能找到一个与你想的。中午吃饭，点了好几条虹尊鱼，顿的，烤的都吃了，不过觉得一般。下午去了神堂裕，里面是一些小溪呀，山呀，在里面走走不错，回归大自然，净化一下，在工作呀、学习呀都能提高效率。

晚上回来后已经快7点了，接着腐败，找地儿吃饭。挺爽的。

十一之后逐渐变冷估计今年即便有活动，也是在市里了。下次出去估计的明年了。

posted @ 2006-09-26 14:04 阿成 阅读(255) | 评论 (0) | 编辑 收藏
用js的eval方法计算表达式

<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title></title>
<script language=javascript>
function fTxtKeyDown(obj)
{
  if(event.keyCode == 32)
  {
    event.returnValue=false;
    //空格键
    var sRet;
    try {
      sRet = eval(obj.value);
    }
    catch(e) {
    }
    if (isNaN(sRet))
    {
      alert("计算式输入错误");
    }
    else
    {
        obj.value=sRet;
    }
  }
}

</script>
</head>

<body>
<font size="2">输入表达式（如：3*2-4）后，按空格键得到结果 try</font><br>
<br>
<input type=text onkeydown="fTxtKeyDown(this);" size="42">
</body>

</html>

posted @ 2006-09-21 21:20 阿成 阅读(999) | 评论 (0) | 编辑 收藏
一些常用正则表达式、java
"^\\d+$"　　//非负整数（正整数   +   0）    
  "^[0-9]*[1-9][0-9]*$"　　//正整数    
  "^((-\\d+)|(0+))$"　　//非正整数（负整数   +   0）    
  "^-[0-9]*[1-9][0-9]*$"　　//负整数    
  "^-?\\d+$"　　　　//整数    
  "^\\d+(\\.\\d+)?$"　　//非负浮点数（正浮点数   +   0）    
  "^(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正浮点数    
  "^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$"　　//非正浮点数（负浮点数   +   0）    
  "^(-(([0-9]+\\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负浮点数    
  "^(-?\\d+)(\\.\\d+)?$"　　//浮点数    
  "^[A-Za-z]+$"　　//由26个英文字母组成的字符串    
  "^[A-Z]+$"　　//由26个英文字母的大写组成的字符串    
  "^[a-z]+$"　　//由26个英文字母的小写组成的字符串    
  "^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符串    
  "^\\w+$"　　//由数字、26个英文字母或者下划线组成的字符串    
  "^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$"　　　　//email地址    
  "^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$"　　//url
posted @ 2006-09-20 16:57 阿成 阅读(323) | 评论 (0) | 编辑 收藏
js表单验证
<title>表单验证类 Validator v1.01</title>
 <style>
 body,td{font:normal 12px Verdana;color:#333333}
 input,textarea,select,td{font:normal 12px Verdana;color:#333333;border:1px solid #999999;background:#ffffff}
 table{border-collapse:collapse;}
 td{padding:3px}
 input{height:20;}
 textarea{width:80%;height:50px;overfmin:auto;}
 form{display:inline}
 </style>
 <table align="center">
  <form name="theForm" id="demo" action="" method="get" onSubmit="return Validator.Validate(this,2)">
    <tr>
   <td>真实姓名：</td><td><input name="Name" dataType="Chinese" msg="真实姓名只允许中文"></td>
  </tr>
  <tr>
   <td>英文名：</td><td><input name="Nick" dataType="English" require="false" msg="英文名只允许英文字母"></td>
  </tr>
    <tr>
   <td>主页：</td><td><input name="Homepage" require="false" dataType="Url"   msg="非法的Url"></td>
  </tr>
  <tr>
   <td>密码：</td><td><input name="Password" dataType="SafeString"   msg="密码不符合安全规则" type="password"></td>
  </tr>
  <tr>
   <td>重复：</td><td><input name="Repeat" dataType="Repeat" to="Password" msg="两次输入的密码不一致" type="password"></td>
  </tr>
  <tr>
   <td>信箱：</td><td><input name="Email" dataType="Email" msg="信箱格式不正确"></td>
  </tr>
    <tr>
   <td>信箱：</td><td><input name="Email" dataType="Repeat" to="Email" msg="两次输入的信箱不一致"></td>
  </tr>
  <tr>
   <td>QQ：</td><td><input name="QQ" require="false" dataType="QQ" msg="QQ号码不存在"></td>
  </tr>
    <tr>
   <td>身份证：</td><td><input name="Card" dataType="IdCard" msg="身份证号码不正确"></td>
  </tr>
  <tr>
   <td>年龄：</td><td><input name="Year" dataType="Range" msg="年龄必须在18~28之间" min="18" max="28"></td>
  </tr>
   <tr>
   <td>年龄1：</td><td><input name="Year1" require="false" dataType="Compare" msg="年龄必须在18以上" to="18" operator="GreaterThanEqual"></td>
  </tr>
   <tr>
   <td>电话：</td><td><input name="Phone" require="false" dataType="Phone" msg="电话号码不正确"></td>
  </tr>
   <tr>
   <td>手机：</td><td><input name="Mobile" require="false" dataType="Mobile" msg="手机号码不正确"></td>
  </tr>
     <tr>
   <td>生日：</td><td><input name="Birthday" dataType="Date" format="ymd" msg="生日日期不存在"></td>
  </tr>
   <tr>
   <td>邮政编码：</td><td><input name="Zip" dataType="Custom" regexp="^[1-9]\d{5}$" msg="邮政编码不存在"></td>
  </tr>
  <tr>
   <td>邮政编码：</td><td><input name="Zip1" dataType="Zip" msg="邮政编码不存在"></td>
  </tr>
  <tr>
   <td>操作系统：</td><td><select name="Operation" dataType="Require"  msg="未选择所用操作系统" ><option value="">选择您所用的操作系统</option><option value="Win98">Win98</option><option value="Win2k">Win2k</option><option value="WinXP">WinXP</option></select></td>
  </tr>
  <tr>
   <td>所在省份：</td><td>广东<input name="Province" value="1" type="radio">陕西<input name="Province" value="2" type="radio">浙江<input name="Province" value="3" type="radio">江西<input name="Province" value="4" type="radio" dataType="Group"  msg="必须选定一个省份" ></td>
  </tr>
  <tr>
   <td>爱好：</td><td>运动<input name="Favorite" value="1" type="checkbox">上网<input name="Favorite" value="2" type="checkbox">听音乐<input name="Favorite" value="3" type="checkbox">看书<input name="Favorite" value="4" type="checkbox"" dataType="Group" min="2" max="3"  msg="必须选择2~3种爱好"></td>
  </tr>
   <td>自我介绍：</td><td><textarea name="Description" dataType="Limit" max="10"  msg="自我介绍内容必须在10个字之内">中文是一个字</textarea></td>
  </tr>
     <td>自传：</td><td><textarea name="History" dataType="LimitB" min="3" max="10"  msg="自传内容必须在[3,10]个字节之内">中文是两个字节t</textarea></td>
  </tr>
  <tr>
   <td colspan="2"><input name="Submit" type="submit" value="确定提交"><input onClick="Validator.Validate(document.getElementById('demo'))" value="检验模式1" type="button"><input onClick="Validator.Validate(document.getElementById('demo'),2)" value="检验模式2" type="button"><input onClick="Validator.Validate(document.getElementById('demo'),3)" value="检验模式3" type="button"></td>
  </tr>
  </form>
 </table>
 <script>
 /*************************************************
 Validator v1.01
 code by 我佛山人
 wfsr@cunite.com
 http://www.cunite.com
*************************************************/
 Validator = {
 Require : /.+/,
 Email : /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/,
 Phone : /^((\(\d{3}\))|(\d{3}\-))?(\(0\d{2,3}\)|0\d{2,3}-)?[1-9]\d{6,7}$/,
 Mobile : /^((\(\d{3}\))|(\d{3}\-))?13\d{9}$/,
 Url : /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/,
 IdCard : /^\d{15}(\d{2}[A-Za-z0-9])?$/,
 Currency : /^\d+(\.\d+)?$/,
 Number : /^\d+$/,
 Zip : /^[1-9]\d{5}$/,
 QQ : /^[1-9]\d{4,8}$/,
 Integer : /^[-\+]?\d+$/,
 Double : /^[-\+]?\d+(\.\d+)?$/,
 English : /^[A-Za-z]+$/,
 Chinese :  /^[\u0391-\uFFE5]+$/,
 UnSafe : /^(([A-Z]*|[a-z]*|\d*|[-_\~!@#\$%\^&\*\.\(\)\[\]\{\}<>\?\\\/\'\"]*)|.{0,5})$|\s/,
 IsSafe : function(str){return !this.UnSafe.test(str);},
 SafeString : "this.IsSafe(value)",
 Limit : "this.limit(value.length,getAttribute('min'),  getAttribute('max'))",
 LimitB : "this.limit(this.LenB(value), getAttribute('min'), getAttribute('max'))",
 Date : "this.IsDate(value, getAttribute('min'), getAttribute('format'))",
 Repeat : "value == document.getElementsByName(getAttribute('to'))[0].value",
 Range : "getAttribute('min') < value && value < getAttribute('max')",
 Compare : "this.compare(value,getAttribute('operator'),getAttribute('to'))",
 Custom : "this.Exec(value, getAttribute('regexp'))",
 Group : "this.MustChecked(getAttribute('name'), getAttribute('min'), getAttribute('max'))",
 ErrorItem : [document.forms[0]],
 ErrorMessage : ["以下原因导致提交失败：\t\t\t\t"],
 Validate : function(theForm, mode){
  var obj = theForm || event.srcElement;
  var count = obj.elements.length;
  this.ErrorMessage.length = 1;
  this.ErrorItem.length = 1;
  this.ErrorItem[0] = obj;
  for(var i=0;i<count;i++){
   with(obj.elements[i]){
    var _dataType = getAttribute("dataType");
    if(typeof(_dataType) == "object" || typeof(this[_dataType]) == "undefined")  continue;
    this.ClearState(obj.elements[i]);
    if(getAttribute("require") == "false" && value == "") continue;
    switch(_dataType){
     case "Date" :
     case "Repeat" :
     case "Range" :
     case "Compare" :
     case "Custom" :
     case "Group" :
     case "Limit" :
     case "LimitB" :
     case "SafeString" :
      if(!eval(this[_dataType])) {
       this.AddError(i, getAttribute("msg"));
      }
      break;
     default :
      if(!this[_dataType].test(value)){
       this.AddError(i, getAttribute("msg"));
      }
      break;
    }
   }
  }
  if(this.ErrorMessage.length > 1){
   mode = mode || 1;
   var errCount = this.ErrorItem.length;
   switch(mode){
   case 2 :
    for(var i=1;i<errCount;i++)
     this.ErrorItem[i].style.color = "red";
   case 1 :
    alert(this.ErrorMessage.join("\n"));
    this.ErrorItem[1].focus();
    break;
   case 3 :
    for(var i=1;i<errCount;i++){
    try{
     var span = document.createElement("SPAN");
     span.id = "__ErrorMessagePanel";
     span.style.color = "red";
     this.ErrorItem[i].parentNode.appendChild(span);
     span.innerHTML = this.ErrorMessage[i].replace(/\d+:/,"*");
     }
     catch(e){alert(e.description);}
    }
    this.ErrorItem[1].focus();
    break;
   default :
    alert(this.ErrorMessage.join("\n"));
    break;
   }
   return false;
  }
  return true;
 },
 limit : function(len,min, max){
  min = min || 0;
  max = max || Number.MAX_VALUE;
  return min <= len && len <= max;
 },
 LenB : function(str){
  return str.replace(/[^\x00-\xff]/g,"**").length;
 },
 ClearState : function(elem){
  with(elem){
   if(style.color == "red")
    style.color = "";
   var lastNode = parentNode.childNodes[parentNode.childNodes.length-1];
   if(lastNode.id == "__ErrorMessagePanel")
    parentNode.removeChild(lastNode);
  }
 },
 AddError : function(index, str){
  this.ErrorItem[this.ErrorItem.length] = this.ErrorItem[0].elements[index];
  this.ErrorMessage[this.ErrorMessage.length] = this.ErrorMessage.length + ":" + str;
 },
 Exec : function(op, reg){
  return new RegExp(reg,"g").test(op);
 },
 compare : function(op1,operator,op2){
  switch (operator) {
   case "NotEqual":
    return (op1 != op2);
   case "GreaterThan":
    return (op1 > op2);
   case "GreaterThanEqual":
    return (op1 >= op2);
   case "LessThan":
    return (op1 < op2);
   case "LessThanEqual":
    return (op1 <= op2);
   default:
    return (op1 == op2);           
  }
 },
 MustChecked : function(name, min, max){
  var groups = document.getElementsByName(name);
  var hasChecked = 0;
  min = min || 1;
  max = max || groups.length;
  for(var i=groups.length-1;i>=0;i--)
   if(groups[i].checked) hasChecked++;
  return min <= hasChecked && hasChecked <= max;
 },
 IsDate : function(op, formatString){
  formatString = formatString || "ymd";
  var m, year, month, day;
  switch(formatString){
   case "ymd" :
    m = op.match(new RegExp("^((\\d{4})|(\\d{2}))([-./])(\\d{1,2})\\4(\\d{1,2})$"));
    if(m == null ) return false;
    day = m[6];
    month = m[5]--;
    year =  (m[2].length == 4) ? m[2] : GetFullYear(parseInt(m[3], 10));
    break;
   case "dmy" :
    m = op.match(new RegExp("^(\\d{1,2})([-./])(\\d{1,2})\\2((\\d{4})|(\\d{2}))$"));
    if(m == null ) return false;
    day = m[1];
    month = m[3]--;
    year = (m[5].length == 4) ? m[5] : GetFullYear(parseInt(m[6], 10));
    break;
   default :
    break;
  }
  if(!parseInt(month)) return false;
  month = month==12 ?0:month;
  var date = new Date(year, month, day);
        return (typeof(date) == "object" && year == date.getFullYear() && month == date.getMonth() && day == date.getDate());
  function GetFullYear(y){return ((y<30 ? "20" : "19") + y)|0;}
 }
 }
</script>
posted @ 2006-09-20 14:01 阿成 阅读(324) | 评论 (0) | 编辑 收藏
htmlparser例子
import  org.htmlparser.Node;
 import  org.htmlparser.NodeFilter;
 import  org.htmlparser.Parser;
 import  org.htmlparser.filters.TagNameFilter;
 import  org.htmlparser.tags.TableTag;
 import  org.htmlparser.util.NodeList;

 /**
 * <br>
 * 标题: <br>
 * 功能概要: <br>
 * 版权: cityyouth.cn (c) 2005 <br>
 * 公司:上海城市青年网 <br>
 * 创建时间:2005-12-21 <br>
 * 修改时间: <br>
 * 修改原因：
 * 
 *  @author  张伟
 *  @version  1.0
  */
public   class  TestYahoo {
     public   static   void  testHtml() {
         try  {
            String sCurrentLine;
            String sTotalString;
            sCurrentLine  =   "" ;
            sTotalString  =   "" ;
            java.io.InputStream l_urlStream;
            java.net.URL l_url  =   new  java.net.URL(
                     " http://sports.sina.com.cn/iframe/nba/live/ " );
            java.net.HttpURLConnection l_connection  =  (java.net.HttpURLConnection) l_url
                    .openConnection();
            l_connection.connect();
            l_urlStream  =  l_connection.getInputStream();
            java.io.BufferedReader l_reader  =   new  java.io.BufferedReader(
                     new  java.io.InputStreamReader(l_urlStream));
             while  ((sCurrentLine  =  l_reader.readLine())  !=   null ) {
                sTotalString  +=  sCurrentLine;
            }
            System.out.println(sTotalString);

            System.out.println( " ==================== " );
            String testText  =  extractText(sTotalString);
            System.out.println(testText);
        }  catch  (Exception e) {
            e.printStackTrace();
        }

    }

     /**
     * 抽取纯文本信息
     * 
     *  @param  inputHtml
     *  @return
      */
     public   static  String extractText(String inputHtml)  throws  Exception {
        StringBuffer text  =   new  StringBuffer();

        Parser parser  =  Parser.createParser( new  String(inputHtml.getBytes(),
                 " 8859_1 " ),  " 8859-1 " );
         //  遍历所有的节点
        NodeList nodes  =  parser.extractAllNodesThatMatch( new  NodeFilter() {
             public   boolean  accept(Node node) {
                 return   true ;
            }
        });
        Node node  =  nodes.elementAt( 0 );
        text.append( new  String(node.toPlainTextString().getBytes( " 8859_1 " )));
         return  text.toString();
    }

     /**
     * 读取文件的方式来分析内容. filePath也可以是一个Url.
     * 
     *  @param  resource
     *            文件/Url
      */
     public   static   void  test5(String resource)  throws  Exception {
        Parser myParser  =   new  Parser(resource);

         //  设置编码
        myParser.setEncoding( " GBK " );
        String filterStr  =   " table " ;
        NodeFilter filter  =   new  TagNameFilter(filterStr);
        NodeList nodeList  =  myParser.extractAllNodesThatMatch(filter);
        TableTag tabletag  =  (TableTag) nodeList.elementAt( 11 );
            
            System.out.println(tabletag.toHtml());
            
            System.out.println( " ============== " );

    }

     /*
     * public static void main(String[] args) { TestYahoo testYahoo = new
     * TestYahoo(); testYahoo.testHtml(); }
      */
     public   static   void  main(String[] args)  throws  Exception {
        test5( " http://sports.yahoo.com/nba/scoreboard " );
    }
}
posted @ 2006-09-15 10:04 阿成 阅读(3951) | 评论 (0) | 编辑 收藏
使用 Spring 更好地处理 Struts 动作
     摘要: 三种整合 Struts 应用程序与 Spring 的方式 ...  阅读全文
posted @ 2006-09-12 15:11 阿成 阅读(207) | 评论 (0) | 编辑 收藏
OOD原则：SRP、OCP以及LSP
单一职责原则（SRP : Single Response Principle)

就一个类而言，应该仅有一个引起它变化的原因。
在这里，职责的定义是： “变化的原因”。

对于何时遵循SRP有以下的考虑：
1.如果应用程序的变化会影响到类中某一种职责，那么就应该将它与另一种职责分开，这样做可以避免客户应用程序和类中的这两职责耦合在一起。
2.如果应用程序的变化总是会导致两个职责同时变化，那么就不必要分离它们。实际上，分离它们会引起不必要的复杂性。

从上可以得知：变化的轴线仅当变化实际发生时才具有真正的意义。如果没有征兆，那么去应用SRP，或者任何其它原则都是不明智。

实际应用：持久化（Persistence）
实际开发中，考虑到业务规则是会频繁改变的，而持久化的方式却不会如此频繁的变化，并且变化的原因也是完全不同的。如果把业务规则和持久化方式绑定到一起，就会为以后的开发、维护造成麻烦。运用分层（layer）架构模式或者TDD开发方式可以很早分离这两个职责，特殊情况下，还可以使用FACADE或者PROXY模式对设计进行重构，分离这两个职责。

开闭原则（OCP : The Open-Close Principle)

描述：软件实体（类、模型、函数等等）应该是可以扩展的，但是不可修改。

遵循开闭原则设计出的模块具有两个主要的特征。它们是：
1. “对于扩展是开放的”（Open for extension）。
   这意味着模块的行为是可以扩展的。当应用的需要改变时，我们可以对模块进行扩展，使其具有满足那些改变的新行为。换句话说，我们可以改变模块的功能。
2. “对于更改是封闭的”（Closed for modification）。
   对模块行为进行扩展时，不必改动模块的源代码或者二进制代码。模块的二进制可执行版本，无论是可链接的库、DLL或者Java的.jar文件，都无需改动。

对于OCP，关键的是 抽象
模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，所以它对于更改可以是关闭的。同时，通过从这个抽象体派生，也可以扩展此模块的行为。

在许多方面，OCP都是面向对象设计的核心所在。但实际应用中，滥用OCP原则也是错误的。正确的做法是应该仅仅对程序中呈现出频繁变化的那些部分做出抽象。拒绝不成熟的抽象和抽象本身一样重要。


Liskov替换原则（LSP）

描述：子类型（subtype）必须能够替换掉它们的基类型（base type）。

此原则是Barbara Liskov首次在1988年写下的。所以就叫做Liskov替换原则。她如此写到：
“这里需要如下替换性质：若对每个类型S的对象o1，都存在一个类型T的对象o2，使得在所有针对T编写的程序P中，用o1替换o2后，程序P行为功能不变，则S是T的子类型。

LSP然我们得出一个非常重要的结论：一个模型，如果孤立的看，并不具有真正意义上的有效性。模型的有效性只能通过它的客户程序来表现。

在考虑一个特定设计是否恰当时，不能完全孤立的来看这个解决方案。必须要根据该设计的使用者所做出的合理假设来审视它。

有谁知道设计的使用者会做出什么样的合理假设呢？大多数这样的假设都很难预测。事实上，如果试图去预测所有这些假设，我们所得到的系统很可能会充满不必要的复杂性的臭味。因此，像所有其它原则一样了，通常最好的办法就是只预测那些最明显的对于LSP的违反情况，而推迟所有其它的预测，直到出现相关的脆弱性的臭味时，才去处理它们。

IS-A是关于行为的。
LSP清晰的指出，OOD中IS－A关系是就行为方式而言的，行为方式是可以进行合理假设的，是客户程序所依赖的。

基于契约设计
基于契约设计（DBC：Design By Contract）。使用DBC，类的编写者能够显式的规定针对该类的契约。客户代码的编写者可以通过该契约获悉可以依赖的行为方式。契约是通过为每个方法声明的前置条件（preconditions)和后置条件（postconditions)来指定的。要使一个方法得以执行，前置条件必须要为真。执行完毕后，该方法要保证后置条件为真。

在单元测试中指定契约
也可以通过编写单元测试的方式来指定契约。客户代码编写者会去查看这些单元测试，这样他们就可以知道对于要使用的类，应该做什么合理的假设。

启发式规则和习惯用法

1.派生类中的退化函数
  在基类中实现了f()方法，在派生类中的函数f()就是退化的，派生类中的退化函数并不总表示为违反LSP，但是当存在这种情况时，还是值得注意一下的。
2.从派生类中抛出异常
  在派生类的方法中添加了其基类不会抛出的异常。如果基类的使用者不期望这些异常，那么把它们添加到派生类的方法中就会导致不可替换性。此时要遵循LSP，要么就必须改变使用者的期望，要么派生类就不应该抛出这些异常。

总结：OCP是OOD中很多原则的核心。如果这个原则应用的有效，应用程序就会具有更多的可维护性、可重用性以及健壮性。LSP是使OCP成为可能的主要原则之一。正是子类型的可替换性才使得使用基类类型的模块在无需修改的情况下就可以扩展。这种可替换性必须是开发人员可以隐式依赖的。因此，如果没有显式的强制基类类型的契约，那么代码就必须良好的并且明显的表达出这一点。
      术语IS-A的含义过于广泛以至于不能作为子类型的定义。子类型的正确定义是“可替换性”，这里的可替换性可以通过显式或者隐式的契约来定义。


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

相关文章：

posted @ 2006-09-06 20:35 阿成 阅读(318) | 评论 (0) | 编辑 收藏
一些java术语
Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。

　　Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。

　　Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。

　　Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字.

　　Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。

　　API 应用程序接口:提供特定功能的一组相关的类和方法的集合。

　　Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。

　　Automatic variables 自动变量:也称为方法局部变量method local variables，声明在方法体中的变量

　　AWT抽象窗口工具集:一个独立的API平台提供用户界面功能。

　　Base class 基类:即被扩展继承的类。

　　Blocked state 阻塞状态:当一个线程等待资源时即处于阻塞状态。阻塞状态不使用处理器资源

　　Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。

　　Casting 类型转换 :即一个类型到另一个类型的转换

　　char 字符:容纳单字符的一种基本数据类型。

　　Child class 子类:见继承类Derived class

　　Class 类:面向对象中的最基本、最重要的定义类型。

　　Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。

　　Class methods 类方法:类方法通常是指的静态方法

　　Class variable 类变量:见静态变量Static variable

　　Collection 容器类:容器类可以看作是一种可以储存其他对象的对象

　　Collection interface 容器类接口:容器类接口定义了一个对所有容器类的公共接口。

　　Collections framework 容器类构架:接口、实现和算法三个元素构成了容器类的架构。

　　Constructor 构造函数:在对象创建或者实例化时候被调用的方法。

　　Containers容器:容器是一种特殊的组件，它可以容纳其他组件。

　　Declaration 声明:声明即是在源文件中描述类、接口、方法、包或者变量的语法。

　　Derived class 继承类:继承类是扩展继承某个类的类。

　　Encapsulation 封装性:封装性体现了面向对象程序设计的一个特性

　　Event classes 事件类:所有的事件类都定义在java.awt.event包中。

　　Event sources 事件源:产生事件的组件或对象称为事件源。

　　Exception 异常:异常是一种对象类型,异常还指应用中发生的一种非标准流程情况，即异常状态

　　Extensibility扩展性:扩展性指的是面向对象程序中，不需要重写代码和重新设计，能容易的
             增强源设计的功能。

　　Finalizer 收尾:每个类都有一个特殊的方法finalizer，它不能被直接调用，而被JVM在适当的
           时候调用，通常用来处理一些清理资源的工作，因此称为收尾机制。

　　Garbage collection 垃圾回收机制:当需要分配的内存空间不再使用的时候，JVM将调用垃圾
           回收机制来回收内存空间。

　　Guarded region 监控区域:一段用来监控错误产生的代码。

　　Heap堆:Java中管理内存的结构称作堆。

　　Identifiers 标识符:即指定类、方法、变量的名字。注意Java是大小写敏感的语言。

　　Import statement 引入语法:引入语法允许你可以不使用某个类的全名就可以参考这个类。

　　Inheritance 继承:继承是面向对象程序设计的重要特点，它是一种处理方法，通过这一方法，
             一个对象可以获得另一个对象的特征。

　　Inner classes 内部类:内部类与一般的类相似，只是它被声明在类的内部，或者甚至某个
             类方法体中。

　　Instance 实例:类实例化以后成为一个对象。

　　Instance variable 实例变量

　　Interface 接口:接口定义的是一组方法或者一个公共接口，它必须通过类来实现。

　　Java source file Java源文件:Java源程序包含的是Java程序语言计算机指令。

　　Java Virtual Machine (JVM) Java虚拟机:解释和执行Java字节码的程序，其中Java字节码
             由Java编译器生成。

　　javac Java编译器:Javac是Java编译程序的名称。

　　JVM Java虚拟机:见Java虚拟机

　　Keywords 关键字:即Java中的保留字，不能用作其他的标识符。

　　Layout managers 布局管理器:布局管理器是一些用来负责处理容器中的组件布局排列的类。

　　Local inner classes 局部内部类:在方法体中，或者甚至更小的语句块中定义的内部类。

　　Local variable 局部变量:在方法体中声明的变量

　　Member inner classes 成员内部类:定义在封装类中的没有指定static修饰符的内部类。

　　Members 成员:类中的元素，包括方法和变量。

　　Method 方法:完成特定功能的一段源代码，可以传递参数和返回结果，定义在类中。

　　Method local variables 方法局部变量:见自动变量Automatic variables

　　Modifier 修饰符:用来修饰类、方法或者变量行为的关键字。

　　Native methods 本地方法:本地方法是指使用依赖平台的语言编写的方法，它用来完成Java
                 无法处理的某些依赖于平台的功能。

　　Object 对象:一旦类实例化之后就成为对象。

　　Overloaded methods 名称重载方法:方法的名称重载是指同一个类中具有多个方法，使用相同
                    的名称而只是其参数列表不同。

　　Overridden methods 覆盖重载方法:方法的覆盖重载是指父类和子类使用的方法采用同样的
                    名称、参数列表和返回类型。

　　Package 包:包即是将一些类聚集在一起的一个实体。

　　Parent class 父类:被其他类继承的类。也见基类。

　　Private members 私有成员:私有成员只能在当前类被访问，其他任何类都不可以访问之。

　　Public members 公共成员:公共成员可以被任何类访问，而不管该类属于那个包。

　　Runtime exceptions 运行时间异常:运行时间异常是一种不能被你自己的程序处理的异常。
                   通常用来指示程序BUG。

　　Source file 源文件:源文件是包含你的Java代码的一个纯文本文件。

　　Stack trace 堆栈轨迹:如果你需要打印出某个时间的调用堆栈状态，你将产生一个堆栈轨迹。

　　Static inner classes 静态内部类:静态内部类是内部类最简单的形式，它于一般的类很相似，
                   除了被定义在了某个类的内部。

　　Static methods 静态方法:静态方法声明一个方法属于整个类，即它可以不需要实例化一个类
                就可以通过类直接访问之。

　　Static variable 静态变量:也可以称作类变量。它类似于静态方法，也是可以不需要实例化类
               就可以通过类直接访问。

　　Superclass 超类:被一个或多个类继承的类。

　　Synchronized methods 同步方法:同步方法是指明某个方法在某个时刻只能由一个线程访问。

　　Thread 线程:线程是一个程序内部的顺序控制流。

　　Time-slicing 时间片:调度安排线程执行的一种方案。

　　Variable access 变量访问控制:变量访问控制是指某个类读或者改变一个其他类中的变量的能力。

　　Visibility 可见性: 可见性体现了方法和实例变量对其他类和包的访问控制。


J2EE相关名词解释:

　　容器：充当中间件的角色

　　WEB容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接更容器中的环境变量接口交互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。

　　EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。

　　WEB容器和EJB容器在原理上是大体相同的，更多的区别是被隔离的外界环境。WEB容器更多的是跟基于HTTP的请求打交道。而EJB容器不是。它是更多的跟数据库、其它服务打交道。但他们都是把与外界的交互实现从而减轻应用程序的负担。例如SERVLET不用关心HTTP的细节，直接引用环境变量session,request,response就行、EJB不用关心数据库连接速度、各种事务控制，直接由容器来完成。

　　RMI/IIOP:远程方法调用/internet对象请求中介协议，他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。

　　JNDI:JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。

　　JMS:JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。

　　JAVAMAIL:JAVA邮件服务。提供邮件的存储、传输功能。他是JAVA编程中实现邮件功能的核心。相当MS中的EXCHANGE开发包。

　　JTA：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
　　
　　JAF:JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。

　　EAI:企业应用集成。是一种概念，从而牵涉到好多技术。J2EE技术是一种很好的集成实现。
posted @ 2006-09-05 10:11 阿成 阅读(316) | 评论 (0) | 编辑 收藏
contentType 和 pageEncoding
ContentType
ContentType属性指定了MIME类型和JSP页面回应时的字符编码方式。MIME类型的默认值是“text/html”; 字符编码方式的默认值是“ISO-8859-1”. MIME类型和字符编码方式由分号隔开

pageEncoding
pageEncoding 在JSP标准的语法中，如果pageEncoding属性存在，那么JSP页面的字符编码方式就由pageEncoding决定，否则就由contentType属性中的charset决定，如果charset也不存在，JSP页面的字符编码方式就采用默认的ISO-8859-1。
posted @ 2006-09-05 09:37 阿成 阅读(292) | 评论 (0) | 编辑 收藏
转帖]计算机主机网关的作用是什么？
假设你的名字叫小不点，你住在一个大院子里，你的邻居有很多小伙伴，在门口传达室还有个看大门的李大爷，李大爷就是你的网关。当你想跟院子里的某个小伙伴玩，只要你在院子里大喊一声他的名字，他听到了就会回应你，并且跑出来跟你玩。

但是你不被允许走出大门，你想与外界发生的一切联系，都必须由门口的李大爷（网关）用电话帮助你联系。假如你想找你的同学小明聊天，小明家住在很远的另外一个院子里，他家的院子里也有一个看门的王大爷（小明的网关）。但是你不知道小明家的电话号码，不过你的班主任老师有一份你们班全体同学的名单和电话号码对照表，你的老师就是你的DNS服务器。于是你在家里拨通了门口李大爷的电话，有了下面的对话：

小不点：李大爷，我想找班主任查一下小明的电话号码行吗？

李大爷：好，你等着。（接着李大爷给你的班主任挂了一个电话，问清楚了小明的电话）问到了，他家的号码是211.99.99.99

小不点：太好了！李大爷，我想找小明，你再帮我联系一下小明吧。

李大爷：没问题。（接着李大爷向电话局发出了请求接通小明家电话的请求，最后一关当然是被转接到了小明家那个院子的王大爷那里，然后王大爷把电话给转到小明家）

就这样你和小明取得了联系。

至于DHCP服务器嘛，可以这样比喻：

你家院子里的居民越来越多了，传达室李大爷那里的电话交换机已经不能满足这么多居民的需求了，所以只好采用了一种新技术叫做DHCP，居民们开机的时候随机得到一个电话号码，每一次得到的号码都可能会不同。

你家门口的李大爷：就是你的网关

你的班主任：就是你的DNS服务器

传达室的电话交换机：就是你的DHCP服务器

同上，李大爷和王大爷之间的对话就叫做路由。

另：如果还有个小朋友叫做小暗，他住的院子看门的是孙大爷，因为小暗的院子刚盖好，孙大爷刚来不久，他没有李大爷和王大爷办公室的电话（李大爷和王大爷当然也没有他的电话），这时会有两种情况：

1、居委会的赵大妈告诉了孙大爷关于李、王两位大爷的电话（同时赵大妈也告诉了李、王关于孙的电话），这就叫静态设定路由

2、赵大妈病了，孙大爷自己到处打电话，见人就说：“我是小暗他们院子管电话的”，结果被李、王二位听到了，就记在了他们的通讯录上，然后李、王就给孙大爷回了个电话说：“我是小明（小不点）他们院子管电话的”，这就叫动态设定路由

然后有一天小不点要找小暗，结果自然是小不点给李大爷打电话说：“大爷，我找小暗”（这里省略了李大爷去查小暗电话的过程，假设他知道小暗的电话），李大爷一找通讯录：“哦，小暗的院子的电话是孙大爷管着的，要找小暗自然先要通知孙大爷，我可以通知王大爷让他去找孙大爷，也可以自己直接找孙，那当然是自己直接找孙方便了”，于是李大爷给孙大爷打了电话，然后孙大爷又把电话转到了小暗家。

这里李大爷的通讯录叫做路由表。

李大爷选择是自己直接找孙大爷还是让王大爷帮忙转接叫做路由选择。

李大爷之所以选择直接找孙大爷是有依据的，因为他直接找孙大爷就能一步到位，如果要王大爷转接就需要两步才能完成，这里的“步”叫做“跳数”，李大爷的选择遵循的是最少步骤（跳数）原则（如果他不遵守这个原则，小不点可能就会多等些时间才能找到小暗，最终结果可能导致李大爷因工作不力被炒鱿鱼，这叫做“延时太长，选路原则不合理，换了一个路由器”）

当然，事情总是变化的，小不点和小明吵架了，这些天小不点老是给小暗打电话，小明心里想：“操，他是不是在说我坏话啊？”于是小明决定偷听小不点和小暗的通话，但是他又不能出院子，怎么办呢？小明做了这样一个决定：

首先他告诉自己院里管电话的王大爷说：“你给李大爷打个电话说小暗搬到咱们院子了，以后凡是打给他的电话我来接”，王大爷没反映过来（毕竟年纪大了啊！）就给李大爷打了电话，说：“现在我来管理小暗的电话了，孙已经不管了”，结果李大爷就把他的通讯录改了，这叫做路由欺骗。

以后小不点再找小暗，李大爷就转给王大爷了（其实应该转给孙大爷的），王大爷收到了这个电话就转给了小明（因为他之前已经和小明说好了），小明收到这个电话就假装小暗和小不点通信。因为小明作贼心虚，害怕明天小不点和小暗见面后当面问他，于是通信断了之后，又自己以小不点的名义给小暗通了个电话复述了一遍刚才的话，有这就叫数据窃听。

再后来，小不点还是不断的和小暗联系，而零落了小明，小明心里嘀咕啊：“我不能总是这样以小暗的身份和小不点通话啊，外一有一天露馅了怎么办！”于是他想了一个更阴险的招数：“干脆我也不偷听你们的电话了，你小不点不是不给我打电话吗！那我让你也给小暗打不了，哼哼！”，他怎么做的呢？我们来看：

他联系了一批狐朋狗友，和他们串通好，每天固定一个时间大家一起给小暗院子传达室打电话，内容什么都有，只要传达室的孙爷爷接电话，就会听到“打雷啦，下雨收衣服啊！”、“人是人他妈生的，妖是妖他妈生的”、“你妈贵姓”等等，听的脑袋都大了，不听又不行，电话不停的响啊！终于有一天，孙爷爷忍不住了，大喊一声：“我受不了拉！！！！”，于是上吊自杀了！

这就是最简单的DDOS攻击，孙爷爷心理承受能力弱的现象叫做“数据报处理模块有BUG”，孙爷爷的自杀叫做“路由器瘫痪”。如果是我，就会微笑着和他们拉家常，例如告诉他们“我早就听了天气预报，衣服10分钟前已经收好了”或者“那你妈是人还是妖”或者“和你奶奶一个姓”等等，我这种健全的心理叫做“健壮的数据报处理，能够抵御任何攻击”

孙爷爷瘫了之后，小不点终于不再给小暗打电话了，因为无论他怎么打对方都是忙音，这种现象叫做“拒绝服务”，所以小明的做法还有一个名字叫做“拒绝服务攻击”。

小明终于安静了几天，...

几天后，小明的院子来了一个美丽的女孩，名字叫做小丽，小明很喜欢她（小小年纪玩什么早恋！）可是小丽有个很帅的男朋友，小明干瞪眼没办法。当然这里还是要遵循上面的原则：小丽是不能出院子的。那个男的想泡小丽自然只能打电话，于是小明又蠢蠢欲动了：

还记得王爷爷是院子的电话总管吗？他之所以能管理电话是因为他有一个通讯录，因为同一个院子可能有2个孩子都叫小明，靠名字无法区分，所以通讯录上每一行只有两项：

门牌 电话

一号门 1234567 （这个是小明的）

二号门 7654321 （这个是小丽的）

......

王爷爷记性不好，但这总不会错了吧（同一个院子不会有2个“二号门”吧）？每次打电话人家都要说出要找的电话号码，然后通过通讯录去院子里面敲门，比如人家说我找“1234567”，于是王爷爷一比较，哦，是一号门的，他就去敲一号门“听电话”，如果是找“7654321”，那他就找二号门“听电话”。

这里的电话号码就是传说中的“IP地址”

这里的门牌号就是传说中的网卡的’MAC‘地址（每一块网卡的MAC地址都是不一样的，这是网卡的制造商写死在网卡的芯片中的）

小明心里想“奶奶的，老子泡不到你也别想泡”，于是他打起了王爷爷通讯录的主意，经过细心的观察，周密的准备，他终于发现王爷爷有尿频的毛病（毕竟是老人啊...），终于在一个月黑风高的白天，王爷爷去上厕所了，小明偷偷的摸进传达室，小心翼翼的改了王爷爷的通讯录......

过了几天，小丽的男朋友又给小丽打来了电话，对方报的电话是“7654321”，王爷爷一看通讯录，靠：

门牌 电话

一号门 1234567 （这个是小明的）

一号门 7654321 （注意：这个原来是小丽的，但是被小明改了）

......

王爷爷不知道改了啊，于是就去找一号门的小明了，小明心里这个美啊，他以小丽父亲的口吻严厉的教训了那个男的和小丽之间不正当的男女关系，结果那个男的恭恭敬敬的挂了电话。当然小丽并不知道整个事情的发生...

这里小明的行为叫做“ARP欺骗”（因为在实际的网络上是通过发送ARP数据包来实现的，所以叫做“ARP欺骗”），王爷爷的通讯录叫做“ARP表”

这里要注意：王爷爷现在有两个通讯录了，一个是记录每个院子传达室电话的本本，叫做“路由表”，一个是现在说的记录院子里面详细信息的本本，叫做“ARP表”。

有句命言是“人们总是在追求完美的，尽管永远也做不到”（请记住这句话，因为这是一个大名人--也就是我，说的）

王爷爷的制度中有一条是这么写的“每个月要重新检查一下门牌号和电话的对应本（也就是ARP表）”，这个动作叫做“刷新ARP表”，每个月的时间限制叫做“刷新ARP表的周期”。这样小明为了让那个男的永远不能找到小丽，之后每个月都要偷偷改一次那个通讯录，不过这样也是不得不做的事啊！

补充一点，小明是很聪明的，如果通讯录（ARP表）被改成了这样：

门牌（MAC） 电话（IP）

一号门 1234567 （这个是小明的）

二号门 1234567 （注意：这个被小明改了，但是他一时头晕改错了）

......

就会是计算机就会弹出一个对话框提示“出现重复的IP地址”，最终会导致王爷爷不知所措，于是通知一号门和二号门，你们的电话重复了。这样小丽就知道有人在破坏她的好事，这个现象叫做“骗局被揭穿了”

小不点知道了小明偷听他和小暗的电话，于是就和小暗约定好了密码。小不点在家里把要说的加密了之后告诉小暗。土豆－〉星期三，地瓜－〉请客，笨蛋－〉小不点家。于是小不点告诉小暗：土豆笨蛋地瓜。小明听了？？？不懂。。。。郁闷了。。。这是加密。

除此之外，小丽也知道了小明改他家的电话号码了。于是王爷爷就登门一个一个把电话和门牌号记下来。并且藏起来不允许外人修改，只能自己有钥匙（密码）。这是ip地址和MAC地址绑定。当有人改了电话号码的时候，就得找王爷爷改。麻烦是麻烦了，但是安全了。不过小明偷偷的把王爷爷的钥匙偷配了一把（盗窃密码成功），于是他还可以修改。这样么，就这样了。
posted @ 2006-09-04 20:16 阿成 阅读(214) | 评论 (0) | 编辑 收藏
对Servlet的初始化的理解

版权所有，转载请声明出处 zhyiwww@163.com

在读我自己的认识之前 , 我们先来看一下 servet 的结构图 :

servlet.png
以下是我自己的一点浅见：

①　 Servlet 在初始化的时候 , 是通过 init(ServletConfig  config) 或 init() 来执行的。

ServletConfig 是一个接口，它怎样传递给他一格对象来进行初始化呢？其实，是这个对象是由 servlet 容器来实例化的，由容器产生一格 ServletConfig 的实现类的对象，然后传递给 Servlet

结论： ServletConfig 由容器实例化

②　 我们有些时候可能在 Servlet 初始化时给它一些固定的配置参数，那么这些参数是怎样传递到 Servlet 呢？

其实，我们在 web.xml 中给 servlet 配置启动参数，在容器对 servlet 进行初始化的时候，会收集你所配置的参数，记录在 ServletConfig 的实现类中，所以你才可以通过 ServletConfig 对象的

    public String getInitParameter(String name); 或

    public Enumeration getInitParameterNames();

方法来取得你已经配置好的参数，也就是说，你对 servlet 的配置都已经记录在 ServletConfig 对象中了。

结论：你对 Servlet 的配置，在 Servlet 的初始化时都由容器来收集并且记录到 ServletConfig 的实现类中。

 

③　 我们来看一个 Servlet 的配置

  <servlet>

    <servlet-name>index</servlet-name>

    <servlet-class>org.zy.pro.sw.servlet.IndexServlet</servlet-class>

    <init-param>

      <param-name>dbconfig</param-name>

      <param-value>/WEB-INF/dbconfig.xml</param-value>

    </init-param>

  </servlet>

在此，我们实现对数据库的配置文件的加载。

当 Servlet 初始化完成后，我们可以通过

String  dbconf=this.getServletConfig().getInitParameter("dbconfig")

来取得我们的配置的参数的值。

但是，我们仅能得到一个配置的字符串。之后我们可以通过配置文件取得我们的数据库的配置参数，然后对数据库进行初始化。

其实我们也可以通过传递一个类的名字串，然后再实例化。

    <init-param>

      <param-name>dbconfig</param-name>

      <param-value>org.zy.util.db.DBUtil</param-value>

    </init-param>

我们先取得配置参数：

String  dbconf=this.getServletConfig().getInitParameter("dbconfig") ；

然后通过

Class.forName(dbconf).getInstance();

来实例化对象，就可以实现对数据库的调用了。

结论：在 web.xml 中对 Servlet 的初始化，只能传递字符串类型的数据

④　 ServletContext

ServletContext 是负责和 Servlet 的上文和下文交互，上面和 Servlet 容器交互，下面和 Servlet 中的请求和相应进行交互。

在 ServletConfig 中，    

public ServletContext getServletContext(); 方法实现取得当前 ServletContext 的对象。

你可能要问， ServletContext 是一个接口，那么你如何取得他的对象呢？

其实这个问题和 ServletConfig 相同，都是在 Servlet 进行初始化的时候产生的对象，是由容器来初始化的。

posted @ 2006-09-04 17:25 阿成 阅读(352) | 评论 (0) | 编辑 收藏
Spring的事件处理机制
Spring本身有ApplicationEvent和ApplicationListener，ApplicationContext可以发布ApplicationEvent，然后ApplicationListener监听event并做出相应动作。但是这里的ApplicationEvent有个陷阱，它的传播范围和当前的ApplicationContext的级别有关，并不是系统中所有的ApplicationListener都可以收到所有的Event。
 
假设当前系统为一个典型的Struts+Spring+Hibernate系统，那么系统中至少会有两个ApplicationContext存在，一个时root ApplicationContext，一个是Servlet的ApplicationContext。root ApplicationContext中包含你所有在webApplicationContext.xml中定义的bean，Servlet的ApplicationContext则包含有所有在action-servlet.xml中定义的bean，需要注意的是root context中的bean是无法看到servlet context中的bean的。而在servlet context中的ApplicationListener也无法收到root context发布的ApplicationEvent。

http://sweetriver.spaces.live.com/blog/cns!367370EB9A9B2807!129.entry
posted @ 2006-09-04 09:10 阿成 阅读(549) | 评论 (0) | 编辑 收藏
[Jsp和Servlet]servlet简明教程【转载】
一、Servlet和JSP概述
  作 者 : 仙人掌工作室
  
  
  　　 1.1 Java Servlet及其特点
  
  　　 Servlet是Java技术对CGI编程的回答。Servlet程序在服务器端运行，动态地生成Web页面。与传统的CGI和许多其他类似CGI的技术相比，Java Servlet具有更高的效率，更容易使用，功能更强大，具有更好的可移植性，更节省投资（更重要的是， Servlet程序员收入要比Perl程序员高:-）：
  
  高效。
  
  在传统的CGI中，每个请求都要启动一个新的进程，如果CGI程序本身的执行时间较短，启动进程所需要的开销很可能反而超过实际执行时间。而在Servlet中，每个请求由一个轻量级的Java线程处理（而不是重量级的操作系统进程）。
  在传统CGI中，如果有N个并发的对同一CGI程序的请求，则该CGI程序的代码在内存中重复装载了N次；而对于Servlet，处理请求的是N个线程，只需要一份Servlet类代码。在性能优化方面，Servlet也比CGI有着更多的选择，比如缓冲以前的计算结果，保持数据库连接的活动，等等。
  
  
  方便。
  
  Servlet提供了大量的实用工具例程，例如自动地解析和解码HTML表单数据、读取和设置HTTP头、处理Cookie、跟踪会话状态等。
  
  
  功能强大。
  
  在Servlet中，许多使用传统CGI程序很难完成的任务都可以轻松地完成。例如，Servlet能够直接和Web服务器交互，而普通的CGI程序不能。Servlet还能够在各个程序之间共享数据，使得数据库连接池之类的功能很容易实现。
  
  
  可移植性好。
  
  Servlet用Java编写，Servlet API具有完善的标准。因此，为I-Planet Enterprise Server写的Servlet无需任何实质上的改动即可移植到Apache、Microsoft IIS或者WebStar。几乎所有的主流服务器都直接或通过插件支持Servlet。
  
  
  节省投资。
  
  不仅有许多廉价甚至免费的Web服务器可供个人或小规模网站使用，而且对于现有的服务器，如果它不支持Servlet的话，要加上这部分功能也往往是免费的（或只需要极少的投资）。
  　　 1.2 JSP及其特点
  
  　　 JavaServer Pages（JSP）是一种实现普通静态HTML和动态HTML混合编码的技术，有关JSP基础概念的说明请参见《JSP技术简介 》。
  
  　　 许多由CGI程序生成的页面大部分仍旧是静态HTML，动态内容只在页面中有限的几个部分出现。但是包括Servlet在内的大多数CGI技术及其变种，总是通过程序生成整个页面。JSP使得我们可以分别创建这两个部分。例如，下面就是一个简单的JSP页面：
  ＜!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"＞
  ＜HTML＞
  ＜HEAD＞＜TITLE＞欢迎访问网上商店＜/TITLE＞＜/HEAD＞
  ＜BODY＞
  ＜H1＞欢迎＜/H1＞
  ＜SMALL＞欢迎,
  ＜!-- 首次访问的用户名字为"New User" --＞
  ＜% out.println(Utils.getUserNameFromCookie(request)); %＞
  要设置帐号信息，请点击
  ＜A HREF="Account-Settings.html"＞这里＜/A＞＜/SMALL＞
  ＜P＞
  页面的其余内容。.
  ＜/BODY＞＜/HTML＞
  
  
  
  　　 下面是JSP和其他类似或相关技术的一个简单比较：
  
  JSP和Active Server Pages（ASP）相比
  
  Microsoft的ASP是一种和JSP类似的技术。JSP和ASP相比具有两方面的优点。首先，动态部分用Java编写，而不是VB Script或其他Microsoft语言，不仅功能更强大而且更易于使用。第二，JSP应用可以移植到其他操作系统和非Microsoft的Web服务器上。
  
  
  JSP和纯Servlet相比
  
  JSP并没有增加任何本质上不能用Servlet实现的功能。但是，在JSP中编写静态HTML更加方便，不必再用 println语句来输出每一行HTML代码。更重要的是，借助内容和外观的分离，页面制作中不同性质的任务可以方便地分开：比如，由页面设计专家进行HTML设计，同时留出供Servlet程序员插入动态内容的空间。
  
  
  JSP和服务器端包含（Server-Side Include，SSI）相比
  
  SSI是一种受到广泛支持的在静态HTML中引入外部代码的技术。JSP在这方面的支持更为完善，因为它可以用Servlet而不是独立的程序来生成动态内容。另外，SSI实际上只用于简单的包含，而不是面向那些能够处理表单数据、访问数据库的“真正的”程序。
  
  
  JSP和JavaScript相比
  
  JavaScript能够在客户端动态地生成HTML。虽然JavaScript很有用，但它只能处理以客户端环境为基础的动态信息。除了Cookie之外，HTTP状态和表单提交数据对JavaScript来说都是不可用的。另外，由于是在客户端运行，JavaScript不能访问服务器端资源，比如数据库、目录信息等等。
 2.1 安装Servlet和JSP开发工具
  
  　　 要学习Servlet和JSP开发，首先你必须准备一个符合Java Servlet 2.1/2.2和JavaServer Pages1.0/1.1规范的开发环境。Sun提供免费的JavaServer Web Development Kit（JSWDK），可以从http://java.sun.com/products/servlet/ 下载。
  
  　　 安装好JSWDK之后，你还要告诉javac，在编译文件的时候到哪里去寻找Servlet和JSP类。JSWDK安装指南对此有详细说明，但主要就是把servlet.jar和jsp.jar加入CLASSPATH。CLASSPATH是一个指示Java如何寻找类文件的环境变量，如果不设置CLASSPATH，Java在当前目录和标准系统库中寻找类；如果你自己设置了CLASSPATH，不要忘记包含当前目录（即在CLASSPATH中包含“.”）。
  
  　　 另外，为了避免和其他开发者安装到同一Web服务器上的Servlet产生命名冲突，最好把自己的Servlet放入包里面。此时，把包层次结构中的顶级目录也加入CLASSPATH会带来不少方便。请参见下文具体说明。
  
  　　 2.2 安装支持Servlet的Web服务器
  
  　　 除了开发工具之外，你还要安装一个支持Java Servlet的Web服务器，或者在现有的Web服务器上安装Servlet软件包。如果你使用的是最新的Web服务器或应用服务器，很可能它已经有了所有必需的软件。请查看Web服务器的文档，或访问http://java.sun.com/products/servlet/industry.html 查看支持Servlet的服务器软件清单。
  
  　　 虽然最终运行Servlet的往往是商业级的服务器，但是开始学习的时候，用一个能够在台式机上运行的免费系统进行开发和测试也足够了。下面是几种当前最受欢迎的产品。
  
  Apache Tomcat.
  
  Tomcat是Servlet 2.2和JSP 1.1规范的官方参考实现。Tomcat既可以单独作为小型Servlet、JSP测试服务器，也可以集成到Apache Web服务器。直到2000年早期，Tomcat还是唯一的支持Servlet 2.2和JSP 1.1规范的服务器，但已经有许多其它服务器宣布提供这方面的支持。
  
  Tomcat和Apache一样是免费的。不过，快速、稳定的Apache服务器安装和配置起来有点麻烦，Tomcat也有同样的缺点。和其他商业级Servlet引擎相比，配置Tomcat的工作量显然要多一点。具体请参见http://jakarta.apache.org/ 。
  
  
  JavaServer Web Development Kit (JSWDK).
  
  JSWDK是Servlet 2.1和JSP 1.0的官方参考实现。把Servlet和JSP应用部署到正式运行它们的服务器之前，JSWDK可以单独作为小型的Servlet、JSP测试服务器。JSWDK也是免费的，而且具有很好的稳定性，但它的安装和配置也较为复杂。具体请参见http://java.sun.com/products/servlet/download.html 。
  
  
  Allaire JRun.
  
  JRun是一个Servlet和JSP引擎，它可以集成到Netscape Enterprise或FastTrack Server、IIS、Microsoft Personal Web Server、版本较低的Apache、O'eilly的WebSite或者StarNine Web STAR。最多支持5个并发连接的限制版本是免费的，商业版本中不存在这个限制，而且增加了远程管理控制台之类的功能。具体请参见http://www.allaire.com/products/jrun/ 。
  
  
  New Atlanta 的ServletExec
  
  ServletExec是一个快速的Servlet和JSP引擎，它可以集成到大多数流行的Web服务器，支持平台包括Solaris、Windows、MacOS、HP-UX和Linux。ServletExec可以免费下载和使用，但许多高级功能和管理工具只有在购买了许可之后才可以使用。New Atlanta还提供一个免费的Servlet调试器，该调试器可以在许多流行的Java IDE下工作。具体请参见http://newatlanta.com/ 。
  
  
  Gefion的LiteWebServer (LWS)
  
  LWS是一个支持Servlet 2.2和JSP 1.1的免费小型Web服务器。 Gefion还有一个免费的WAICoolRunner插件，利用该插件可以为Netscape FastTrack和Enterprise Server增加Servlet 2.2和JSP 1.1支持。具体请参见http://www.gefionsoftware.com/ 。
  
  
  Sun的Java Web Server.
  
  该服务器全部用Java写成，而且是首先提供Servlet 2.1和JSP 1.0规范完整支持的Web服务器之一。虽然Sun现在已转向Netscape/I-Planet Server，不再发展Java Web Server，但它仍旧是一个广受欢迎的Servlet、JSP学习平台。要得到免费试用版本，请访问http://www.sun.com/software/jwebserver/try/ 。
 
3.1 Servlet基本结构
  
  　　 下面的代码显示了一个简单Servlet的基本结构。该Servlet处理的是GET请求，所谓的GET请求，如果你不熟悉HTTP，可以把它看成是当用户在浏览器地址栏输入URL、点击Web页面中的链接、提交没有指定METHOD的表单时浏览器所发出的请求。Servlet也可以很方便地处理POST请求。POST请求是提交那些指定了METHOD=“POST”的表单时所发出的请求，具体请参见稍后几节的讨论。
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  
  public class SomeServlet extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
  
   // 使用“request”读取和请求有关的信息（比如Cookies）
   // 和表单数据
  
   // 使用“response”指定HTTP应答状态代码和应答头
   // （比如指定内容类型，设置Cookie）
  
   PrintWriter out = response.getWriter();
   // 使用 "out"把应答内容发送到浏览器
   }
  }
  
  
  
  
  　　 如果某个类要成为Servlet，则它应该从HttpServlet 继承，根据数据是通过GET还是POST发送，覆盖doGet、doPost方法之一或全部。doGet和doPost方法都有两个参数，分别为HttpServletRequest 类型和HttpServletResponse 类型。HttpServletRequest提供访问有关请求的信息的方法，例如表单数据、HTTP请求头等等。HttpServletResponse除了提供用于指定HTTP应答状态（200，404等）、应答头（Content-Type，Set-Cookie等）的方法之外，最重要的是它提供了一个用于向客户端发送数据的PrintWriter 。对于简单的Servlet来说，它的大部分工作是通过println语句生成向客户端发送的页面。
  
  　　 注意doGet和doPost抛出两个异常，因此你必须在声明中包含它们。另外，你还必须导入java.io包（要用到PrintWriter等类）、javax.servlet包（要用到HttpServlet等类）以及javax.servlet.http包（要用到HttpServletRequest类和HttpServletResponse类）。
  
  　　 最后，doGet和doPost这两个方法是由service方法调用的，有时你可能需要直接覆盖service方法，比如Servlet要处理GET和POST两种请求时。
  
  　　 3.2 输出纯文本的简单Servlet
  
  　　 下面是一个输出纯文本的简单Servlet。
  
  　　 3.2.1 HelloWorld.java
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  
  public class HelloWorld extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   PrintWriter out = response.getWriter();
   out.println("Hello World");
   }
  }
  
  
  
  
  　　 3.2.2 Servlet的编译和安装
  
  　　 不同的Web服务器上安装Servlet的具体细节可能不同，请参考Web服务器文档了解更权威的说明。假定使用Java Web Server（JWS）2.0，则Servlet应该安装到JWS安装目录的servlets子目录下。在本文中，为了避免同一服务器上不同用户的Servlet命名冲突，我们把所有Servlet都放入一个独立的包hall中；如果你和其他人共用一个服务器，而且该服务器没有“虚拟服务器”机制来避免这种命名冲突，那么最好也使用包。把Servlet放入了包hall之后，HelloWorld.java实际上是放在servlets目录的hall子目录下。
  
  　　 大多数其他服务器的配置方法也相似，除了JWS之外，本文的Servlet和JSP示例已经在BEA WebLogic和IBM WebSphere 3.0下经过测试。WebSphere具有优秀的虚拟服务器机制，因此，如果只是为了避免命名冲突的话并非一定要用包。
  
  　　 对于没有使用过包的初学者，下面我们介绍编译包里面的类的两种方法。
  
  　　 一种方法是设置CLASSPATH，使其指向实际存放Servlet的目录的上一级目录（Servlet主目录），然后在该目录中按正常的方式编译。例如，如果Servlet的主目录是C:＼JavaWebServer＼servlets，包的名字（即主目录下的子目录名字）是hall，在Windows下，编译过程如下：
   DOS＞ set CLASSPATH=C:＼JavaWebServer＼servlets;%CLASSPATH%
   DOS＞ cd C:＼JavaWebServer＼servlets＼hall
   DOS＞ javac YourServlet.java
  
  
  
  　　 第二种编译包里面的Servlet的方法是进入Servlet主目录，执行“javac directory＼YourServlet.java”（Windows）或者“javac directory/YourServlet.java”（Unix）。例如，再次假定Servlet主目录是C:＼JavaWebServer＼servlets，包的名字是hall，在Windows中编译过程如下：
   DOS＞ cd C:＼JavaWebServer＼servlets
   DOS＞ javac hall＼YourServlet.java
  
  
  
  　　 注意在Windows下，大多数JDK 1.1版本的javac要求目录名字后面加反斜杠(＼)。JDK1.2已经改正这个问题，然而由于许多Web服务器仍旧使用JDK 1.1，因此大量的Servlet开发者仍旧在使用JDK 1.1。
  
  　　 最后，Javac还有一个高级选项用于支持源代码和.class文件的分开放置，即你可以用javac的“-d”选项把.class文件安装到Web服务器所要求的目录。
  
  　　 3.2.3 运行Servlet
  
  　　 在Java Web Server下，Servlet应该放到JWS安装目录的servlets子目录下，而调用Servlet的URL是http://host/servlet/ServletName。注意子目录的名字是servlets（带“s”），而URL使用的是“servlet”。由于HelloWorld Servlet放入包hall，因此调用它的URL应该是http://host/servlet/hall.HelloWorld。在其他的服务器上，安装和调用Servlet的方法可能略有不同。
  
  　　 大多数Web服务器还允许定义Servlet的别名，因此Servlet也可能用http://host/any-path/any-file.html形式的URL调用。具体如何进行配置完全依赖于服务器类型，请参考服务器文档了解细节。
  
  　　 3.3 输出HTML的Servlet
  
  　　 大多数Servlet都输出HTML，而不象上例一样输出纯文本。要输出HTML还有两个额外的步骤要做：告诉浏览器接下来发送的是HTML；修改println语句构造出合法的HTML页面。
  
  　　 第一步通过设置Content-Type（内容类型）应答头完成。一般地，应答头可以通过HttpServletResponse的setHeader方法设置，但由于设置内容类型是一个很频繁的操作，因此Servlet API提供了一个专用的方法setContentType。注意设置应答头应该在通过PrintWriter发送内容之前进行。下面是一个实例：
  
  　　 HelloWWW.java
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  
  public class HelloWWW extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   out.println("＜!DOCTYPE HTML PUBLIC ＼"-//W3C//DTD HTML 4.0 " +
   "Transitional//EN＼"＞＼n" +
   "＜HTML＞＼n" +
   "＜HEAD＞＜TITLE＞Hello WWW＜/TITLE＞＜/HEAD＞＼n" +
   "＜BODY＞＼n" +
   "＜H1＞Hello WWW＜/H1＞＼n" +
   "＜/BODY＞＜/HTML＞");
   }
  }
  
  
  
  
  　　 3.4 几个HTML工具函数
  
  　　 通过println语句输出HTML并不方便，根本的解决方法是使用JavaServer Pages（JSP）。然而，对于标准的Servlet来说，由于Web页面中有两个部分（DOCTYPE和HEAD）一般不会改变，因此可以用工具函数来封装生成这些内容的代码。
  
  　　 虽然大多数主流浏览器都会忽略DOCTYPE行，但严格地说HTML规范是要求有DOCTYPE行的，它有助于HTML语法检查器根据所声明的HTML版本检查HTML文档合法性。在许多Web页面中，HEAD部分只包含＜TITLE＞。虽然许多有经验的编写者都会在HEAD中包含许多META标记和样式声明，但这里只考虑最简单的情况。
  
  　　 下面的Java方法只接受页面标题为参数，然后输出页面的DOCTYPE、HEAD、TITLE部分。清单如下：
  
  　　 ServletUtilities.java
  package hall;
  
  public class ServletUtilities {
   public static final String DOCTYPE =
   "＜!DOCTYPE HTML PUBLIC ＼"-//W3C//DTD HTML 4.0 Transitional//EN＼"＞";
  
   public static String headWithTitle(String title) {
   return(DOCTYPE + "＼n" +
   "＜HTML＞＼n" +
   "＜HEAD＞＜TITLE＞" + title + "＜/TITLE＞＜/HEAD＞＼n");
   }
  
   // 其他工具函数的代码在本文后面介绍
  }
  
  
  
  
  　　 HelloWWW2.java
  
  　　 下面是应用了ServletUtilities之后重写HelloWWW类得到的HelloWWW2：
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  
  public class HelloWWW2 extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   out.println(ServletUtilities.headWithTitle("Hello WWW") +
   "＜BODY＞＼n" +
   "＜H1＞Hello WWW＜/H1＞＼n" +
   "＜/BODY＞＜/HTML＞");
   }
  }
4.1 表单数据概述
  
  　　 如果你曾经使用过Web搜索引擎，或者浏览过在线书店、股票价格、机票信息，或许会留意到一些古怪的URL，比如“http://host/path?user=Marty+Hall&origin=bwi&dest=lax”。这个URL中位于问号后面的部分，即“user=Marty+Hall&origin=bwi&dest=lax”，就是表单数据，这是将Web页面数据发送给服务器程序的最常用方法。对于GET请求，表单数据附加到URL的问号后面（如上例所示）；对于POST请求，表单数据用一个单独的行发送给服务器。
  
  　　 以前，从这种形式的数据提取出所需要的表单变量是CGI编程中最麻烦的事情之一。首先，GET请求和POST请求的数据提取方法不同：对于GET请求，通常要通过QUERY_STRING环境变量提取数据；对于POST请求，则一般通过标准输入提取数据。第二，程序员必须负责在“&”符号处截断变量名字-变量值对，再分离出变量名字（等号左边）和变量值（等号右边）。第三，必须对变量值进行URL反编码操作。因为发送数据的时候，字母和数字以原来的形式发送，但空格被转换成加号，其他字符被转换成“%XX”形式，其中XX是十六进制表示的字符ASCII（或者ISO Latin-1）编码值。例如，如果HTML表单中名为“users”的域值为“~hall, ~gates, and ~mcnealy”，则实际向服务器发送的数据为“users=%7Ehall%2C+%7Egates%2C+and+%7Emcnealy”。最后，即第四个导致解析表单数据非常困难的原因在于，变量值既可能被省略（如“param1=val1＆param2=＆param3=val3”），也有可能一个变量拥有一个以上的值，即同一个变量可能出现一次以上（如“param1=val1＆param2=val2＆param1=val3”）。
  
  　　 Java Servlet的好处之一就在于所有上述解析操作都能够自动完成。只需要简单地调用一下HttpServletRequest的getParameter方法、在调用参数中提供表单变量的名字（大小写敏感）即可，而且GET请求和POST请求的处理方法完全相同。
  
  　　 getParameter方法的返回值是一个字符串，它是参数中指定的变量名字第一次出现所对应的值经反编码得到得字符串（可以直接使用）。如果指定的表单变量存在，但没有值，getParameter返回空字符串；如果指定的表单变量不存在，则返回null。如果表单变量可能对应多个值，可以用getParameterValues来取代getParameter。getParameterValues能够返回一个字符串数组。
  
  　　 最后，虽然在实际应用中Servlet很可能只会用到那些已知名字的表单变量，但在调试环境中，获得完整的表单变量名字列表往往是很有用的，利用getParamerterNames方法可以方便地实现这一点。getParamerterNames返回的是一个Enumeration，其中的每一项都可以转换为调用getParameter的字符串。
  
  　　 4.2 实例：读取三个表单变量
  
  　　 下面是一个简单的例子，它读取三个表单变量param1、param2和param3，并以HTML列表的形式列出它们的值。请注意，虽然在发送应答内容之前必须指定应答类型（包括内容类型、状态以及其他HTTP头信息），但Servlet对何时读取请求内容却没有什么要求。
  
  　　 另外，我们也可以很容易地把Servlet做成既能处理GET请求，也能够处理POST请求，这只需要在doPost方法中调用doGet方法，或者覆盖service方法（service方法调用doGet、doPost、doHead等方法）。在实际编程中这是一种标准的方法，因为它只需要很少的额外工作，却能够增加客户端编码的灵活性。
  
  　　 如果你习惯用传统的CGI方法，通过标准输入读取POST数据，那么在Servlet中也有类似的方法，即在HttpServletRequest上调用getReader或者getInputStream，但这种方法对普通的表单变量来说太麻烦。然而，如果是要上载文件，或者POST数据是通过专门的客户程序而不是HTML表单发送，那么就要用到这种方法。
  
  　　 注意用第二种方法读取POST数据时，不能再用getParameter来读取这些数据。
  
  　　 ThreeParams.java
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.util.*;
  
  public class ThreeParams extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   String title = "读取三个请求参数";
   out.println(ServletUtilities.headWithTitle(title) +
   "＜BODY＞＼n" +
   "＜H1 ALIGN=CENTER＞" + title + "＜/H1＞＼n" +
   "＜UL＞＼n" +
   " ＜LI＞param1: "
   + request.getParameter("param1") + "＼n" +
   " ＜LI＞param2: "
   + request.getParameter("param2") + "＼n" +
   " ＜LI＞param3: "
   + request.getParameter("param3") + "＼n" +
   "＜/UL＞＼n" +
   "＜/BODY＞＜/HTML＞");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  }
  
  
  
  
  　　 4.3 实例：输出所有的表单数据
  
  　　 下面这个例子寻找表单所发送的所有变量名字，并把它们放入表格中，没有值或者有多个值的变量都突出显示。
  
  　　 首先，程序通过HttpServletRequest的getParameterNames方法得到所有的变量名字，getParameterNames返回的是一个Enumeration。接下来，程序用循环遍历这个Enumeration，通过hasMoreElements确定何时结束循环，利用nextElement得到Enumeration中的各个项。由于nextElement返回的是一个Object，程序把它转换成字符串后再用这个字符串来调用getParameterValues。
  
  　　 getParameterValues返回一个字符串数组，如果这个数组只有一个元素且等于空字符串，说明这个表单变量没有值，Servlet以斜体形式输出“No Value”；如果数组元素个数大于1，说明这个表单变量有多个值，Servlet以HTML列表形式输出这些值；其他情况下Servlet直接把变量值放入表格。
  
  　　 ShowParameters.java
  
  　　 注意，ShowParameters.java用到了前面介绍过的ServletUtilities.java。
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.util.*;
  
  public class ShowParameters extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   String title = "读取所有请求参数";
   out.println(ServletUtilities.headWithTitle(title) +
   "＜BODY BGCOLOR=＼"#FDF5E6＼"＞＼n" +
   "＜H1 ALIGN=CENTER＞" + title + "＜/H1＞＼n" +
   "＜TABLE BORDER=1 ALIGN=CENTER＞＼n" +
   "＜TR BGCOLOR=＼"#FFAD00＼"＞＼n" +
   "＜TH＞参数名字＜TH＞参数值");
   Enumeration paramNames = request.getParameterNames();
   while(paramNames.hasMoreElements()) {
   String paramName = (String)paramNames.nextElement();
   out.println("＜TR＞＜TD＞" + paramName + "＼n＜TD＞");
   String[] paramValues = request.getParameterValues(paramName);
   if (paramValues.length == 1) {
   String paramValue = paramValues[0];
   if (paramValue.length() == 0)
   out.print("＜I＞No Value＜/I＞");
   else
   out.print(paramValue);
   } else {
   out.println("＜UL＞");
   for(int i=0; i＜paramValues.length; i++) {
   out.println("＜LI＞" + paramValues[i]);
   }
   out.println("＜/UL＞");
   }
   }
   out.println("＜/TABLE＞＼n＜/BODY＞＜/HTML＞");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  }
  
  
  
  
  　　 测试表单
  
  　　 下面是向上述Servlet发送数据的表单PostForm.html。就像所有包含密码输入域的表单一样，该表单用POST方法发送数据。我们可以看到，在Servlet中同时实现doGet和doPost这两种方法为表单制作带来了方便。
  ＜!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"＞
  ＜HTML＞
  ＜HEAD＞
   ＜TITLE＞示例表单＜/TITLE＞
  ＜/HEAD＞
  
  ＜BODY BGCOLOR="#FDF5E6"＞
  ＜H1 ALIGN="CENTER"＞用POST方法发送数据的表单＜/H1＞
  
  ＜FORM ACTION="/servlet/hall.ShowParameters"
   METHOD="POST"＞
   Item Number:
   ＜INPUT TYPE="TEXT" NAME="itemNum"＞＜BR＞
   Quantity:
   ＜INPUT TYPE="TEXT" NAME="quantity"＞＜BR＞
   Price Each:
   ＜INPUT TYPE="TEXT" NAME="price" VALUE="$"＞＜BR＞
   ＜HR＞
   First Name:
   ＜INPUT TYPE="TEXT" NAME="firstName"＞＜BR＞
   Last Name:
   ＜INPUT TYPE="TEXT" NAME="lastName"＞＜BR＞
   Middle Initial:
   ＜INPUT TYPE="TEXT" NAME="initial"＞＜BR＞
   Shipping Address:
   ＜TEXTAREA NAME="address" ROWS=3 COLS=40＞＜/TEXTAREA＞＜BR＞
   Credit Card:＜BR＞
   ＜INPUT TYPE="RADIO" NAME="cardType"
   VALUE="Visa"＞Visa＜BR＞
   ＜INPUT TYPE="RADIO" NAME="cardType"
   VALUE="Master Card"＞Master Card＜BR＞
   ＜INPUT TYPE="RADIO" NAME="cardType"
   VALUE="Amex"＞American Express＜BR＞
   ＜INPUT TYPE="RADIO" NAME="cardType"
   VALUE="Discover"＞Discover＜BR＞
   ＜INPUT TYPE="RADIO" NAME="cardType"
   VALUE="Java SmartCard"＞Java SmartCard＜BR＞
   Credit Card Number:
   ＜INPUT TYPE="PASSWORD" NAME="cardNum"＞＜BR＞
   Repeat Credit Card Number:
   ＜INPUT TYPE="PASSWORD" NAME="cardNum"＞＜BR＞＜BR＞
   ＜CENTER＞
   ＜INPUT TYPE="SUBMIT" VALUE="Submit Order"＞
   ＜/CENTER＞
  ＜/FORM＞
  
  ＜/BODY＞
  ＜/HTML＞
5.1 HTTP请求头概述
  
  　　 HTTP客户程序（例如浏览器），向服务器发送请求的时候必须指明请求类型（一般是GET或者POST）。如有必要，客户程序还可以选择发送其他的请求头。大多数请求头并不是必需的，但Content-Length除外。对于POST请求来说Content-Length必须出现。
  
  　　 下面是一些最常见的请求头：
  
  Accept：浏览器可接受的MIME类型。
  Accept-Charset：浏览器可接受的字符集。
  Accept-Encoding：浏览器能够进行解码的数据编码方式，比如gzip。Servlet能够向支持gzip的浏览器返回经gzip编码的HTML页面。许多情形下这可以减少5到10倍的下载时间。
  Accept-Language：浏览器所希望的语言种类，当服务器能够提供一种以上的语言版本时要用到。
  Authorization：授权信息，通常出现在对服务器发送的WWW-Authenticate头的应答中。
  Connection：表示是否需要持久连接。如果Servlet看到这里的值为“Keep-Alive”，或者看到请求使用的是HTTP 1.1（HTTP 1.1默认进行持久连接），它就可以利用持久连接的优点，当页面包含多个元素时（例如Applet，图片），显著地减少下载所需要的时间。要实现这一点，Servlet需要在应答中发送一个Content-Length头，最简单的实现方法是：先把内容写入ByteArrayOutputStream，然后在正式写出内容之前计算它的大小。
  Content-Length：表示请求消息正文的长度。
  Cookie：这是最重要的请求头信息之一，参见后面《Cookie处理》一章中的讨论。
  From：请求发送者的email地址，由一些特殊的Web客户程序使用，浏览器不会用到它。
  Host：初始URL中的主机和端口。
  If-Modified-Since：只有当所请求的内容在指定的日期之后又经过修改才返回它，否则返回304“Not Modified”应答。
  Pragma：指定“no-cache”值表示服务器必须返回一个刷新后的文档，即使它是代理服务器而且已经有了页面的本地拷贝。
  Referer：包含一个URL，用户从该URL代表的页面出发访问当前请求的页面。
  User-Agent：浏览器类型，如果Servlet返回的内容与浏览器类型有关则该值非常有用。
  UA-Pixels，UA-Color，UA-OS，UA-CPU：由某些版本的IE浏览器所发送的非标准的请求头，表示屏幕大小、颜色深度、操作系统和CPU类型。
  　　 有关HTTP头完整、详细的说明，请参见http://www.w3.org/Protocols/ 的HTTP规范。
  
  　　 5.2 在Servlet中读取请求头
  
  　　 在Servlet中读取HTTP头是非常方便的，只需要调用一下HttpServletRequest的getHeader方法即可。如果客户请求中提供了指定的头信息，getHeader返回对应的字符串；否则，返回null。部分头信息经常要用到，它们有专用的访问方法：getCookies方法返回Cookie头的内容，经解析后存放在Cookie对象的数组中，请参见后面有关Cookie章节的讨论；getAuthType和getRemoteUser方法分别读取Authorization头中的一部分内容；getDateHeader和getIntHeader方法读取指定的头，然后返回日期值或整数值。
  
  　　 除了读取指定的头之外，利用getHeaderNames还可以得到请求中所有头名字的一个Enumeration对象。
  
  　　 最后，除了查看请求头信息之外，我们还可以从请求主命令行获得一些信息。getMethod方法返回请求方法，请求方法通常是GET或者POST，但也有可能是HEAD、PUT或者DELETE。getRequestURI方法返回URI（URI是URL的从主机和端口之后到表单数据之前的那一部分）。getRequestProtocol返回请求命令的第三部分，一般是“HTTP/1.0”或者“HTTP/1.1”。
  
  　　 5.3 实例：输出所有的请求头
  
  　　 下面的Servlet实例把所有接收到的请求头和它的值以表格的形式输出。另外，该Servlet还会输出主请求命令的三个部分：请求方法，URI，协议/版本。
  
  　　 ShowRequestHeaders.java
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.util.*;
  
  public class ShowRequestHeaders extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   String title = "显示所有请求头";
   out.println(ServletUtilities.headWithTitle(title) +
   "＜BODY BGCOLOR=＼"#FDF5E6＼"＞＼n" +
   "＜H1 ALIGN=CENTER＞" + title + "＜/H1＞＼n" +
   "＜B＞Request Method: ＜/B＞" +
   request.getMethod() + "＜BR＞＼n" +
   "＜B＞Request URI: ＜/B＞" +
   request.getRequestURI() + "＜BR＞＼n" +
   "＜B＞Request Protocol: ＜/B＞" +
   request.getProtocol() + "＜BR＞＜BR＞＼n" +
   "＜TABLE BORDER=1 ALIGN=CENTER＞＼n" +
   "＜TR BGCOLOR=＼"#FFAD00＼"＞＼n" +
   "＜TH＞Header Name＜TH＞Header Value");
   Enumeration headerNames = request.getHeaderNames();
   while(headerNames.hasMoreElements()) {
   String headerName = (String)headerNames.nextElement();
   out.println("＜TR＞＜TD＞" + headerName);
   out.println(" ＜TD＞" + request.getHeader(headerName));
   }
   out.println("＜/TABLE＞＼n＜/BODY＞＜/HTML＞");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  }
6.1 CGI变量概述
  
  　　 如果你是从传统的CGI编程转而学习Java Servlet，或许已经习惯了“CGI变量”这一概念。CGI变量汇集了各种有关请求的信息：
  
  部分来自HTTP请求命令和请求头，例如Content-Length头；
  部分来自Socket本身，例如主机的名字和IP地址；
  也有部分与服务器安装配置有关，例如URL到实际路径的映射。
  　　 6.2 标准CGI变量的Servlet等价表示
  
  　　 下表假定request对象是提供给doGet和doPost方法的HttpServletRequest类型对象。 CGI变量 含义 从doGet或doPost访问
  AUTH_TYPE 如果提供了Authorization头，这里指定了具体的模式（basic或者digest）。 request.getAuthType()
  CONTENT_LENGTH 只用于POST请求，表示所发送数据的字节数。 严格地讲，等价的表达方式应该是String.valueOf(request.getContentLength())（返回一个字符串）。但更常见的是用request.getContentLength()返回含义相同的整数。
  CONTENT_TYPE 如果指定的话，表示后面所跟数据的类型。 request.getContentType()
  DOCUMENT_ROOT 与http://host/对应的路径。 getServletContext().getRealPath("/")
  注意低版本Servlet规范中的等价表达方式是request.getRealPath("/")。
  
  HTTP_XXX_YYY 访问任意HTTP头。 request.getHeader("Xxx-Yyy")
  PATH_INFO URL中的附加路径信息，即URL中Servlet路径之后、查询字符串之前的那部分。 request.getPathInfo()
  PATH_TRANSLATED 映射到服务器实际路径之后的路径信息。 request.getPathTranslated()
  QUERY_STRING 这是字符串形式的附加到URL后面的查询字符串，数据仍旧是URL编码的。在Servlet中很少需要用到未经解码的数据，一般使用getParameter访问各个参数。 request.getQueryString()
  REMOTE_ADDR 发出请求的客户机的IP地址。 request.getRemoteAddr()
  REMOTE_HOST 发出请求的客户机的完整的域名，如java.sun.com。如果不能确定该域名，则返回IP地址。 request.getRemoteHost()
  REMOTE_USER 如果提供了Authorization头，则代表其用户部分。它代表发出请求的用户的名字。 request.getRemoteUser()
  REQUEST_METHOD 请求类型。通常是GET或者POST。但偶尔也会出现HEAD，PUT， DELETE，OPTIONS，或者 TRACE. request.getMethod()
  SCRIPT_NAME URL中调用Servlet的那一部分，不包含附加路径信息和查询字符串。 request.getServletPath()
  SERVER_NAME Web服务器名字。 request.getServerName()
  SERVER_PORT 服务器监听的端口。 严格地说，等价表达应该是返回字符串的String.valueOf(request.getServerPort())。但经常使用返回整数值的request.getServerPort()。
  SERVER_PROTOCOL 请求命令中的协议名字和版本（即HTTP/1.0或HTTP/1.1）。 request.getProtocol()
  SERVER_SOFTWARE Servlet引擎的名字和版本。 getServletContext().getServerInfo()
  
  
  　　 6.3 实例：读取CGI变量
  
  　　 下面这个Servlet创建一个表格，显示除了HTTP_XXX_YYY之外的所有CGI变量。HTTP_XXX_YYY是HTTP请求头信息，请参见上一节介绍。
  
  　　 ShowCGIVariables.java
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.util.*;
  
  public class ShowCGIVariables extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   String[][] variables =
   { { "AUTH_TYPE", request.getAuthType() },
   { "CONTENT_LENGTH", String.valueOf(request.getContentLength()) },
   { "CONTENT_TYPE", request.getContentType() },
   { "DOCUMENT_ROOT", getServletContext().getRealPath("/") },
   { "PATH_INFO", request.getPathInfo() },
   { "PATH_TRANSLATED", request.getPathTranslated() },
   { "QUERY_STRING", request.getQueryString() },
   { "REMOTE_ADDR", request.getRemoteAddr() },
   { "REMOTE_HOST", request.getRemoteHost() },
   { "REMOTE_USER", request.getRemoteUser() },
   { "REQUEST_METHOD", request.getMethod() },
   { "SCRIPT_NAME", request.getServletPath() },
   { "SERVER_NAME", request.getServerName() },
   { "SERVER_PORT", String.valueOf(request.getServerPort()) },
   { "SERVER_PROTOCOL", request.getProtocol() },
   { "SERVER_SOFTWARE", getServletContext().getServerInfo() }
   };
   String title = "显示CGI变量";
   out.println(ServletUtilities.headWithTitle(title) +
   "＜BODY BGCOLOR=＼"#FDF5E6＼"＞＼n" +
   "＜H1 ALIGN=CENTER＞" + title + "＜/H1＞＼n" +
   "＜TABLE BORDER=1 ALIGN=CENTER＞＼n" +
   "＜TR BGCOLOR=＼"#FFAD00＼"＞＼n" +
   "＜TH＞CGI Variable Name＜TH＞Value");
   for(int i=0; i＜variables.length; i++) {
   String varName = variables[i][0];
   String varValue = variables[i][1];
   if (varValue == null)
   varValue = "＜I＞Not specified＜/I＞";
   out.println("＜TR＞＜TD＞" + varName + "＜TD＞" + varValue);
   }
   out.println("＜/TABLE＞＜/BODY＞＜/HTML＞");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  }
7.1 状态代码概述
  
  　　 Web服务器响应浏览器或其他客户程序的请求时，其应答一般由以下几个部分组成：一个状态行，几个应答头，一个空行，内容文档。下面是一个最简单的应答：
  HTTP/1.1 200 OK
  Content-Type: text/plain
  
  Hello World
  
  
  
  
  　　 状态行包含HTTP版本、状态代码、与状态代码对应的简短说明信息。在大多数情况下，除了Content-Type之外的所有应答头都是可选的。但Content-Type是必需的，它描述的是后面文档的MIME类型。虽然大多数应答都包含一个文档，但也有一些不包含，例如对HEAD请求的应答永远不会附带文档。有许多状态代码实际上用来标识一次失败的请求，这些应答也不包含文档（或只包含一个简短的错误信息说明）。
  
  　　 Servlet可以利用状态代码来实现许多功能。例如，可以把用户重定向到另一个网站；可以指示出后面的文档是图片、PDF文件或HTML文件；可以告诉用户必须提供密码才能访问文档；等等。这一部分我们将具体讨论各种状态代码的含义以及利用这些代码可以做些什么。
  
  　　 7.2 设置状态代码
  
  　　 如前所述，HTTP应答状态行包含HTTP版本、状态代码和对应的状态信息。由于状态信息直接和状态代码相关，而HTTP版本又由服务器确定，因此需要Servlet设置的只有一个状态代码。
  
  　　 Servlet设置状态代码一般使用HttpServletResponse的setStatus方法。setStatus方法的参数是一个整数（即状态代码），不过为了使得代码具有更好的可读性，可以用HttpServletResponse中定义的常量来避免直接使用整数。这些常量根据HTTP 1.1中的标准状态信息命名，所有的名字都加上了SC前缀（Status Code的缩写）并大写，同时把空格转换成了下划线。也就是说，与状态代码404对应的状态信息是“Not Found”，则HttpServletResponse中的对应常量名字为SC_NOT_FOUND。但有两个例外：和状态代码302对应的常量根据HTTP 1.0命名，而307没有对应的常量。
  
  　　 设置状态代码并非总是意味着不要再返回文档。例如，虽然大多数服务器返回404应答时会输出简单的“File Not Found”信息，但Servlet也可以定制这个应答。不过，定制应答时应当在通过PrintWriter发送任何内容之前先调用response.setStatus。
  
  　　 虽然设置状态代码一般使用的是response.setStauts(int)方法，但为了简单起见，HttpServletResponse为两种常见的情形提供了专用方法：sendError方法生成一个404应答，同时生成一个简短的HTML错误信息文档；sendRedirect方法生成一个302应答，同时在Location头中指示新文档的URL。
  
  　　 7.3 HTTP 1.1状态代码及其含义
  
  　　 下表显示了常见的HTTP 1.1状态代码以及它们对应的状态信息和含义。
  
  　　 应当谨慎地使用那些只有HTTP 1.1支持的状态代码，因为许多浏览器还只能够支持HTTP 1.0。如果你使用了HTTP 1.1特有的状态代码，最好能够检查一下请求的HTTP版本号（通过HttpServletRequest的getProtocol方法）。 状态代码 状态信息 含义
  100 Continue 初始的请求已经接受，客户应当继续发送请求的其余部分。（HTTP 1.1新）
  101 Switching Protocols 服务器将遵从客户的请求转换到另外一种协议（HTTP 1.1新）
  200 OK 一切正常，对GET和POST请求的应答文档跟在后面。如果不用setStatus设置状态代码，Servlet默认使用202状态代码。
  201 Created 服务器已经创建了文档，Location头给出了它的URL。
  202 Accepted 已经接受请求，但处理尚未完成。
  203 Non-Authoritative Information 文档已经正常地返回，但一些应答头可能不正确，因为使用的是文档的拷贝（HTTP 1.1新）。
  204 No Content 没有新文档，浏览器应该继续显示原来的文档。如果用户定期地刷新页面，而Servlet可以确定用户文档足够新，这个状态代码是很有用的。
  205 Reset Content 没有新的内容，但浏览器应该重置它所显示的内容。用来强制浏览器清除表单输入内容（HTTP 1.1新）。
  206 Partial Content 客户发送了一个带有Range头的GET请求，服务器完成了它（HTTP 1.1新）。
  300 Multiple Choices 客户请求的文档可以在多个位置找到，这些位置已经在返回的文档内列出。如果服务器要提出优先选择，则应该在Location应答头指明。
  301 Moved Permanently 客户请求的文档在其他地方，新的URL在Location头中给出，浏览器应该自动地访问新的URL。
  302 Found 类似于301，但新的URL应该被视为临时性的替代，而不是永久性的。注意，在HTTP1.0中对应的状态信息是“Moved Temporatily”，而HttpServletResponse中相应的常量是SC_MOVED_TEMPORARILY，而不是SC_FOUND。
  出现该状态代码时，浏览器能够自动访问新的URL，因此它是一个很有用的状态代码。为此，Servlet提供了一个专用的方法，即sendRedirect。使用response.sendRedirect(url)比使用response.setStatus(response.SC_MOVED_TEMPORARILY)和response.setHeader("Location",url)更好。这是因为：
  
  首先，代码更加简洁。
  第二，使用sendRedirect，Servlet会自动构造一个包含新链接的页面（用于那些不能自动重定向的老式浏览器）。
  最后，sendRedirect能够处理相对URL，自动把它们转换成绝对URL。
  注意这个状态代码有时候可以和301替换使用。例如，如果浏览器错误地请求http://host/~user（缺少了后面的斜杠），有的服务器返回301，有的则返回302。
  
  严格地说，我们只能假定只有当原来的请求是GET时浏览器才会自动重定向。请参见307。
  
  303 See Other 类似于301/302，不同之处在于，如果原来的请求是POST，Location头指定的重定向目标文档应该通过GET提取（HTTP 1.1新）。
  304 Not Modified 客户端有缓冲的文档并发出了一个条件性的请求（一般是提供If-Modified-Since头表示客户只想比指定日期更新的文档）。服务器告诉客户，原来缓冲的文档还可以继续使用。
  305 Use Proxy 客户请求的文档应该通过Location头所指明的代理服务器提取（HTTP 1.1新）。
  307 Temporary Redirect 和302（Found）相同。许多浏览器会错误地响应302应答进行重定向，即使原来的请求是POST，即使它实际上只能在POST请求的应答是303时才能重定向。由于这个原因，HTTP 1.1新增了307，以便更加清除地区分几个状态代码：当出现303应答时，浏览器可以跟随重定向的GET和POST请求；如果是307应答，则浏览器只能跟随对GET请求的重定向。
  注意，HttpServletResponse中没有为该状态代码提供相应的常量。（HTTP 1.1新）
  
  400 Bad Request 请求出现语法错误。
  401 Unauthorized 客户试图未经授权访问受密码保护的页面。应答中会包含一个WWW-Authenticate头，浏览器据此显示用户名字/密码对话框，然后在填写合适的Authorization头后再次发出请求。
  403 Forbidden 资源不可用。服务器理解客户的请求，但拒绝处理它。通常由于服务器上文件或目录的权限设置导致。
  404 Not Found 无法找到指定位置的资源。这也是一个常用的应答，HttpServletResponse专门提供了相应的方法：sendError(message)。
  405 Method Not Allowed 请求方法（GET、POST、HEAD、DELETE、PUT、TRACE等）对指定的资源不适用。（HTTP 1.1新）
  406 Not Acceptable 指定的资源已经找到，但它的MIME类型和客户在Accpet头中所指定的不兼容（HTTP 1.1新）。
  407 Proxy Authentication Required 类似于401，表示客户必须先经过代理服务器的授权。（HTTP 1.1新）
  408 Request Timeout 在服务器许可的等待时间内，客户一直没有发出任何请求。客户可以在以后重复同一请求。（HTTP 1.1新）
  409 Conflict 通常和PUT请求有关。由于请求和资源的当前状态相冲突，因此请求不能成功。（HTTP 1.1新）
  410 Gone 所请求的文档已经不再可用，而且服务器不知道应该重定向到哪一个地址。它和404的不同在于，返回407表示文档永久地离开了指定的位置，而404表示由于未知的原因文档不可用。（HTTP 1.1新）
  411 Length Required 服务器不能处理请求，除非客户发送一个Content-Length头。（HTTP 1.1新）
  412 Precondition Failed 请求头中指定的一些前提条件失败（HTTP 1.1新）。
  413 Request Entity Too Large 目标文档的大小超过服务器当前愿意处理的大小。如果服务器认为自己能够稍后再处理该请求，则应该提供一个Retry-After头（HTTP 1.1新）。
  414 Request URI Too Long URI太长（HTTP 1.1新）。
  416 Requested Range Not Satisfiable 服务器不能满足客户在请求中指定的Range头。（HTTP 1.1新）
  500 Internal Server Error 服务器遇到了意料不到的情况，不能完成客户的请求。
  501 Not Implemented 服务器不支持实现请求所需要的功能。例如，客户发出了一个服务器不支持的PUT请求。
  502 Bad Gateway 服务器作为网关或者代理时，为了完成请求访问下一个服务器，但该服务器返回了非法的应答。
  503 Service Unavailable 服务器由于维护或者负载过重未能应答。例如，Servlet可能在数据库连接池已满的情况下返回503。服务器返回503时可以提供一个Retry-After头。
  504 Gateway Timeout 由作为代理或网关的服务器使用，表示不能及时地从远程服务器获得应答。（HTTP 1.1新）
  505 HTTP Version Not Supported 服务器不支持请求中所指明的HTTP版本。（HTTP 1.1新）
  
  
  　　 7.4 实例：访问多个搜索引擎
  
  　　 下面这个例子用到了除200之外的另外两个常见状态代码：302和404。302通过sendRedirect方法设置，404通过sendError方法设置。
  
  　　 在这个例子中，首先出现的HTML表单用来选择搜索引擎、搜索字符串、每页显示的搜索结果数量。表单提交后，Servlet提取这三个变量，按照所选择的搜索引擎的要求构造出包含这些变量的URL，然后把用户重定向到这个URL。如果用户不能正确地选择搜索引擎，或者利用其他表单发送了一个不认识的搜索引擎名字，则返回一个提示搜索引擎找不到的404页面。
  
  　　 SearchEngines.java
  
  　　 注意：这个Servlet要用到后面给出的SearchSpec类，SearchSpec的功能是构造适合不同搜索引擎的URL。
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.net.*;
  
  public class SearchEngines extends HttpServlet {
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   // getParameter自动解码URL编码的查询字符串。由于我们
   // 要把查询字符串发送给另一个服务器，因此再次使用
   // URLEncoder进行URL编码
   String searchString =
   URLEncoder.encode(request.getParameter("searchString"));
   String numResults =
   request.getParameter("numResults");
   String searchEngine =
   request.getParameter("searchEngine");
   SearchSpec[] commonSpecs = SearchSpec.getCommonSpecs();
   for(int i=0; i＜commonSpecs.length; i++) {
   SearchSpec searchSpec = commonSpecs[i];
   if (searchSpec.getName().equals(searchEngine)) {
   String url =
   response.encodeURL(searchSpec.makeURL(searchString,
   numResults));
   response.sendRedirect(url);
   return;
   }
   }
   response.sendError(response.SC_NOT_FOUND,
   "No recognized search engine specified.");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  }
  
  
  
  
  　　 SearchSpec.java
  package hall;
  
  class SearchSpec {
   private String name, baseURL, numResultsSuffix;
  
   private static SearchSpec[] commonSpecs =
   { new SearchSpec("google",
   "http://www.google.com/search?q=",
   "&num="),
   new SearchSpec("infoseek",
   "http://infoseek.go.com/Titles?qt=",
   "&nh="),
   new SearchSpec("lycos",
   "http://lycospro.lycos.com/cgi-bin/pursuit?query=",
   "&maxhits="),
   new SearchSpec("hotbot",
   "http://www.hotbot.com/?MT=",
   "&DC=")
   };
  
   public SearchSpec(String name,
   String baseURL,
   String numResultsSuffix) {
   this.name = name;
   this.baseURL = baseURL;
   this.numResultsSuffix = numResultsSuffix;
   }
  
   public String makeURL(String searchString, String numResults) {
   return(baseURL + searchString + numResultsSuffix + numResults);
   }
  
   public String getName() {
   return(name);
   }
  
   public static SearchSpec[] getCommonSpecs() {
   return(commonSpecs);
   }
  }
  
  
  
  
  　　 SearchEngines.html
  
  　　 下面是调用上述Servlet的HTML表单。
  ＜!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"＞
  ＜HTML＞
  ＜HEAD＞
   ＜TITLE＞访问多个搜索引擎＜/TITLE＞
  ＜/HEAD＞
  
  ＜BODY BGCOLOR="#FDF5E6"＞
  
  ＜FORM ACTION="/servlet/hall.SearchEngines"＞
   ＜CENTER＞
   搜索关键字:
   ＜INPUT TYPE="TEXT" NAME="searchString"＞＜BR＞
   每页显示几个查询结果:
   ＜INPUT TYPE="TEXT" NAME="numResults"
   VALUE=10 SIZE=3＞＜BR＞
   ＜INPUT TYPE="RADIO" NAME="searchEngine"
   VALUE="google"＞
   Google |
   ＜INPUT TYPE="RADIO" NAME="searchEngine"
   VALUE="infoseek"＞
   Infoseek |
   ＜INPUT TYPE="RADIO" NAME="searchEngine"
   VALUE="lycos"＞
   Lycos |
   ＜INPUT TYPE="RADIO" NAME="searchEngine"
   VALUE="hotbot"＞
   HotBot
   ＜BR＞
   ＜INPUT TYPE="SUBMIT" VALUE="Search"＞
   ＜/CENTER＞
  ＜/FORM＞
  
  ＜/BODY＞
  ＜/HTML＞
8.1 HTTP应答头概述
  
  　　 Web服务器的HTTP应答一般由以下几项构成：一个状态行，一个或多个应答头，一个空行，内容文档。设置HTTP应答头往往和设置状态行中的状态代码结合起来。例如，有好几个表示“文档位置已经改变”的状态代码都伴随着一个Location头，而401（Unauthorized）状态代码则必须伴随一个WWW-Authenticate头。
  
  　　 然而，即使在没有设置特殊含义的状态代码时，指定应答头也是很有用的。应答头可以用来完成：设置Cookie，指定修改日期，指示浏览器按照指定的间隔刷新页面，声明文档的长度以便利用持久HTTP连接，……等等许多其他任务。
  
  　　 设置应答头最常用的方法是HttpServletResponse的setHeader，该方法有两个参数，分别表示应答头的名字和值。和设置状态代码相似，设置应答头应该在发送任何文档内容之前进行。
  
  　　 setDateHeader方法和setIntHeadr方法专门用来设置包含日期和整数值的应答头，前者避免了把Java时间转换为GMT时间字符串的麻烦，后者则避免了把整数转换为字符串的麻烦。
  
  　　 HttpServletResponse还提供了许多设置常见应答头的简便方法，如下所示：
  
  setContentType：设置Content-Type头。大多数Servlet都要用到这个方法。
  setContentLength：设置Content-Length头。对于支持持久HTTP连接的浏览器来说，这个函数是很有用的。
  addCookie：设置一个Cookie（Servlet API中没有setCookie方法，因为应答往往包含多个Set-Cookie头）。
  另外，如上节介绍，sendRedirect方法设置状态代码302时也会设置Location头。
  　　 8.2 常见应答头及其含义
  
  　　 有关HTTP头详细和完整的说明，请参见http://www.w3.org/Protocols/ 规范。
  
  应答头 说明
  Allow 服务器支持哪些请求方法（如GET、POST等）。
  Content-Encoding 文档的编码（Encode）方法。只有在解码之后才可以得到Content-Type头指定的内容类型。利用gzip压缩文档能够显著地减少HTML文档的下载时间。Java的GZIPOutputStream可以很方便地进行gzip压缩，但只有Unix上的Netscape和Windows上的IE 4、IE 5才支持它。因此，Servlet应该通过查看Accept-Encoding头（即request.getHeader("Accept-Encoding")）检查浏览器是否支持gzip，为支持gzip的浏览器返回经gzip压缩的HTML页面，为其他浏览器返回普通页面。
  Content-Length 表示内容长度。只有当浏览器使用持久HTTP连接时才需要这个数据。如果你想要利用持久连接的优势，可以把输出文档写入ByteArrayOutputStram，完成后查看其大小，然后把该值放入Content-Length头，最后通过byteArrayStream.writeTo(response.getOutputStream()发送内容。
  Content-Type 表示后面的文档属于什么MIME类型。Servlet默认为text/plain，但通常需要显式地指定为text/html。由于经常要设置Content-Type，因此HttpServletResponse提供了一个专用的方法setContentTyep。
  Date 当前的GMT时间。你可以用setDateHeader来设置这个头以避免转换时间格式的麻烦。
  Expires 应该在什么时候认为文档已经过期，从而不再缓存它？
  Last-Modified 文档的最后改动时间。客户可以通过If-Modified-Since请求头提供一个日期，该请求将被视为一个条件GET，只有改动时间迟于指定时间的文档才会返回，否则返回一个304（Not Modified）状态。Last-Modified也可用setDateHeader方法来设置。
  Location 表示客户应当到哪里去提取文档。Location通常不是直接设置的，而是通过HttpServletResponse的sendRedirect方法，该方法同时设置状态代码为302。
  Refresh 表示浏览器应该在多少时间之后刷新文档，以秒计。除了刷新当前文档之外，你还可以通过setHeader("Refresh", "5; URL=http://host/path")让浏览器读取指定的页面。
  注意这种功能通常是通过设置HTML页面HEAD区的＜META HTTP-EQUIV="Refresh" CONTENT="5;URL=http://host/path"＞实现，这是因为，自动刷新或重定向对于那些不能使用CGI或Servlet的HTML编写者十分重要。但是，对于Servlet来说，直接设置Refresh头更加方便。
  
  注意Refresh的意义是“N秒之后刷新本页面或访问指定页面”，而不是“每隔N秒刷新本页面或访问指定页面”。因此，连续刷新要求每次都发送一个Refresh头，而发送204状态代码则可以阻止浏览器继续刷新，不管是使用Refresh头还是＜META HTTP-EQUIV="Refresh" ...＞。
  
  注意Refresh头不属于HTTP 1.1正式规范的一部分，而是一个扩展，但Netscape和IE都支持它。
  
  Server 服务器名字。Servlet一般不设置这个值，而是由Web服务器自己设置。
  Set-Cookie 设置和页面关联的Cookie。Servlet不应使用response.setHeader("Set-Cookie", ...)，而是应使用HttpServletResponse提供的专用方法addCookie。参见下文有关Cookie设置的讨论。
  WWW-Authenticate 客户应该在Authorization头中提供什么类型的授权信息？在包含401（Unauthorized）状态行的应答中这个头是必需的。例如，response.setHeader("WWW-Authenticate", "BASIC realm=＼"executives＼"")。
  注意Servlet一般不进行这方面的处理，而是让Web服务器的专门机制来控制受密码保护页面的访问（例如.htaccess）。
  
  
  
  　　 8.3 实例：内容改变时自动刷新页面
  
  　　 下面这个Servlet用来计算大素数。因为计算非常大的数字（例如500位）可能要花不少时间，所以Servlet将立即返回已经找到的结果，同时在后台继续计算。后台计算使用一个优先级较低的线程以避免过多地影响Web服务器的性能。如果计算还没有完成，Servlet通过发送Refresh头指示浏览器在几秒之后继续请求新的内容。
  
  　　 注意，本例除了说明HTTP应答头的用处之外，还显示了Servlet的另外两个很有价值的功能。首先，它表明Servlet能够处理多个并发的连接，每个都有自己的线程。Servlet维护了一份已有素数计算请求的Vector表，通过查找素数个数（素数列表的长度）和数字个数（每个素数的长度）将当前请求和已有请求相匹配，把所有这些请求同步到这个列表上。第二，本例证明，在Servlet中维持请求之间的状态信息是非常容易的。维持状态信息在传统的CGI编程中是一件很麻烦的事情。由于维持了状态信息，浏览器能够在刷新页面时访问到正在进行的计算过程，同时也使得Servlet能够保存一个有关最近请求结果的列表，当一个新的请求指定了和最近请求相同的参数时可以立即返回结果。
  
  　　 PrimeNumbers.java
  
  　　 注意，该Servlet要用到前面给出的ServletUtilities.java。另外还要用到：PrimeList.java，用于在后台线程中创建一个素数的Vector；Primes.java，用于随机生成BigInteger类型的大数字，检查它们是否是素数。（此处略去PrimeList.java和Primes.java的代码。）
  package hall;
  
  import java.io.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.util.*;
  
  public class PrimeNumbers extends HttpServlet {
   private static Vector primeListVector = new Vector();
   private static int maxPrimeLists = 30;
  
   public void doGet(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   int numPrimes = ServletUtilities.getIntParameter(request, "numPrimes", 50);
   int numDigits = ServletUtilities.getIntParameter(request, "numDigits", 120);
   PrimeList primeList = findPrimeList(primeListVector, numPrimes, numDigits);
   if (primeList == null) {
   primeList = new PrimeList(numPrimes, numDigits, true);
   synchronized(primeListVector) {
   if (primeListVector.size() ＞= maxPrimeLists)
   primeListVector.removeElementAt(0);
   primeListVector.addElement(primeList);
   }
   }
   Vector currentPrimes = primeList.getPrimes();
   int numCurrentPrimes = currentPrimes.size();
   int numPrimesRemaining = (numPrimes - numCurrentPrimes);
   boolean isLastResult = (numPrimesRemaining == 0);
   if (!isLastResult) {
   response.setHeader("Refresh", "5");
   }
   response.setContentType("text/html");
   PrintWriter out = response.getWriter();
   String title = "Some " + numDigits + "-Digit Prime Numbers";
   out.println(ServletUtilities.headWithTitle(title) +
   "＜BODY BGCOLOR=＼"#FDF5E6＼"＞＼n" +
   "＜H2 ALIGN=CENTER＞" + title + "＜/H2＞＼n" +
   "＜H3＞Primes found with " + numDigits +
   " or more digits: " + numCurrentPrimes + ".＜/H3＞");
   if (isLastResult)
   out.println("＜B＞Done searching.＜/B＞");
   else
   out.println("＜B＞Still looking for " + numPrimesRemaining +
   " more＜BLINK＞...＜/BLINK＞＜/B＞");
   out.println("＜OL＞");
   for(int i=0; i＜numCurrentPrimes; i++) {
   out.println(" ＜LI＞" + currentPrimes.elementAt(i));
   }
   out.println("＜/OL＞");
   out.println("＜/BODY＞＜/HTML＞");
   }
  
   public void doPost(HttpServletRequest request,
   HttpServletResponse response)
   throws ServletException, IOException {
   doGet(request, response);
   }
  
   // 检查是否存在同类型请求（已经完成，或者正在计算）。
   // 如存在，则返回现有结果而不是启动新的后台线程。
   private PrimeList findPrimeList(Vector primeListVector,
   int numPrimes,
   int numDigits) {
   synchronized(primeListVector) {
   for(int i=0; i＜primeListVector.size(); i++) {
   PrimeList primes = (PrimeList)primeListVector.elementAt(i);
   if ((numPrimes == primes.numPrimes()) &&
   (numDigits == primes.numDigits()))
   return(primes);
   }
   return(null);
   }
   }
  } 
posted @ 2006-09-01 17:20 阿成 阅读(612) | 评论 (0) | 编辑 收藏
一篇关于web.xml配置的详细说明【转载】
1 定义头和根元素

部署描述符文件就像所有XML文件一样，必须以一个XML头开始。这个头声明可以使用的XML版本并给出文件的字符编码。
DOCYTPE声明必须立即出现在此头之后。这个声明告诉服务器适用的servlet规范的版本（如2.2或2.3）并指定管理此文件其余部分内容的语法的DTD(Document Type Definition，文档类型定义)。
所有部署描述符文件的顶层（根）元素为web-app。请注意，XML元素不像HTML，他们是大小写敏感的。因此，web-App和WEB-APP都是不合法的，web-app必须用小写。

2 部署描述符文件内的元素次序

XML 元素不仅是大小写敏感的，而且它们还对出现在其他元素中的次序敏感。例如，XML头必须是文件中的第一项，DOCTYPE声明必须是第二项，而web- app元素必须是第三项。在web-app元素内，元素的次序也很重要。服务器不一定强制要求这种次序，但它们允许（实际上有些服务器就是这样做的）完全拒绝执行含有次序不正确的元素的Web应用。这表示使用非标准元素次序的web.xml文件是不可移植的。
下面的列表给出了所有可直接出现在web-app元素内的合法元素所必需的次序。例如，此列表说明servlet元素必须出现在所有servlet-mapping元素之前。请注意，所有这些元素都是可选的。因此，可以省略掉某一元素，但不能把它放于不正确的位置。
l icon icon元素指出IDE和GUI工具用来表示Web应用的一个和两个图像文件的位置。
l display-name display-name元素提供GUI工具可能会用来标记这个特定的Web应用的一个名称。
l description description元素给出与此有关的说明性文本。
l context-param context-param元素声明应用范围内的初始化参数。
l filter 过滤器元素将一个名字与一个实现javax.servlet.Filter接口的类相关联。
l filter-mapping 一旦命名了一个过滤器，就要利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。
l listener servlet API的版本2.3增加了对事件监听程序的支持，事件监听程序在建立、修改和删除会话或servlet环境时得到通知。Listener元素指出事件监听程序类。
l servlet 在向servlet或JSP页面制定初始化参数或定制URL时，必须首先命名servlet或JSP页面。Servlet元素就是用来完成此项任务的。
l servlet-mapping 服务器一般为servlet提供一个缺省的URL： http://host/webAppPrefix/servlet/ServletName 。但是，常常会更改这个URL，以便servlet可以访问初始化参数或更容易地处理相对URL。在更改缺省URL时，使用servlet-mapping元素。
l session-config 如果某个会话在一定时间内未被访问，服务器可以抛弃它以节省内存。可通过使用HttpSession的setMaxInactiveInterval方法明确设置单个会话对象的超时值，或者可利用session-config元素制定缺省超时值。
l mime-mapping 如果Web应用具有想到特殊的文件，希望能保证给他们分配特定的MIME类型，则mime-mapping元素提供这种保证。
l welcom-file-list welcome-file-list元素指示服务器在收到引用一个目录名而不是文件名的URL时，使用哪个文件。
l error-page error-page元素使得在返回特定HTTP状态代码时，或者特定类型的异常被抛出时，能够制定将要显示的页面。
l taglib taglib元素对标记库描述符文件（Tag Libraryu Descriptor file）指定别名。此功能使你能够更改TLD文件的位置，而不用编辑使用这些文件的JSP页面。
l resource-env-ref resource-env-ref元素声明与资源相关的一个管理对象。
l resource-ref resource-ref元素声明一个资源工厂使用的外部资源。
l security-constraint security-constraint元素制定应该保护的URL。它与login-config元素联合使用
l login-config 用login-config元素来指定服务器应该怎样给试图访问受保护页面的用户授权。它与sercurity-constraint元素联合使用。
l security-role security-role元素给出安全角色的一个列表，这些角色将出现在servlet元素内的security-role-ref元素的role-name子元素中。分别地声明角色可使高级IDE处理安全信息更为容易。
l env-entry env-entry元素声明Web应用的环境项。
l ejb-ref ejb-ref元素声明一个EJB的主目录的引用。
l ejb-local-ref ejb-local-ref元素声明一个EJB的本地主目录的应用。

3 分配名称和定制的UL

在web.xml中完成的一个最常见的任务是对servlet或JSP页面给出名称和定制的URL。用servlet元素分配名称，使用servlet-mapping元素将定制的URL与刚分配的名称相关联。
3.1 分配名称
为了提供初始化参数，对servlet或JSP页面定义一个定制URL或分配一个安全角色，必须首先给servlet或JSP页面一个名称。可通过 servlet元素分配一个名称。最常见的格式包括servlet-name和servlet-class子元素（在web-app元素内），如下所示：
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
这表示位于WEB-INF/classes/moreservlets/TestServlet的servlet已经得到了注册名Test。给 servlet一个名称具有两个主要的含义。首先，初始化参数、定制的URL模式以及其他定制通过此注册名而不是类名引用此servlet。其次,可在 URL而不是类名中使用此名称。因此，利用刚才给出的定义，URL http://host/webAppPrefix/servlet/Test 可用于 http://host/webAppPrefix/servlet/moreservlets.TestServlet 的场所。
请记住：XML元素不仅是大小写敏感的，而且定义它们的次序也很重要。例如，web-app元素内所有servlet元素必须位于所有servlet- mapping元素（下一小节介绍）之前，而且还要位于5.6节和5.11节讨论的与过滤器或文档相关的元素（如果有的话）之前。类似地，servlet 的servlet-name子元素也必须出现在servlet-class之前。5.2节"部署描述符文件内的元素次序"将详细介绍这种必需的次序。
例如，程序清单5-1给出了一个名为TestServlet的简单servlet，它驻留在moreservlets程序包中。因为此servlet是扎根在一个名为deployDemo的目录中的Web应用的组成部分，所以TestServlet.class放在deployDemo/WEB- INF/classes/moreservlets中。程序清单5-2给出将放置在deployDemo/WEB-INF/内的web.xml文件的一部分。此web.xml文件使用servlet-name和servlet-class元素将名称Test与TestServlet.class相关联。图 5-1和图5-2分别显示利用缺省URL和注册名调用TestServlet时的结果。

程序清单5-1 TestServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to illustrate servlet naming
* and custom URLs.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class TestServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Test Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>URI: " + uri + "</H2>\n" +
"</BODY></HTML>");
}
}


程序清单5-2 web.xml（说明servlet名称的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- … -->
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- … -->
</web-app>

3.2 定义定制的URL
大多数服务器具有一个缺省的serlvet URL：
 http://host/webAppPrefix/servlet/packageName.ServletName 。虽然在开发中使用这个URL很方便，但是我们常常会希望另一个URL用于部署。例如，可能会需要一个出现在Web应用顶层的URL（如，http: //host/webAppPrefix/Anyname），并且在此URL中没有servlet项。位于顶层的URL简化了相对URL的使用。此外，对许多开发人员来说，顶层URL看上去比更长更麻烦的缺省URL更简短。
事实上，有时需要使用定制的URL。比如，你可能想关闭缺省URL映射，以便更好地强制实施安全限制或防止用户意外地访问无初始化参数的servlet。如果你禁止了缺省的URL，那么你怎样访问servlet呢？这时只有使用定制的URL了。
为了分配一个定制的URL，可使用servlet-mapping元素及其servlet-name和url-pattern子元素。Servlet- name元素提供了一个任意名称，可利用此名称引用相应的servlet；url-pattern描述了相对于Web应用的根目录的URL。url- pattern元素的值必须以斜杠（/）起始。
下面给出一个简单的web.xml摘录，它允许使用URL http://host/webAppPrefix/UrlTest 而不是 http://host/webAppPrefix/servlet/Test 或
http: //host/webAppPrefix/servlet/moreservlets.TestServlet。请注意，仍然需要XML头、 DOCTYPE声明以及web-app封闭元素。此外，可回忆一下，XML元素出现地次序不是随意的。特别是，需要把所有servlet元素放在所有 servlet-mapping元素之前。
<servlet>
<servlet-name>Test</servlet-name>
<servlet-class>moreservlets.TestServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/UrlTest</url-pattern>
</servlet-mapping>
URL模式还可以包含通配符。例如，下面的小程序指示服务器发送所有以Web应用的URL前缀开始，以..asp结束的请求到名为BashMS的servlet。
<servlet>
<servlet-name>BashMS</servlet-name>
<servlet-class>msUtils.ASPTranslator</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name>BashMS</servlet-name>
<url-pattern>/*.asp</url-pattern>
</servlet-mapping>
3.3 命名JSP页面
因为JSP页面要转换成sevlet，自然希望就像命名servlet一样命名JSP页面。毕竟，JSP页面可能会从初始化参数、安全设置或定制的URL中受益，正如普通的serlvet那样。虽然JSP页面的后台实际上是servlet这句话是正确的，但存在一个关键的猜疑：即，你不知道JSP页面的实际类名（因为系统自己挑选这个名字）。因此，为了命名JSP页面，可将jsp-file元素替换为servlet-calss元素，如下所示：
<servlet>
<servlet-name>Test</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
命名JSP页面的原因与命名servlet的原因完全相同：即为了提供一个与定制设置（如，初始化参数和安全设置）一起使用的名称，并且，以便能更改激活 JSP页面的URL（比方说，以便多个URL通过相同页面得以处理，或者从URL中去掉.jsp扩展名）。但是，在设置初始化参数时，应该注意，JSP页面是利用jspInit方法，而不是init方法读取初始化参数的。
例如，程序清单5-3给出一个名为TestPage.jsp的简单JSP页面，它的工作只是打印出用来激活它的URL的本地部分。TestPage.jsp放置在deployDemo应用的顶层。程序清单5-4给出了用来分配一个注册名PageName，然后将此注册名与 http://host/webAppPrefix/UrlTest2/anything 形式的URL相关联的web.xml文件（即，deployDemo/WEB-INF/web.xml）的一部分。

程序清单5-3 TestPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>
JSP Test Page
</TITLE>
</HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>URI: <%= request.getRequestURI() %></H2>
</BODY>
</HTML>


程序清单5-4 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/TestPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


4 禁止激活器servlet

对servlet或JSP页面建立定制URL的一个原因是，这样做可以注册从 init（servlet）或jspInit（JSP页面）方法中读取得初始化参数。但是，初始化参数只在是利用定制URL模式或注册名访问 servlet或JSP页面时可以使用，用缺省URL http://host/webAppPrefix/servlet/ServletName 访问时不能使用。因此，你可能会希望关闭缺省URL，这样就不会有人意外地调用初始化servlet了。这个过程有时称为禁止激活器servlet，因为多数服务器具有一个用缺省的servlet URL注册的标准servlet，并激活缺省的URL应用的实际servlet。
有两种禁止此缺省URL的主要方法：
l 在每个Web应用中重新映射/servlet/模式。
l 全局关闭激活器servlet。
重要的是应该注意到，虽然重新映射每个Web应用中的/servlet/模式比彻底禁止激活servlet所做的工作更多，但重新映射可以用一种完全可移植的方式来完成。相反，全局禁止激活器servlet完全是针对具体机器的，事实上有的服务器（如ServletExec）没有这样的选择。下面的讨论对每个Web应用重新映射/servlet/ URL模式的策略。后面提供在Tomcat中全局禁止激活器servlet的详细内容。
4.1 重新映射/servlet/URL模式
在一个特定的Web应用中禁止以 http://host/webAppPrefix/servlet/ 开始的URL的处理非常简单。所需做的事情就是建立一个错误消息servlet，并使用前一节讨论的url-pattern元素将所有匹配请求转向该 servlet。只要简单地使用：
<url-pattern>/servlet/*</url-pattern>
作为servlet-mapping元素中的模式即可。
例如，程序清单5-5给出了将SorryServlet servlet（程序清单5-6）与所有以 http://host/webAppPrefix/servlet/ 开头的URL相关联的部署描述符文件的一部分。

程序清单5-5 web.xml（说明JSP页命名的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>Sorry</servlet-name>
<servlet-class>moreservlets.SorryServlet</servlet-class>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> Sorry </servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


程序清单5-6 SorryServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to give error messages to
* users who try to access default servlet URLs
* (i.e., http://host/webAppPrefix/servlet/ServletName )
* in Web applications that have disabled this
* behavior.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class SorryServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Invoker Servlet Disabled.";
out.println(ServletUtilities.headWithTitle(title) +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>" + title + "</H2>\n" +
"Sorry, access to servlets by means of\n" +
"URLs that begin with\n" +
" http://host/webAppPrefix/servlet/ \n" +
"has been disabled.\n" +
"</BODY></HTML>");
}

public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}


4.2 全局禁止激活器：Tomcat
Tomcat 4中用来关闭缺省URL的方法与Tomcat 3中所用的很不相同。下面介绍这两种方法：
1．禁止激活器： Tomcat 4
Tomcat 4用与前面相同的方法关闭激活器servlet，即利用web.xml中的url-mapping元素进行关闭。不同之处在于Tomcat使用了放在 install_dir/conf中的一个服务器专用的全局web.xml文件，而前面使用的是存放在每个Web应用的WEB-INF目录中的标准 web.xml文件。
因此，为了在Tomcat 4中关闭激活器servlet，只需在install_dir/conf/web.xml中简单地注释出/servlet/* URL映射项即可，如下所示：
<!--
<servlet-mapping>
<servlet-name>invoker</servlet-name>
<url-pattern>/servlet/*</url-pattern>
</servlet-mapping>
-->
再次提醒，应该注意这个项是位于存放在install_dir/conf的Tomcat专用的web.xml文件中的，此文件不是存放在每个Web应用的WEB-INF目录中的标准web.xml。
2．禁止激活器：Tomcat3
在Apache Tomcat的版本3中，通过在install_dir/conf/server.xml中注释出InvokerInterceptor项全局禁止缺省 servlet URL。例如，下面是禁止使用缺省servlet URL的server.xml文件的一部分。
<!--
<RequsetInterceptor
className="org.apache.tomcat.request.InvokerInterceptor"
debug="0" prefix="/servlet/" />
-->

5 初始化和预装载servlet与JSP页面

这里讨论控制servlet和JSP页面的启动行为的方法。特别是，说明了怎样分配初始化参数以及怎样更改服务器生存期中装载servlet和JSP页面的时刻。
5.1 分配servlet初始化参数
利用init-param元素向servlet提供初始化参数，init-param元素具有param-name和param-value子元素。例如，在下面的例子中，如果initServlet servlet是利用它的注册名（InitTest）访问的，它将能够从其方法中调用getServletConfig(). getInitParameter("param1")获得"Value 1"，调用getServletConfig().getInitParameter("param2")获得"2"。
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>param1</param-name>
<param-value>value1</param-value>
</init-param>
<init-param>
<param-name>param2</param-name>
<param-value>2</param-value>
</init-param>
</servlet>
在涉及初始化参数时，有几点需要注意：
l 返回值。GetInitParameter的返回值总是一个String。因此，在前一个例子中，可对param2使用Integer.parseInt获得一个int。
l JSP中的初始化。JSP页面使用jspInit而不是init。JSP页面还需要使用jsp-file元素代替servlet-class。
l 缺省URL。初始化参数只在通过它们的注册名或与它们注册名相关的定制URL模式访问Servlet时可以使用。因此，在这个例子中，param1和 param2初始化参数将能够在使用URL http://host/webAppPrefix/servlet/InitTest 时可用，但在使用URL http://host/webAppPrefix/servlet/myPackage.InitServlet 时不能使用。
例如，程序清单5-7给出一个名为InitServlet的简单servlet，它使用init方法设置firstName和emailAddress字段。程序清单5-8给出分配名称InitTest给servlet的web.xml文件。
程序清单5-7 InitServlet.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

/** Simple servlet used to illustrate servlet
* initialization parameters.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class InitServlet extends HttpServlet {
private String firstName, emailAddress;

public void init() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}

public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String uri = request.getRequestURI();
out.println(ServletUtilities.headWithTitle("Init Servlet") +
"<BODY BGCOLOR=\"#FDF5E6\">\n" +
"<H2>Init Parameters:</H2>\n" +
"<UL>\n" +
"<LI>First name: " + firstName + "\n" +
"<LI>Email address: " + emailAddress + "\n" +
"</UL>\n" +
"</BODY></HTML>");
}
}


程序清单5-8 web.xml（说明初始化参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitTest</servlet-name>
<servlet-class>moreservlets.InitServlet</servlet-class>
<init-param>
<param-name>firstName</param-name>
<param-value>Larry</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value> Ellison@Microsoft.com </param-value>
</init-param>
</servlet>
<!-- ... -->
</web-app>

5.2 分配JSP初始化参数
给JSP页面提供初始化参数在三个方面不同于给servlet提供初始化参数。
1）使用jsp-file而不是servlet-class。因此，WEB-INF/web.xml文件的servlet元素如下所示：
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
<init-param>
<param-name>...</param-name>
<param-value>...</param-value>
</init-param>
...
</servlet>
2) 几乎总是分配一个明确的URL模式。对servlet，一般相应地使用以 http://host/webAppPrefix/servlet/ 开始的缺省URL。只需记住，使用注册名而不是原名称即可。这对于JSP页面在技术上也是合法的。例如，在上面给出的例子中，可用URL http://host/webAppPrefix/servlet/PageName 访问RealPage.jsp的对初始化参数具有访问权的版本。但在用于JSP页面时，许多用户似乎不喜欢应用常规的servlet的URL。此外，如果 JSP页面位于服务器为其提供了目录清单的目录中（如，一个既没有index.html也没有index.jsp文件的目录），则用户可能会连接到此 JSP页面，单击它，从而意外地激活未初始化的页面。因此，好的办法是使用url-pattern（5.3节）将JSP页面的原URL与注册的 servlet名相关联。这样，客户机可使用JSP页面的普通名称，但仍然激活定制的版本。例如，给定来自项目1的servlet定义，可使用下面的 servlet-mapping定义：
<servlet-mapping>
<servlet-name>PageName</servlet-name>
<url-pattern>/RealPage.jsp</url-pattern>
</servlet-mapping>
3）JSP页使用jspInit而不是init。自动从JSP页面建立的servlet或许已经使用了inti方法。因此，使用JSP声明提供一个init方法是不合法的，必须制定jspInit方法。
为了说明初始化JSP页面的过程，程序清单5-9给出了一个名为InitPage.jsp的JSP页面，它包含一个jspInit方法且放置于 deployDemo Web应用层次结构的顶层。一般， http://host/deployDemo/InitPage.jsp 形式的URL将激活此页面的不具有初始化参数访问权的版本，从而将对firstName和emailAddress变量显示null。但是， web.xml文件（程序清单5-10）分配了一个注册名，然后将该注册名与URL模式/InitPage.jsp相关联。

程序清单5-9 InitPage.jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>JSP Init Test</TITLE></HEAD>
<BODY BGCOLOR="#FDF5E6">
<H2>Init Parameters:</H2>
<UL>
<LI>First name: <%= firstName %>
<LI>Email address: <%= emailAddress %>
</UL>
</BODY></HTML>
<%!
private String firstName, emailAddress;

public void jspInit() {
ServletConfig config = getServletConfig();
firstName = config.getInitParameter("firstName");
emailAddress = config.getInitParameter("emailAddress");
}
%>


程序清单5-10 web.xml（说明JSP页面的init参数的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<servlet>
<servlet-name>InitPage</servlet-name>
<jsp-file>/InitPage.jsp</jsp-file>
<init-param>
<param-name>firstName</param-name>
<param-value>Bill</param-value>
</init-param>
<init-param>
<param-name>emailAddress</param-name>
<param-value> gates@oracle.com </param-value>
</init-param>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> InitPage</servlet-name>
<url-pattern>/InitPage.jsp</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


5.3 提供应用范围内的初始化参数
一般，对单个地servlet或JSP页面分配初始化参数。指定的servlet或JSP页面利用ServletConfig的getInitParameter方法读取这些参数。但是，在某些情形下，希望提供可由任意servlet或JSP页面借助ServletContext的getInitParameter方法读取的系统范围内的初始化参数。
可利用context-param元素声明这些系统范围内的初始化值。context-param元素应该包含param-name、param-value以及可选的description子元素，如下所示：
<context-param>
<param-name>support-email</param-name>
<param-value> blackhole@mycompany.com </param-value>
</context-param>
可回忆一下，为了保证可移植性，web.xml内的元素必须以正确的次序声明。但这里应该注意，context-param元素必须出现任意与文档有关的元素（icon、display-name或description）之后及filter、filter-mapping、listener或 servlet元素之前。
5.4 在服务器启动时装载servlet
假如servlet或JSP页面有一个要花很长时间执行的init （servlet）或jspInit（JSP）方法。例如，假如init或jspInit方法从某个数据库或ResourceBundle查找产量。这种情况下，在第一个客户机请求时装载servlet的缺省行为将对第一个客户机产生较长时间的延迟。因此，可利用servlet的load-on- startup元素规定服务器在第一次启动时装载servlet。下面是一个例子。
<servlet>
<servlet-name> … </servlet-name>
<servlet-class> … </servlet-class> <!-- Or jsp-file -->
<load-on-startup/>
</servlet>
可以为此元素体提供一个整数而不是使用一个空的load-on-startup。想法是服务器应该在装载较大数目的servlet或JSP页面之前装载较少数目的servlet或JSP页面。例如，下面的servlet项（放置在Web应用的WEB-INF目录下的web.xml文件中的web-app元素内）将指示服务器首先装载和初始化SearchServlet，然后装载和初始化由位于Web应用的result目录中的index.jsp文件产生的 servlet。
<servlet>
<servlet-name>Search</servlet-name>
<servlet-class>myPackage.SearchServlet</servlet-class> <!-- Or jsp-file -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>Results</servlet-name>
<servlet-class>/results/index.jsp</servlet-class> <!-- Or jsp-file -->
<load-on-startup>2</load-on-startup>
</servlet>

6 声明过滤器

servlet版本2.3引入了过滤器的概念。虽然所有支持servlet API版本2.3的服务器都支持过滤器，但为了使用与过滤器有关的元素，必须在web.xml中使用版本2.3的DTD。
过滤器可截取和修改进入一个servlet或JSP页面的请求或从一个servlet或JSP页面发出的相应。在执行一个servlet或JSP页面之前，必须执行第一个相关的过滤器的doFilter方法。在该过滤器对其FilterChain对象调用doFilter时，执行链中的下一个过滤器。如果没有其他过滤器，servlet或JSP页面被执行。过滤器具有对到来的ServletRequest对象的全部访问权，因此，它们可以查看客户机名、查找到来的cookie等。为了访问servlet或JSP页面的输出，过滤器可将响应对象包裹在一个替身对象（stand-in object）中，比方说把输出累加到一个缓冲区。在调用FilterChain对象的doFilter方法之后，过滤器可检查缓冲区，如有必要，就对它进行修改，然后传送到客户机。
例如，程序清单5-11帝国难以了一个简单的过滤器，只要访问相关的servlet或JSP页面，它就截取请求并在标准输出上打印一个报告（开发过程中在桌面系统上运行时，大多数服务器都可以使用这个过滤器）。

程序清单5-11 ReportFilter.java
package moreservlets;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

/** Simple filter that prints a report on the standard output
* whenever the associated servlet or JSP page is accessed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class ReportFilter implements Filter {
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain)
throws ServletException, IOException {
HttpServletRequest req = (HttpServletRequest)request;
System.out.println(req.getRemoteHost() +
" tried to access " +
req.getRequestURL() +
" on " + new Date() + ".");
chain.doFilter(request,response);
}

public void init(FilterConfig config)
throws ServletException {
}

public void destroy() {}
}

一旦建立了一个过滤器，可以在web.xml中利用filter元素以及filter-name（任意名称）、file-class（完全限定的类名）和（可选的）init-params子元素声明它。请注意，元素在web.xml的web-app元素中出现的次序不是任意的；允许服务器（但不是必需的）强制所需的次序，并且实际中有些服务器也是这样做的。但这里要注意，所有filter元素必须出现在任意filter-mapping元素之前， filter-mapping元素又必须出现在所有servlet或servlet-mapping元素之前。
例如，给定上述的ReportFilter类，可在web.xml中作出下面的filter声明。它把名称Reporter与实际的类ReportFilter（位于moreservlets程序包中）相关联。
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
一旦命名了一个过滤器，可利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。关于此项工作有两种选择。
首先，可使用filter-name和servlet-name子元素把此过滤器与一个特定的servlet名（此servlet名必须稍后在相同的 web.xml文件中使用servlet元素声明）关联。例如，下面的程序片断指示系统只要利用一个定制的URL访问名为SomeServletName 的servlet或JSP页面，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>SomeServletName</servlet-name>
</filter-mapping>
其次，可利用filter-name和url-pattern子元素将过滤器与一组servlet、JSP页面或静态内容相关联。例如，相面的程序片段指示系统只要访问Web应用中的任意URL，就运行名为Reporter的过滤器。
<filter-mapping>
<filter-name>Reporter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
例如，程序清单5-12给出了将ReportFilter过滤器与名为PageName的servlet相关联的web.xml文件的一部分。名字 PageName依次又与一个名为TestPage.jsp的JSP页面以及以模式http: //host/webAppPrefix/UrlTest2/ 开头的URL相关联。TestPage.jsp的源代码已经JSP页面命名的谈论在前面的3节"分配名称和定制的URL"中给出。事实上，程序清单5- 12中的servlet和servlet-name项从该节原封不动地拿过来的。给定这些web.xml项，可看到下面的标准输出形式的调试报告（换行是为了容易阅读）。
audit.irs.gov tried to access
http://mycompany.com/deployDemo/UrlTest2/business/tax-plan.html
on Tue Dec 25 13:12:29 EDT 2001.

程序清单5-12 Web.xml（说明filter用法的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<filter>
<filter-name>Reporter</filter-name>
<filter-class>moresevlets.ReportFilter</filter-class>
</filter>
<!-- ... -->
<filter-mapping>
<filter-name>Reporter</filter-name>
<servlet-name>PageName</servlet-name>
</filter-mapping>
<!-- ... -->
<servlet>
<servlet-name>PageName</servlet-name>
<jsp-file>/RealPage.jsp</jsp-file>
</servlet>
<!-- ... -->
<servlet-mapping>
<servlet-name> PageName </servlet-name>
<url-pattern>/UrlTest2/*</url-pattern>
</servlet-mapping>
<!-- ... -->
</web-app>


7 指定欢迎页

假如用户提供了一个像http: //host/webAppPrefix/directoryName/ 这样的包含一个目录名但没有包含文件名的URL，会发生什么事情呢？用户能得到一个目录表？一个错误？还是标准文件的内容？如果得到标准文件内容，是 index.html、index.jsp、default.html、default.htm或别的什么东西呢？
Welcome-file-list 元素及其辅助的welcome-file元素解决了这个模糊的问题。例如，下面的web.xml项指出，如果一个URL给出一个目录名但未给出文件名，服务器应该首先试用index.jsp，然后再试用index.html。如果两者都没有找到，则结果有赖于所用的服务器（如一个目录列表）。
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
虽然许多服务器缺省遵循这种行为，但不一定必须这样。因此，明确地使用welcom-file-list保证可移植性是一种良好的习惯。

8 指定处理错误的页面

现在我了解到，你在开发servlet和JSP页面时从不会犯错误，而且你的所有页面是那样的清晰，一般的程序员都不会被它们的搞糊涂。但是，是人总会犯错误的，用户可能会提供不合规定的参数，使用不正确的URL或者不能提供必需的表单字段值。除此之外，其它开发人员可能不那么细心，他们应该有些工具来克服自己的不足。
error-page元素就是用来克服这些问题的。它有两个可能的子元素，分别是：error-code和exception- type。第一个子元素error-code指出在给定的HTTP错误代码出现时使用的URL。第二个子元素excpetion-type指出在出现某个给定的Java异常但未捕捉到时使用的URL。error-code和exception-type都利用location元素指出相应的URL。此 URL必须以/开始。location所指出的位置处的页面可通过查找HttpServletRequest对象的两个专门的属性来访问关于错误的信息，这两个属性分别是：javax.servlet.error.status_code和javax.servlet.error.message。
可回忆一下，在web.xml内以正确的次序声明web-app的子元素很重要。这里只要记住，error-page出现在web.xml文件的末尾附近，servlet、servlet-name和welcome-file-list之后即可。

8.1 error-code元素
为了更好地了解error-code元素的值，可考虑一下如果不正确地输入文件名，大多数站点会作出什么反映。这样做一般会出现一个404错误信息，它表示不能找到该文件，但几乎没提供更多有用的信息。另一方面，可以试一下在 www.microsoft.com 、 www.ibm.com 处或者特别是在 www.bea.com 处输出未知的文件名。这是会得出有用的消息，这些消息提供可选择的位置，以便查找感兴趣的页面。提供这样有用的错误页面对于Web应用来说是很有价值得。事实上rm-error-page子元素）。由form-login-page给出的HTML表单必须具有一个j_security_check的 ACTION属性、一个名为j_username的用户名文本字段以及一个名为j_password的口令字段。
例如，程序清单5-19指示服务器使用基于表单的验证。Web应用的顶层目录中的一个名为login.jsp的页面将收集用户名和口令，并且失败的登陆将由相同目录中名为login-error.jsp的页面报告。

程序清单5-19 web.xml（说明login-config的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<security-constraint> ... </security-constraint>
<login-config>
<auth-method> FORM </auth-method>
<form-login-config>
<form-login-page>/login.jsp</form-login-page>
<form-error-page>/login-error.jsp</form-error-page>
</form-login-config>
</login-config>
<!-- ... -->
</web-app>


9.2 限制对Web资源的访问
现在，可以指示服务器使用何种验证方法了。"了不起，"你说道，"除非我能指定一个来收到保护的 URL，否则没有多大用处。"没错。指出这些URL并说明他们应该得到何种保护正是security-constriaint元素的用途。此元素在 web.xml中应该出现在login-config的紧前面。它包含是个可能的子元素，分别是：web-resource-collection、 auth-constraint、user-data-constraint和display-name。下面各小节对它们进行介绍。
l web-resource-collection
此元素确定应该保护的资源。所有security-constraint元素都必须包含至少一个web-resource-collection项。此元素由一个给出任意标识名称的web-resource-name元素、一个确定应该保护的URL的url-pattern元素、一个指出此保护所适用的 HTTP命令（GET、POST等，缺省为所有方法）的http-method元素和一个提供资料的可选description元素组成。例如，下面的 Web-resource-collection项（在security-constratint元素内）指出Web应用的proprietary目录中所有文档应该受到保护。
<security-constraint>
<web-resource-coolection>
<web-resource-name>Proprietary</web-resource-name>
<url-pattern>/propritary/*</url-pattern>
</web-resource-coolection>
<!-- ... -->
</security-constraint>
重要的是应该注意到，url-pattern仅适用于直接访问这些资源的客户机。特别是，它不适合于通过MVC体系结构利用 RequestDispatcher来访问的页面，或者不适合于利用类似jsp:forward的手段来访问的页面。这种不匀称如果利用得当的话很有好处。例如，servlet可利用MVC体系结构查找数据，把它放到bean中，发送请求到从bean中提取数据的JSP页面并显示它。我们希望保证决不直接访问受保护的JSP页面，而只是通过建立该页面将使用的bean的servlet来访问它。url-pattern和auth-contraint元素可通过声明不允许任何用户直接访问JSP页面来提供这种保证。但是，这种不匀称的行为可能让开发人员放松警惕，使他们偶然对应受保护的资源提供不受限制的访问。
l auth-constraint
尽管web-resource-collention元素质出了哪些URL应该受到保护，但是auth-constraint元素却指出哪些用户应该具有受保护资源的访问权。此元素应该包含一个或多个标识具有访问权限的用户类别role- name元素，以及包含（可选）一个描述角色的description元素。例如，下面web.xml中的security-constraint元素部门规定只有指定为Administrator或Big Kahuna（或两者）的用户具有指定资源的访问权。
<security-constraint>
<web-resource-coolection> ... </web-resource-coolection>
<auth-constraint>
<role-name>administrator</role-name>
<role-name>kahuna</role-name>
</auth-constraint>
</security-constraint>
重要的是认识到，到此为止，这个过程的可移植部分结束了。服务器怎样确定哪些用户处于任何角色以及它怎样存放用户的口令，完全有赖于具体的系统。
例如，Tomcat使用install_dir/conf/tomcat-users.xml将用户名与角色名和口令相关联，正如下面例子中所示，它指出用户joe（口令bigshot）和jane（口令enaj）属于administrator和kahuna角色。
<tomcat-users>
<user name="joe" password="bigshot" roles="administrator,kahuna" />
<user name="jane" password="enaj" roles="kahuna" />
</tomcat-users>
l user-data-constraint
这个可选的元素指出在访问相关资源时使用任何传输层保护。它必须包含一个transport-guarantee子元素（合法值为NONE、 INTEGRAL或CONFIDENTIAL），并且可选地包含一个description元素。transport-guarantee为NONE值将对所用的通讯协议不加限制。INTEGRAL值表示数据必须以一种防止截取它的人阅读它的方式传送。虽然原理上（并且在未来的HTTP版本中），在 INTEGRAL和CONFIDENTIAL之间可能会有差别，但在当前实践中，他们都只是简单地要求用SSL。例如，下面指示服务器只允许对相关资源做 HTTPS连接：
<security-constraint>
<!-- ... -->
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>
l display-name
security-constraint的这个很少使用的子元素给予可能由GUI工具使用的安全约束项一个名称。
9.3 分配角色名
迄今为止，讨论已经集中到完全由容器（服务器）处理的安全问题之上了。但servlet以及JSP页面也能够处理它们自己的安全问题。
例如，容器可能允许用户从bigwig或bigcheese角色访问一个显示主管人员额外紧贴的页面，但只允许bigwig用户修改此页面的参数。完成这种更细致的控制的一种常见方法是调用HttpServletRequset的isUserInRole方法，并据此修改访问。
Servlet的 security-role-ref子元素提供出现在服务器专用口令文件中的安全角色名的一个别名。例如，假如编写了一个调用 request.isUserInRole（"boss"）的servlet，但后来该servlet被用在了一个其口令文件调用角色manager而不是boss的服务器中。下面的程序段使该servlet能够使用这两个名称中的任何一个。
<servlet>
<!-- ... -->
<security-role-ref>
<role-name>boss</role-name> <!-- New alias -->
<role-link>manager</role-link> <!-- Real name -->
</security-role-ref>
</servlet>
也可以在web-app内利用security-role元素提供将出现在role-name元素中的所有安全角色的一个全局列表。分别地生命角色使高级IDE容易处理安全信息。

10 控制会话超时

如果某个会话在一定的时间内未被访问，服务器可把它扔掉以节约内存。可利用HttpSession的setMaxInactiveInterval方法直接设置个别会话对象的超时值。如果不采用这种方法，则缺省的超时值由具体的服务器决定。但可利用session-config和session- timeout元素来给出一个适用于所有服务器的明确的超时值。超时值的单位为分钟，因此，下面的例子设置缺省会话超时值为三个小时（180分钟）。
<session-config>
<session-timeout>180</session-timeout>
</session-config>

11 Web应用的文档化

越来越多的开发环境开始提供servlet和JSP的直接支持。例子有Borland Jbuilder Enterprise Edition、Macromedia UltraDev、Allaire JRun Studio（写此文时，已被Macromedia收购）以及IBM VisuaAge for Java等。
大量的web.xml元素不仅是为服务器设计的，而且还是为可视开发环境设计的。它们包括icon、display-name和discription等。
可回忆一下，在web.xml内以适当地次序声明web-app子元素很重要。不过，这里只要记住icon、display-name和description是web.xml的web-app元素内的前三个合法元素即可。
l icon
icon元素指出GUI工具可用来代表Web应用的一个和两个图像文件。可利用small-icon元素指定一幅16 x 16的GIF或JPEG图像，用large-icon元素指定一幅32 x 32的图像。下面举一个例子：
<icon>
<small-icon>/images/small-book.gif</small-icon>
<large-icon>/images/tome.jpg</large-icon>
</icon>
l display-name
display-name元素提供GUI工具可能会用来标记此Web应用的一个名称。下面是个例子。
<display-name>Rare Books</display-name>
l description
description元素提供解释性文本，如下所示：
<description>
This Web application represents the store developed for
rare-books.com, an online bookstore specializing in rare
and limited-edition books.
</description>

12 关联文件与MIME类型

服务器一般都具有一种让Web站点管理员将文件扩展名与媒体相关联的方法。例如，将会自动给予名为mom.jpg的文件一个image/jpeg的MIME 类型。但是，假如你的Web应用具有几个不寻常的文件，你希望保证它们在发送到客户机时分配为某种MIME类型。mime-mapping元素（具有 extension和mime-type子元素）可提供这种保证。例如，下面的代码指示服务器将application/x-fubar的MIME类型分配给所有以.foo结尾的文件。
<mime-mapping>
<extension>foo</extension>
<mime-type>application/x-fubar</mime-type>
</mime-mapping>
或许，你的Web应用希望重载（override）标准的映射。例如，下面的代码将告诉服务器在发送到客户机时指定.ps文件作为纯文本（text/plain）而不是作为PostScript（application/postscript）。
<mime-mapping>
<extension>ps</extension>
<mime-type>application/postscript</mime-type>
</mime-mapping>


13 定位TLD

JSP taglib元素具有一个必要的uri属性，它给出一个TLD（Tag Library Descriptor）文件相对于Web应用的根的位置。TLD文件的实际名称在发布新的标签库版本时可能会改变，但我们希望避免更改所有现有JSP页面。此外，可能还希望使用保持taglib元素的简练性的一个简短的uri。这就是部署描述符文件的taglib元素派用场的所在了。Taglib包含两个子元素：taglib-uri和taglib-location。taglib-uri元素应该与用于JSP taglib元素的uri属性的东西相匹配。Taglib-location元素给出TLD文件的实际位置。例如，假如你将文件chart-tags- 1.3beta.tld放在WebApp/WEB-INF/tlds中。现在，假如web.xml在web-app元素内包含下列内容。
<taglib>
<taglib-uri>/charts.tld</taglib-uri>
<taglib-location>
/WEB-INF/tlds/chart-tags-1.3beta.tld
</taglib-location>
</taglib>
给出这个说明后，JSP页面可通过下面的简化形式使用标签库。
<%@ taglib uri="/charts.tld" prefix="somePrefix" %>

14 指定应用事件监听程序

应用事件监听器程序是建立或修改servlet环境或会话对象时通知的类。它们是servlet规范的版本2.3中的新内容。这里只简单地说明用来向Web应用注册一个监听程序的web.xml的用法。
注册一个监听程序涉及在web.xml的web-app元素内放置一个listener元素。在listener元素内，listener-class元素列出监听程序的完整的限定类名，如下所示：
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
虽然listener元素的结构很简单，但请不要忘记，必须正确地给出web-app元素内的子元素的次序。listener元素位于所有的servlet 元素之前以及所有filter-mapping元素之后。此外，因为应用生存期监听程序是serlvet规范的2.3版本中的新内容，所以必须使用 web.xml DTD的2.3版本，而不是2.2版本。
例如，程序清单5-20给出一个名为ContextReporter的简单的监听程序，只要Web应用的Servlet-Context建立（如装载Web应用）或消除（如服务器关闭）时，它就在标准输出上显示一条消息。程序清单5-21给出此监听程序注册所需要的web.xml文件的一部分。

程序清单5-20 ContextReporterjava
package moreservlets;

import javax.servlet.*;
import java.util.*;

/** Simple listener that prints a report on the standard output
* when the ServletContext is created or destroyed.
* <P>
* Taken from More Servlets and JavaServer Pages
* from Prentice Hall and Sun Microsystems Press,
* http://www.moreservlets.com/.
* © 2002 Marty Hall; may be freely used or adapted.
*/

public class ContextReporter implements ServletContextListener {
public void contextInitialized(ServletContextEvent event) {
System.out.println("Context created on " +
new Date() + ".");
}

public void contextDestroyed(ServletContextEvent event) {
System.out.println("Context destroyed on " +
new Date() + ".");
}
}


程序清单5-21 web.xml（声明一个监听程序的摘录）
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
" http://java.sun.com/dtd/web-app_2_3.dtd ">

<web-app>
<!-- ... -->
<filter-mapping> … </filter-mapping>
<listener>
<listener-class>package.ListenerClass</listener-class>
</listener>
<servlet> ... </servlet>
<!-- ... -->
</web-app>


15 J2EE元素

本节描述用作J2EE环境组成部分的Web应用的web.xml元素。这里将提供一个简明的介绍，详细内容可以参阅 http://java.sun.com/j2ee/j2ee-1_3-fr-spec.pdf 的Java 2 Plantform Enterprise Edition版本1.3规范的第5章。
l distributable
distributable 元素指出，Web应用是以这样的方式编程的：即，支持集群的服务器可安全地在多个服务器上分布Web应用。例如，一个可分布的应用必须只使用 Serializable对象作为其HttpSession对象的属性，而且必须避免用实例变量（字段）来实现持续性。distributable元素直接出现在discription元素之后，并且不包含子元素或数据，它只是一个如下的标志。
<distributable />
l resource-env-ref
resource -env-ref元素声明一个与某个资源有关的管理对象。此元素由一个可选的description元素、一个resource-env-ref- name元素（一个相对于java:comp/env环境的JNDI名）以及一个resource-env-type元素（指定资源类型的完全限定的类），如下所示：
<resource-env-ref>
<resource-env-ref-name>
jms/StockQueue
</resource-env-ref-name>
<resource-env-ref-type>
javax.jms.Queue
</resource-env-ref-type>
</resource-env-ref>
l env-entry
env -entry元素声明Web应用的环境项。它由一个可选的description元素、一个env-entry-name元素（一个相对于java: comp/env环境JNDI名）、一个env-entry-value元素（项值）以及一个env-entry-type元素（java.lang程序包中一个类型的完全限定类名，java.lang.Boolean、java.lang.String等）组成。下面是一个例子：
<env-entry>
<env-entry-name>minAmout</env-entry-name>
<env-entry-value>100.00</env-entry-value>
<env-entry-type>minAmout</env-entry-type>
</env-entry>
l ejb-ref
ejb -ref元素声明对一个EJB的主目录的应用。它由一个可选的description元素、一个ejb-ref-name元素（相对于java: comp/env的EJB应用）、一个ejb-ref-type元素（bean的类型，Entity或Session）、一个home元素（bean的主目录接口的完全限定名）、一个remote元素（bean的远程接口的完全限定名）以及一个可选的ejb-link元素（当前bean链接的另一个 bean的名称）组成。
l ejb-local-ref
ejb-local-ref元素声明一个EJB的本地主目录的引用。除了用local-home代替home外，此元素具有与ejb-ref元素相同的属性并以相同的方式使用。
posted @ 2006-09-01 17:17 阿成 阅读(203) | 评论 (0) | 编辑 收藏
Java Servlet API说明文档【转载】
Java Servlet API说明文档（2.1a版）
译者前言：
近来在整理有关Servlet资料时发现，在网上竟然找不到一份中文的Java Servlet API的说明文档，而在有一本有关JSP的书后面附的Java Servlet API说明竟然不全，而这份文档的2.1a版在1998年的11月份就已定稿。所以我决定翻译一份中文的文档（其中一些与技术关系不大的部分已被略去），有兴趣的读者可以从http: //java.sun.com/products/servlet/2.1/servletspec-2.1.zip下载原文阅读。


Java Servlet API说明文档（2.1a版）
1998年11月


绪言
这是一份关于2.1版Java Servlet API的说明文档，作为对这本文档的补充，你可以到http://java.sun.com/products/servlet/index.html下面下载Javadoc格式的文档。

谁需要读这份文档
这份文档描述了Java Servlet API的最新版本2.1版。所以，这本书对于Servlet的开发者及servlet引擎的开发者同样适用。

Java Servlet API的组成
Java Servlet API由两个软件包组成：一个是对应HTTP的软件包，另一个是不对应HTTP的通用的软件包。这两个软件包的同时存在使得Java Servlet API能够适应将来的其他请求-响应的协议。
这份文档以及刚才提及的Javadoc格式的文档都描述了这两个软件包，Javadoc格式的文档还描述了你应该如何使用这两个软件包中的所有方法。

有关规范
你也许对下面的这些Internet规范感兴趣，这些规范将直接影响到Servlet API的发展和执行。你可以从http: //info.internet.isi.edu/7c/in-notes/rfc/.cache 找到下面提到的所有这些RFC规范。
RFC 1738 统一资源定位器(URL)
RFC 1808 相关统一资源定位器
RFC 1945 超文本传输协议--HTTP/1.0
RFC 2045 多用途Internet邮件扩展(多用途网际邮件扩充协议(MIME))第一部分:Internet信息体格式
RFC 2046 多用途Internet邮件扩展(多用途网际邮件扩充协议(MIME))第二部分:媒体类型
RFC 2047 多用途网际邮件扩充协议(MIME)(多用途Internet邮件扩展)第三部分:信息标题扩展用于非ASCII文本
RFC 2048 多用途Internet邮件扩展(多用途网际邮件扩充协议(MIME))第四部分: 注册步骤
RFC 2049 多用途Internet邮件扩展(多用途网际邮件扩充协议(MIME))第五部分:一致性标准和例子
RFC 2068 超文本传输协议 -- HTTP/1.1
RFC 2069 一个扩展HTTP:摘要访问鉴定
RFC 2109 HTTP状态管理机制
RFC 2145 HTTP 版本号的使用和解释
RFC 2324 超文本Coffee Pot控制协议 (HTCPCP/1.0)
万维网协会（http://www.w3.org）管理着这些协议的规范和执行。/


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

API对象的说明
这一部分包含了对Java Servlet API的全部类和接口的详细说明。这个说明与Javadoc API差不多，但是这份文档提供了更多的信息。
API包含了两个软件包，十二个接口和九个类。
软件包：javax.servlet
所包含的接口：RequestDispatcher；Servlet；ServletConfig；ServletContext；ServletRequest；ServletResponse；SingleThreadModel。
所包含的类：GenericServlet；ServletInputStream；ServletOutputStream；ServletException；UnavailableException。

一、RequestDispatcher接口：
定义：
public interface RequestDispatcher;
定义一个对象，从客户端接收请求，然后将它发给服务器的可用资源（例如Servlet、CGI、HTML文件、JSP文件）。Servlet引擎创建request dispatcher对象，用于封装由一个特定的URL定义的服务器资源。
这个接口是专用于封装Servlet的，但是一个Servlet引擎可以创建request dispatcher对象用于封装任何类型的资源。
request dispatcher对象是由Servlet引擎建立的，而不是由Servlet开发者建立的。
方法
1、forward
public void forward(ServletRequest request, ServletReponse response)
throws ServletException, IOException;
被用来从这个Servlet向其它服务器资源传递请求。当一个Servlet对响应作了初步的处理，并要求其它的对象对此作出响应时，可以使用这个方法。
当request对象被传递到目标对象时，请求的URL路径和其他路径参数会被调整为反映目标对象的目标URL路径。
如果已经通过响应返回了一个ServletOutputStream对象或PrintWriter对象，这个方法将不能使用，否则，这个方法会抛出一个IllegalStateException。
2、include
public void include(ServletRequest request, ServletResponse response)
throws ServletException, IOException
用来包括发送给其他服务器资源的响应的内容。本质上来说，这个方法反映了服务器端的内容。
请求对象传到目标对象后会反映调用请求的请求URL路径和路径信息。这个响应对象只能调用这个Servlet的ServletOutputStream对象和PrintWriter对象。
一个调用include的Servlet不能设置头域，如果这个Servlet调用了必须设置头域的方法（例如cookie），这个方法将不能保证正常使用。作为一个Servlet开发者，你必须妥善地解决那些可能直接存储头域的方法。例如，即使你使用会话跟踪，为了保证session的正常工作，你必须在一个调用include的Servlet之外开始你的session

二、Servlet接口。
定义
public interface Servlet
这个接口定义了一个Servlet：一个在Web服务器上继承了这个功能的Java类。
方法
1、init
public void init(ServletConfig config) throws ServletException;
Servlet引擎会在Servlet实例化之后，置入服务之前精确地调用init方法。在调用service方法之前，init方法必须成功退出。
如果init方法抛出一个ServletException，你不能将这个Servlet置入服务中，如果init方法在超时范围内没完成，我们也可以假定这个Servlet是不具备功能的，也不能置入服务中。
2、service
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException;
Servlet引擎调用这个方法以允许Servlet响应请求。这个方法在Servlet未成功初始化之前无法调用。在Servlet被初始化之前，Servlet引擎能够封锁未决的请求。
在一个Servlet对象被卸载后，直到一个新的Servelt被初始化，Servlet引擎不能调用这个方法
3、destroy
public void destroy();
当一个Servlet被从服务中去除时，Servlet引擎调用这个方法。在这个对象的service方法所有线程未全部退出或者没被引擎认为发生超时操作时，destroy方法不能被调用。
4、getServletConfig
public ServletConfig getServletConfig();
返回一个ServletConfig对象，作为一个Servlet的开发者，你应该通过init方法存储ServletConfig对象以便这个方法能返回这个对象。为了你的便利，GenericServlet在执行这个接口时，已经这样做了。
5、getServletInfo
public String getServletInfo();
允许Servlet向主机的Servlet运行者提供有关它本身的信息。返回的字符串应该是纯文本格式而不应有任何标志（例如HTML，XML等）。

三、ServletConfig接口
定义
public interface ServletConfig
这个接口定义了一个对象，通过这个对象，Servlet引擎配置一个Servlet并且允许Servlet获得一个有关它的ServletContext接口的说明。每一个ServletConfig对象对应着一个唯一的Servlet。
方法
1、getInitParameter
public String getInitParameter(String name);
这个方法返回一个包含Servlet指定的初始化参数的String。如果这个参数不存在，返加空值。
2、getInitParameterNames
public Enumeration getInitParameterNames();
这个方法返回一个列表String对象，该对象包括Servlet的所有初始化参数名。如果Servlet没有初始化参数，getInitParameterNames返回一个空的列表。
3、getServletContext
public ServletContext getServletContext();
返回这个Servlet的ServletContext对象。

四、ServletContext接口
定义
public interface ServletContext
定义了一个Servlet的环境对象，通过这个对象，Servlet引擎向Servlet提供环境信息。
一个Servlet的环境对象必须至少与它所驻留的主机是一一对应的。在一个处理多个虚拟主机的Servlet引擎中（例如，使用了HTTP1.1的主机头域），每一个虚拟主机必须被视为一个单独的环境。此外，Servlet引擎还可以创建对应于一组Servlet的环境对象。
方法
1、getAttribute
public Object getAttribute(String name);
返回Servlet环境对象中指定的属性对象。如果该属性对象不存在，返回空值。这个方法允许访问有关这个Servlet引擎的在该接口的其他方法中尚未提供的附加信息。
2、getAttributeNames
public Enumeration getAttributeNames();
返回一个Servlet环境对象中可用的属性名的列表。
3、getContext
public ServletContext getContext(String uripath);
返回一个Servlet环境对象，这个对象包括了特定URI路径的Servlets和资源，如果该路径不存在，则返回一个空值。URI路径格式是/dir/dir/filename.ext。
为了安全，如果通过这个方法访问一个受限制的Servlet的环境对象，会返回一个空值。
4、getMajorVersion
public int getMajorVersion();
返回Servlet引擎支持的Servlet API的主版本号。例如对于2.1版，这个方法会返回一个整数2。
5、getMinorVersion
public int getMinorVersion();
返回Servlet引擎支持的Servlet API的次版本号。例如对于2.1版，这个方法会返回一个整数2。
6、getMimeType
public String getMimeType(String file);
返回指定文件的MIME类型，如果这种MIME类型未知，则返回一个空值。MIME类型是由Servlet引擎的配置决定的。
7、getRealPath
public String getRealPath(String path);
一个符合URL路径格式的指定的虚拟路径的格式是：/dir/dir/filename.ext。用这个方法，可以返回与一个符合该格式的虚拟路径相对应的真实路径的String。这个真实路径的格式应该适合于运行这个Servlet引擎的计算机（包括其相应的路径解析器）。
不管是什么原因，如果这一从虚拟路径转换成实际路径的过程不能执行，该方法将会返回一个空值。
8、getResource
public URL getResource(String uripath);
返回一个URL对象，该对象反映位于给定的URL地址（格式：/dir/dir/filename.ext）的Servlet环境对象已知的资源。无论 URLStreamHandlers对于访问给定的环境是不是必须的，Servlet引擎都必须执行。如果给定的路径的Servlet环境没有已知的资源，该方法会返回一个空值。
这个方法和java.lang.Class的getResource方法不完全相同。 java.lang.Class的getResource方法通过装载类来寻找资源。而这个方法允许服务器产生环境变量给任何资源的任何Servlet，而不必依赖于装载类、特定区域等等。
9、getResourceAsStream
public InputStream getResourceAsStream(String uripath);
返回一个InputStream对象，该对象引用指定的URL的Servlet环境对象的内容。如果没找到Servlet环境变量，就会返回空值，URL路径应该具有这种格式：/dir/dir/filename.ext。
这个方法是一个通过getResource方法获得URL对象的方便的途径。请注意，当你使用这个方法时，meta-information（例如内容长度、内容类型）会丢失。
10、getRequestDispatcher
public RequestDispatcher getRequestDispatcher(String uripath);
如果这个指定的路径下能够找到活动的资源(例如一个Servlet，JSP页面，CGI等等)就返回一个特定URL的RequestDispatcher 对象，否则，就返回一个空值，Servlet引擎负责用一个request dispatcher对象封装目标路径。这个 request dispatcher对象可以用来完全请求的传送。
11、getServerInfo
public String getServerInfo();
返回一个String对象，该对象至少包括Servlet引擎的名字和版本号。
12、log
public void log(String msg);
public void log(String msg, Throwable t);
public void log(Exception exception, String msg); // 这种用法将被取消
写指定的信息到一个Servlet环境对象的log文件中。被写入的log文件由Servlet引擎指定，但是通常这是一个事件log。当这个方法被一个异常调用时，log中将包括堆栈跟踪。
13、setAttribute
public void setAttribute(String name, Object o);
给予Servlet环境对象中你所指定的对象一个名称。
14、removeAttribute
public void removeAttribute(String name);
从指定的Servlet环境对象中删除一个属性。
注：以下几个方法将被取消
15、getServlet
public Servlet getServlet(String name) throws ServletException;
最初用来返回一个指定名称的Servlet，如果没找到就返回一个空值。如果这个Servlet能够返回，这就意味着它已经被初始化，而且已经可以接受 service请求。这是一个危险的方法。当调用这个方法时，可能并不知道Servlet的状态，这就可能导致有关服务器状态的问题。而允许一个 Servlet访问其他Servlet的这个方法也同样的危险。
现在这个方法返回一个空值，为了保持和以前版本的兼容性，现在这个方法还没有被取消。在以后的API版本中，该方法将被取消。
16、getServletNames
public Enumeration getServletNames();
最初用来返回一个String对象的列表，该列表表示了在这个Servlet环境下所有已知的Servlet对象名。这个列表总是包含这个Servlet自身。
基于与上一个方法同样的理由，这也是一个危险的方法。
现在这个方法返回一个空的列表。为了保持和以前版本的兼容性，现在这个方法还没有被取消。在以后的API版本中，该方法将被取消。
17、getServlets
public Enumeration getServlets();
最初用来返回在这个Servelet环境下所有已知的Servlet对象的列表。这个列表总是包含这个Servlet自身。
基于与getServlet方法同样的理由，这也是一个危险的方法。
现在这个方法返回一个空的列表。为了保持和以前版本的兼容性，现在这个方法还没有被取消。在以后的API版本中，该方法将被取消。

五、ServletRequest接口
定义
public interface ServletRequest
定义一个Servlet引擎产生的对象，通过这个对象，Servlet可以获得客户端请求的数据。这个对象通过读取请求体的数据提供包括参数的名称、值和属性以及输入流的所有数据。
方法
1、getAttribute
public Object getAttribute(String name);
返回请求中指定属性的值，如果这个属性不存在，就返回一个空值。这个方法允许访问一些不提供给这个接口中其他方法的请求信息以及其他Servlet放置在这个请求对象内的数据。
2、getAttributeNames
public Enumeration getAttributeNames();
返回包含在这个请求中的所有属性名的列表。
3、getCharacterEncoding
public String getCharacterEncoding();
返回请求中输入内容的字符编码类型，如果没有定义字符编码类型就返回空值。
4、getContentLength
public int getContentLength();
请求内容的长度，如果长度未知就返回-1。
5、getContentType
public String getContentType();
返回请求数据体的MIME类型，如果类型未知返回空值。
6、getInputStream
public ServletInputStream getInputStream() throws IOException;
返回一个输入流用来从请求体读取二进制数据。如果在此之前已经通过getReader方法获得了要读取的结果，这个方法会抛出一个IllegalStateException。
7、getParameter
public String getParameter(String name);
以一个String返回指定的参数的值，如果这个参数不存在返回空值。例如，在一个HTTP Servlet中，这个方法会返回一个指定的查询语句产生的参数的值或一个被提交的表单中的参数值。如果一个参数名对应着几个参数值，这个方法只能返回通过getParameterValues方法返回的数组中的第一个值。因此，如果这个参数有（或者可能有）多个值，你只能使用getParameterValues方法。
8、getParameterNames
public Enumeration getParameterNames();
返回所有参数名的String对象列表，如果没有输入参数，该方法返回一个空值。
9、getParameterValues
public String[] getParameterValues(String name);
通过一个String对象的数组返回指定参数的值，如果这个参数不存在，该方法返回一个空值。
10、getProtocol
public String getProtocol();
返回这个请求所用的协议，其形式是协议/主版本号.次版本号。例如对于一个HTTP1.0的请求，该方法返回HTTP/1.0。
11、getReader
public BufferedReader getReader() throws IOException;
这个方法返回一个buffered reader用来读取请求体的实体，其编码方式依照请求数据的编码方式。如果这个请求的输入流已经被getInputStream调用获得，这个方法会抛出一个IllegalStateException。
12、getRemoteAddr
public String getRemoteAddr();
返回发送请求者的IP地址。
13、getRemoteHost
public String getRemoteHost();
返回发送请求者的主机名称。如果引擎不能或者选择不解析主机名（为了改善性能），这个方法会直接返回IP地址。
14、getScheme
public String getScheme();
返回请求所使用的URL的模式。例如，对于一个HTTP请求，这个模式就是http。
15、getServerName
public String getServerName();
返回接收请求的服务器的主机名。
16、getServerPort
public int getServerPort();
返回接收请求的端口号。
17、setAttribute
public void setAttribute(String name, Object object);
这个方法在请求中添加一个属性，这个属性可以被其他可以访问这个请求对象的对象（例如一个嵌套的Servlet）使用。
注：以下方法将被取消
getRealPath
public String getRealPath(String path);
返回与虚拟路径相对应的真实路径，如果因为某种原因，这一过程不能进行，该方法将返回一个空值。
这个方法和ServletContext接口中的getRealPath方法重复。在2.1版中，ServletContext接口将阐明一个 Servlet所能用的所有的路径的映射。该方法执行的结果将会与ServletContext中getRealPath方法的结果完全一样。

六、ServletResponse接口
定义
public interface ServletResponse
定义一个Servlet引擎产生的对象，通过这个对象，Servlet对客户端的请求作出响应。这个响应应该是一个MIME实体，可能是一个HTML页、图象数据或其他MIME的格式。
方法
1、getCharacterEncoding
public String getCharacterEncoding();
返回MIME实体的字符编码。这个字符编码可以是指定的类型，也可以是与请求头域所反映的客户端所能接受的字符编码最匹配的类型。在HTTP协议中，这个信息被通过Accept-Charset传送到Servlet引擎。
有关字符编码和MIME的更多信息请参看RFC 2047。
2、getOutputStream
public ServletOutputStream getOutputStream() throws IOException;
返回一个记录二进制的响应数据的输出流。
如果这个响应对象已经调用getWriter，将会抛出IllegalStateException。
3、getWriter
public PrintWriter getWriter throws IOException;
这个方法返回一个PringWriter对象用来记录格式化的响应实体。如果要反映使用的字符编码，必须修改响应的MIME类型。在调用这个方法之前，必须设定响应的content类型。
如果没有提供这样的编码类型，会抛出一个UnsupportedEncodingException，如果这个响应对象已调用getOutputStream，会抛出一个getOutputStream。
4、setContentLength
public void setContentLength(int length);
设置响应的内容的长度，这个方法会覆盖以前对内容长度的设定。
为了保证成功地设定响应头的内容长度，在响应被提交到输出流之前必须调用这个方法。
5、setContentType
public void setContentType(String type);
这个方法用来设定响应的content类型。这个类型以后可能会在另外的一些情况下被隐式地修改，这里所说的另外的情况可能当服务器发现有必要的情况下对MIME的字符设置。
为了保证成功地设定响应头的content类型，在响应被提交到输出流之前必须调用这个方法。

七、SingleThreadModel接口
定义
public interface SingleThreadModel;
这是一个空接口，它指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定，那么在这个Servlet中的service方法中将不会有两个线程被同时执行。
Servlet可以通过维持一个各自独立的Servlet实例池，或者通过只让Servlet的service中只有一个线程的方法来实现这个保证。

八、GenericServlet类
public abstract class GenericServlet implements Servlet,
ServletConfig, Serializable;
这个类的存在使得编写Servlet更加方便。它提供了一个简单的方案，这个方案用来执行有关Servlet生命周期的方法以及在初始化时对ServletConfig对象和ServletContext对象进行说明。
方法
1、destroy
public void destroy();
在这里destroy方法不做任何其他的工作。
2、getInitParameter
public String getInitParameter(String name);
这是一个简便的途径，它将会调用ServletConfig对象的同名的方法。
3、getInitParameterNames
public Enumeration getInitParameterNames();
这是一个简便的途径，它将会调用ServletConfig对象的同名的方法。
4、getServletConfig
public ServletConfig getServletConfig();
返回一个通过这个类的init方法产生的ServletConfig对象的说明。
5、getServletContext
public ServletContext getServletContext();
这是一个简便的途径，它将会调用ServletConfig对象的同名的方法。
6、getServletInfo
public String getServletInfo();
返回一个反映Servlet版本的String。
7、init
public void init() throws ServletException;
public void init(ServletConfig config) throws ServletException;
init(ServletConfig config)方法是一个对这个Servlet的生命周期进行初始化的简便的途径。
init()方法是用来让你对GenericServlet类进行扩充的，使用这个方法时，你不需要存储config对象，也不需要调用super.init(config)。
init(ServletConfig config)方法会存储config对象然后调用init()。如果你重载了这个方法，你必须调用super.init(config)，这样GenericServlet类的其他方法才能正常工作。
8、log
public void log(String msg);
public void log(String msg, Throwable cause);
通过Servlet content对象将Servlet的类名和给定的信息写入log文件中。
9、service
public abstract void service(ServletRequest request, ServletResponse
response) throws ServletException, IOException;
这是一个抽象的方法，当你扩展这个类时，为了执行网络请求，你必须执行它。

九、ServletInputStream类
定义
public abstract class ServletInputStream extends InputStream
这个类定义了一个用来读取客户端的请求信息的输入流。这是一个Servlet引擎提供的抽象类。一个Servlet通过使用ServletRequest接口获得了对一个ServletInputStream对象的说明。
这个类的子类必须提供一个从InputStream接口读取有关信息的方法。
方法
1、readLine
public int readLine(byte[] b, int off, int len) throws IOException;
从输入流的指定的偏移量开始将指定长度的字节读入到指定的数组中。如果该行所有请求的内容都已被读取，这个读取的过程将结束。如果是遇到了新的一行，新的一行的首个字符也将被读入到数组中。

十、ServletOutputStream类
定义
public abstract class ServletOutputStream extends OutputStream
这是一个由Servlet引擎使用的抽象类。Servlet通过使用ServletResponse接口的使用获得了对一个这种类型的对象的说明。利用这个输出流可以将数据返回到客户端。
这个类的子类必须提供一个向OutputStream接口写入有关信息的方法。
在这个接口中，当一个刷新或关闭的方法被调用时。所有数据缓冲区的信息将会被发送到客户端，也就是说响应被提交了。请注意，关闭这种类型的对象时不一定要关闭隐含的socket流。
方法
1、print
public void print(String s) throws IOException;
public void print(boolean b) throws IOException;
public void print(char c) throws IOException;
public void print(int i) throws IOException;
public void print(long l) throws IOException;
public void print(float f) throws IOException;
public void print(double d) throws IOException;
输出变量到输出流中
2、println
public void println() throws IOException;
public void println(String s) throws IOException;
public void println(boolean b) throws IOException;
public void println(char c) throws IOException;
public void println(int i) throws IOException;
public void println(long l) throws IOException;
public void println(float f) throws IOException;
public void println(double d) throws IOException;
输出变量到输出流中，并增加一个回车换行符

十一、ServletException类
定义
public class ServletException extends Exception
当Servlet遇到问题时抛出的一个异常。
构造函数
public ServletException();
public ServletException(String message);
public ServletException(String message, Throwable cause);
public ServletException(Throwable cause);
构造一个新的ServletException，如果这个构造函数包括一个Throwable参数，这个Throwable对象将被作为可能抛出这个异常的原因。
方法
1、getRootCause
public Throwable getRootCause();
如果配置了抛出这个异常的原因，这个方法将返回这个原因，否则返回一个空值。

十二、UnavailableException类
定义
public class UnavailableException extends ServletException
不论一个Servlet是永久地还是临时地无效，都会抛出这个异常。Servlet会记录这个异常以及Servlet引擎所要采取的相应措施。
临时的无效是指Servlet在某一时间由于一个临时的问题而不能处理请求。例如，在另一个不同的应用层的服务（可能是数据库）无法使用。这个问题可能会自行纠正或者需要采取其他的纠正措施。
永久的无效是指除非管理员采取措施，这个Servlet将不能处理客户端的请求。例如，这个Servlet配置信息丢失或Servlet的状态被破坏。
Servlet 引擎可以安全地处理包括永久无效在内的这两种异常，但是对临时无效的正常处理可以使得Servlet引擎更健壮。特别的，这时对Servlet的请求只是被阻止（或者是被延期）一段时间，这显然要比在service自己重新启动前完全拒绝请求更为科学。
构造函数
public UnavailableException(Servlet servlet, String message);
public UnavailableException(int seconds, Servlet servlet,
String message);
构造一个包含指定的描述信息的新的异常。如果这个构造函数有一个关于秒数的参数，这将给出Servlet发生临时无效后，能够重新处理请求的估计时间。如果不包含这个参数，这意味着这个Servlet永久无效。
方法
1、getServlet
public Servlet getServlet();
返回报告无效的Servlet。这被Servlet引擎用来识别受到影响的Servlet。
2、getUnavailableSeconds
public int getUnavailableSeconds();
返回Servlet预期的无效时间，如果这个Servlet是永久无效，返回-1。
3、isPermanent
public boolean isPermanent();
如果这个Servlet永久无效，返回布尔值true，指示必须采取一些管理行动以使得这个Servlet可用。

软件包：javax.servlet.http
所包含的接口：HttpServletRequest；HttpServletResponse；HttpSession；HttpSessionBindingListener；HttpSessionContext。
所包含的类：Cookie；HttpServlet；HttpSessionBindingEvent；HttpUtils。

一、HttpServletRequest接口
定义\
public interface HttpServletRequest extends ServletRequest;
用来处理一个对Servlet的HTTP格式的请求信息。
方法
1、getAuthType
public String getAuthType();
返回这个请求的身份验证模式。
2、getCookies
public Cookie[] getCookies();
返回一个数组，该数组包含这个请求中当前的所有cookie。如果这个请求中没有cookie，返回一个空数组。
3、getDateHeader
public long getDateHeader(String name);
返回指定的请求头域的值，这个值被转换成一个反映自1970-1-1日（GMT）以来的精确到毫秒的长整数。
如果头域不能转换，抛出一个IllegalArgumentException。如果这个请求头域不存在，这个方法返回-1。
4、getHeader
public String getHeader(String name);
返回一个请求头域的值。（译者注：与上一个方法不同的是，该方法返回一个字符串）
如果这个请求头域不存在，这个方法返回-1。
5、getHeaderNames
public Enumeration getHeaderNames();
该方法返回一个String对象的列表，该列表反映请求的所有头域名。
有的引擎可能不允许通过这种方法访问头域，在这种情况下，这个方法返回一个空的列表。
6、getIntHeader
public int getIntHeader(String name);
返回指定的请求头域的值，这个值被转换成一个整数。
如果头域不能转换，抛出一个IllegalArgumentException。如果这个请求头域不存在，这个方法返回-1。
7、getMethod
public String getMethod();
返回这个请求使用的HTTP方法（例如：GET、POST、PUT）
8、getPathInfo
public String getPathInfo();
这个方法返回在这个请求的URL的Servlet路径之后的请求URL的额外的路径信息。如果这个请求URL包括一个查询字符串，在返回值内将不包括这个查询字符串。这个路径在返回之前必须经过URL解码。如果在这个请求的URL的Servlet路径之后没有路径信息。这个方法返回空值。
9、getPathTranslated
public String getPathTranslated();
这个方法获得这个请求的URL的Servlet路径之后的额外的路径信息，并将它转换成一个真实的路径。在进行转换前，这个请求的URL必须经过URL解码。如果在这个URL的Servlet路径之后没有附加路径信息。这个方法返回空值。
10、getQueryString
public String getQueryString();
返回这个请求URL所包含的查询字符串。一个查询字串符在一个URL中由一个“？”引出。如果没有查询字符串，这个方法返回空值。
11、getRemoteUser
public String getRemoteUser
返回作了请求的用户名，这个信息用来作HTTP用户论证。
如果在请求中没有用户名信息，这个方法返回空值。
12、getRequestedSessionId
public String getRequestedSessionId();
返回这个请求相应的session id。如果由于某种原因客户端提供的session id是无效的，这个session id将与在当前session中的session id不同，与此同时，将建立一个新的session。
如果这个请求没与一个session关联，这个方法返回空值。
13、getRequestURI
public String getRequestURI();
从HTTP请求的第一行返回请求的URL中定义被请求的资源的部分。如果有一个查询字符串存在，这个查询字符串将不包括在返回值当中。例如，一个请求通过 /catalog/books?id=1这样的URL路径访问，这个方法将返回/catalog/books。这个方法的返回值包括了Servlet路径和路径信息。
如果这个URL路径中的的一部分经过了URL编码，这个方法的返回值在返回之前必须经过解码。
14、getServletPath
public String getServletPath();
这个方法返回请求URL反映调用Servlet的部分。例如，一个Servlet被映射到/catalog/summer这个URL路径，而一个请求使用了/catalog/summer/casual这样的路径。所谓的反映调用Servlet的部分就是指/catalog/summer。
如果这个Servlet不是通过路径匹配来调用。这个方法将返回一个空值。
15、getSession
public HttpSession getSession();
public HttpSession getSession(boolean create);
返回与这个请求关联的当前的有效的session。如果调用这个方法时没带参数，那么在没有session与这个请求关联的情况下，将会新建一个session。如果调用这个方法时带入了一个布尔型的参数，只有当这个参数为真时，session才会被建立。
为了确保session能够被完全维持。Servlet开发者必须在响应被提交之前调用该方法。
如果带入的参数为假，而且没有session与这个请求关联。这个方法会返回空值。
16、isRequestedSessionIdValid
public boolean isRequestedSessionIdValid();
这个方法检查与此请求关联的session当前是不是有效。如果当前请求中使用的session无效，它将不能通过getSession方法返回。
17、isRequestedSessionIdFromCookie
public boolean isRequestedSessionIdFromCookie();
如果这个请求的session id是通过客户端的一个cookie提供的，该方法返回真，否则返回假。
18、isRequestedSessionIdFromURL
public boolean isRequestedSessionIdFromURL();
如果这个请求的session id是通过客户端的URL的一部分提供的，该方法返回真，否则返回假。请注意此方法与isRequestedSessionIdFromUrl在URL的拼写上不同。
以下方法将被取消\

19、isRequestedSessionIdFromUrl
public boolean isRequestedSessionIdFromUrl();
该方法被isRequestedSessionIdFromURL代替。

二、HttpServletResponse接口
定义\

public interface HttpServletResponse extends ServletResponse
描述一个返回到客户端的HTTP回应。这个接口允许Servlet程序员利用HTTP协议规定的头信息。
成员变量
public static final int SC_CONTINUE = 100;
public static final int SC_SWITCHING_PROTOCOLS = 101;
public static final int SC_OK = 200;
public static final int SC_CREATED = 201;
public static final int SC_ACCEPTED = 202;
public static final int SC_NON_AUTHORITATIVE_INFORMATION = 203;
public static final int SC_NO_CONTENT = 204;
public static final int SC_RESET_CONTENT = 205;
public static final int SC_PARTIAL_CONTENT = 206;
public static final int SC_MULTIPLE_CHOICES = 300;
public static final int SC_MOVED_PERMANENTLY = 301;
public static final int SC_MOVED_TEMPORARILY = 302;
public static final int SC_SEE_OTHER = 303;
public static final int SC_NOT_MODIFIED = 304;
public static final int SC_USE_PROXY = 305;
public static final int SC_BAD_REQUEST = 400;
public static final int SC_UNAUTHORIZED = 401;
public static final int SC_PAYMENT_REQUIRED = 402;
public static final int SC_FORBIDDEN = 403;
public static final int SC_NOT_FOUND = 404;
public static final int SC_METHOD_NOT_ALLOWED = 405;
public static final int SC_NOT_ACCEPTABLE = 406;
public static final int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
public static final int SC_REQUEST_TIMEOUT = 408;
public static final int SC_CONFLICT = 409;
public static final int SC_GONE = 410;
public static final int SC_LENGTH_REQUIRED = 411;
public static final int SC_PRECONDITION_FAILED = 412;
public static final int SC_REQUEST_ENTITY_TOO_LARGE = 413;
public static final int SC_REQUEST_URI_TOO_LONG = 414;
public static final int SC_UNSUPPORTED_MEDIA_TYPE = 415;
public static final int SC_INTERNAL_SERVER_ERROR = 500;
public static final int SC_NOT_IMPLEMENTED = 501;
public static final int SC_BAD_GATEWAY = 502;
public static final int SC_SERVICE_UNAVAILABLE = 503;
public static final int SC_GATEWAY_TIMEOUT = 504;
public static final int SC_HTTP_VERSION_NOT_SUPPORTED = 505;
以上HTTP产状态码是由HTTP/1.1定义的。
方法
1、addCookie
public void addCookie(Cookie cookie);
在响应中增加一个指定的cookie。可多次调用该方法以定义多个cookie。为了设置适当的头域，该方法应该在响应被提交之前调用。
2、containsHeader
public boolean containsHeader(String name);
检查是否设置了指定的响应头。
3、encodeRedirectURL
public String encodeRedirectURL(String url);
对sendRedirect方法使用的指定URL进行编码。如果不需要编码，就直接返回这个URL。之所以提供这个附加的编码方法，是因为在 redirect的情况下，决定是否对URL进行编码的规则和一般情况有所不同。所给的URL必须是一个绝对URL。相对URL不能被接收，会抛出一个 IllegalArgumentException。
所有提供给sendRedirect方法的URL都应通过这个方法运行，这样才能确保会话跟踪能够在所有浏览器中正常运行。
4、encodeURL
public String encodeURL(String url);
对包含session ID的URL进行编码。如果不需要编码，就直接返回这个URL。Servlet引擎必须提供URL编码方法，因为在有些情况下，我们将不得不重写URL，例如，在响应对应的请求中包含一个有效的session，但是这个session不能被非URL的（例如cookie）的手段来维持。
所有提供给Servlet的URL都应通过这个方法运行，这样才能确保会话跟踪能够在所有浏览器中正常运行。
5、sendError
public void sendError(int statusCode) throws IOException;
public void sendError(int statusCode, String message) throws
IOException;
用给定的状态码发给客户端一个错误响应。如果提供了一个message参数，这将作为响应体的一部分被发出，否则，服务器会返回错误代码所对应的标准信息。
调用这个方法后，响应立即被提交。在调用这个方法后，Servlet不会再有更多的输出。
6、sendRedirect
public void sendRedirect(String location) throws IOException;
使用给定的路径，给客户端发出一个临时转向的响应（SC_MOVED_TEMPORARILY）。给定的路径必须是绝对URL。相对URL将不能被接收，会抛出一个IllegalArgumentException。
这个方法必须在响应被提交之前调用。调用这个方法后，响应立即被提交。在调用这个方法后，Servlet不会再有更多的输出。
7、setDateHeader
public void setDateHeader(String name, long date);
用一个给定的名称和日期值设置响应头，这里的日期值应该是反映自1970-1-1日（GMT）以来的精确到毫秒的长整数。如果响应头已经被设置，新的值将覆盖当前的值。
8、setHeader
public void setHeader(String name, String value);
用一个给定的名称和域设置响应头。如果响应头已经被设置，新的值将覆盖当前的值。
9、setIntHeader
public void setIntHeader(String name, int value);
用一个给定的名称和整形值设置响应头。如果响应头已经被设置，新的值将覆盖当前的值。
10、setStatus
public void setStatus(int statusCode);
这个方法设置了响应的状态码，如果状态码已经被设置，新的值将覆盖当前的值。
以下的几个方法将被取消\
11、encodeRedirectUrl
public String encodeRedirectUrl(String url);
该方法被encodeRedirectURL取代。
12、encodeUrl
public String encodeUrl(String url);
该方法被encodeURL取代。
13、setStatus
public void setStatus(int statusCode, String message);
这个方法设置了响应的状态码，如果状态码已经被设置，新的值将覆盖当前的值。如果提供了一个message，它也将会被作为响应体的一部分被发送。

三、HttpSession接口
定义\
public interface HttpSession
这个接口被Servlet引擎用来实现在HTTP客户端和HTTP会话两者的关联。这种关联可能在多外连接和请求中持续一段给定的时间。session用来在无状态的HTTP协议下越过多个请求页面来维持状态和识别用户。
一个session可以通过cookie或重写URL来维持。
方法
1、getCreationTime
public long getCreationTime();
返回建立session的时间，这个时间表示为自1970-1-1日（GMT）以来的毫秒数。
2、getId
public String getId();
返回分配给这个session的标识符。一个HTTP session的标识符是一个由服务器来建立和维持的唯一的字符串。
3、getLastAccessedTime
public long getLastAccessedTime();
返回客户端最后一次发出与这个session有关的请求的时间，如果这个session是新建立的，返回-1。这个时间表示为自1970-1-1日（GMT）以来的毫秒数。
4、getMaxInactiveInterval
public int getMaxInactiveInterval();
返加一个秒数，这个秒数表示客户端在不发出请求时，session被Servlet引擎维持的最长时间。在这个时间之后，Servlet引擎可能被Servlet引擎终止。如果这个session不会被终止，这个方法返回-1。
当session无效后再调用这个方法会抛出一个IllegalStateException。
5、getValue
public Object getValue(String name);
返回一个以给定的名字绑定到session上的对象。如果不存在这样的绑定，返回空值。
当session无效后再调用这个方法会抛出一个IllegalStateException。
6、getValueNames
public String[] getValueNames();
以一个数组返回绑定到session上的所有数据的名称。
当session无效后再调用这个方法会抛出一个IllegalStateException。
7、invalidate
public void invalidate();
这个方法会终止这个session。所有绑定在这个session上的数据都会被清除。并通过HttpSessionBindingListener接口的valueUnbound方法发出通告。
8、isNew
public boolean isNew();
返回一个布尔值以判断这个session是不是新的。如果一个session已经被服务器建立但是还没有收到相应的客户端的请求，这个session将被认为是新的。这意味着，这个客户端还没有加入会话或没有被会话公认。在他发出下一个请求时还不能返回适当的session认证信息。
当session无效后再调用这个方法会抛出一个IllegalStateException。
9、putValue
public void putValue(String name, Object value);
以给定的名字，绑定给定的对象到session中。已存在的同名的绑定会被重置。这时会调用HttpSessionBindingListener接口的valueBound方法。
当session无效后再调用这个方法会抛出一个IllegalStateException。
10、removeValue
public void removeValue(String name);
取消给定名字的对象在session上的绑定。如果未找到给定名字的绑定的对象，这个方法什么出不做。 这时会调用HttpSessionBindingListener接口的valueUnbound方法。
当session无效后再调用这个方法会抛出一个IllegalStateException。
11、setMaxInactiveInterval
public int setMaxInactiveInterval(int interval);
设置一个秒数，这个秒数表示客户端在不发出请求时，session被Servlet引擎维持的最长时间。
以下这个方法将被取消\
12、getSessionContext
public HttpSessionContext getSessionContext();
返回session在其中得以保持的环境变量。这个方法和其他所有HttpSessionContext的方法一样被取消了。

四、HttpSessionBindingListener接口
定义\
public interface HttpSessionBindingListener
这个对象被加入到HTTP的session中，执行这个接口会通告有没有什么对象被绑定到这个HTTP session中或被从这个HTTP session中取消绑定。
方法
1、valueBound
public void valueBound(HttpSessionBindingEvent event);
当一个对象被绑定到session中，调用此方法。HttpSession.putValue方法被调用时，Servlet引擎应该调用此方法。
2、valueUnbound
public void valueUnbound(HttpSessionBindingEvent event);
当一个对象被从session中取消绑定，调用此方法。HttpSession.removeValue方法被调用时，Servlet引擎应该调用此方法。

五、HttpSessionContext接口
定义\
此接口将被取消\
public interface HttpSessionContext
这个对象是与一组HTTP session关联的单一的实体。
这个接口由于安全的原因被取消，它出现在目前的版本中仅仅是为了兼容性的原因。这个接口的方法将模拟以前的版本的定义返回相应的值。
方法
1、getSession
public HttpSession getSession(String sessionId);
当初用来返回与这个session id相关的session。现在返回空值。
2、getIds
public Enumeration getIds();
当初用来返回这个环境下所有session id的列表。现在返回空的列表。

六、Cookie类\
定义\
public class Cookie implements Cloneable
这个类描述了一个cookie，有关cookie的定义你可以参照Netscape Communications Corporation的说明，也可以参照RFC 2109。
构造函数
public Cookie(String name, String value);
用一个name-value对定义一个cookie。这个name必须能被HTTP/1.1所接受。
以字符$开头的name被RFC 2109保留。
给定的name如果不能被HTTP/1.1所接受，该方法抛出一个IllegalArgumentException。
方法
1、getComment
public String getComment();
返回描述这个cookie目的的说明，如果未定义这个说明，返回空值。
2、getDomain
public String getDomain();
返回这个cookie可以出现的区域，如果未定义区域，返回空值。
3、getMaxAge
public int getMaxAge();
这个方法返回这个cookie指定的最长存活时期。如果未定义这个最长存活时期，该方法返回-1。
4、getName
public String getName();
该方法返回cookie名。
5、getPath
public String getPath();
返回这个cookie有效的所有URL路径的前缀，如果未定义，返回空值。
6、getSecure
public boolean getSecure();
如果这个cookie只通过安全通道传输返回真，否则返回假。
7、getValue
public String getValue();
该方法返回cookie的值。
8、getVersion
public int getVersion();
返回cookie的版本。版本1由RFC 2109解释。版本0由Netscape Communications Corporation的说明解释。新构造的cookie默认使用版本0。
9、setComment
public void setComment(String purpose);
如果一个用户将这个cookie提交给另一个用户，必须通过这个说明描述这个cookie的目的。版本0不支持这个属性。
10、setDomain
public void setDomain(String pattern);
这个方法设置cookie的有效域的属性。这个属性指定了cookie可以出现的区域。一个有效域以一个点开头（.foo.com），这意味着在指定的域名解析系统的区域中（可能是http://www.foo.com但不是a.b.foo.com...乇４嫠闹骰?/a>
11、setMaxAge
public void setMaxAge(int expiry);
这个方法设定这个cookie的最长存活时期。在该存活时期之后，cookie会被终目。负数表示这个cookie不会生效，0将从客户端删除这个cookie。
12、setPath
public void setPath(String uri);
这个方法设置cookie的路径属性。客户端只能向以这个给定的路径String开头的路径返回cookie。
13、setSecure
public void setSecure(boolean flag);
指出这个cookie只能通过安全通道（例如HTTPS）发送。只有当产生这个cookie的服务器使用安全协议发送这个cookie值时才能这样设置。
14、setValue
public void setValue(String newValue);
设置这个cookie的值，对于二进制数据采用BASE64编码。
版本0不能使用空格、{}、()、=、，、“”、/、?、@、：以及；。
15、setVersion
public void setVersion(int v);
设置cookie的版本号

七、HttpServlet类\
定义\
public class HttpServlet extends GenericServlet implements
Serializable
这是一个抽象类，用来简化HTTP Servlet写作的过程。它是GenericServlet类的扩充，提供了一个处理HTTP协议的框架。
在这个类中的service方法支持例如GET、POST这样的标准的HTTP方法。这一支持过程是通过分配他们到适当的方法（例如doGet、doPost）来实现的。
方法
1、doDelete
protected void doDelete(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP DELETE操作。这个操作允许客户端请求从服务器上删除URL。这一操作可能有负面影响，对此用户就负起责任。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理DELETE请求时，你必须重载这一方法。
2、doGet
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP GET操作。这个操作允许客户端简单地从一个HTTP服务器“获得”资源。对这个方法的重载将自动地支持HEAD方法。
GET操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。
3、doHead
protected void doHead(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP HEAD操作。默认的情况是，这个操作会按照一个无条件的GET方法来执行，该操作不向客户端返回任何数据，而仅仅是返回包含内容长度的头信息。
与GET操作一样，这个操作应该是安全而且没有负面影响的。这个操作也应该可以安全地重复。
这个方法的默认执行结果是自动处理HTTP HEAD操作，这个方法不需要被一个子类执行。
4、doOptions
protected void doOptions(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP OPTION操作。这个操作自动地决定支持哪一种HTTP方法。例如，一个Servlet写了一个HttpServlet的子类并重载了doGet方法，doOption会返回下面的头：
Allow: GET,HEAD,TRACE,OPTIONS
你一般不需要重载这个方法。
5、doPost
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP POST操作。这个操作包含请求体的数据，Servlet应该按照他行事。
这个操作可能有负面影响。例如更新存储的数据或在线购物。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理POST操作时，你必须在HttpServlet的子类中重载这一方法。
6、doPut
protected void doPut(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP PUT操作。这个操作类似于通过FTP发送文件。
这个操作可能有负面影响。例如更新存储的数据或在线购物。
这一方法的默认执行结果是返回一个HTTP BAD_REQUEST错误。当你要处理PUT操作时，你必须在HttpServlet的子类中重载这一方法。
7、doTrace
protected void doTrace(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
被这个类的service方法调用，用来处理一个HTTP TRACE操作。这个操作的默认执行结果是产生一个响应，这个响应包含一个反映trace请求中发送的所有头域的信息。
当你开发Servlet时，在多数情况下你需要重载这个方法。
8、getLastModified
protected long getLastModified(HttpServletRequest request);
返回这个请求实体的最后修改时间。为了支持GET操作，你必须重载这一方法，以精确地反映最后修改的时间。这将有助于浏览器和代理服务器减少装载服务器和网络资源，从而更加有效地工作。返回的数值是自1970-1-1日（GMT）以来的毫秒数。
默认的执行结果是返回一个负数，这标志着最后修改时间未知，它也不能被一个有条件的GET操作使用。
9、service
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException;
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException;
这是一个Servlet的HTTP-specific方案，它分配请求到这个类的支持这个请求的其他方法。
当你开发Servlet时，在多数情况下你不必重载这个方法。

八、HttpSessionBindingEvent类\
定义\
public class HttpSessionBindingEvent extends EventObject
这个事件是在监听到HttpSession发生绑定和取消绑定的情况时连通HttpSessionBindingListener的。这可能是一个session被终止或被认定无效的结果。
事件源是HttpSession.putValue或HttpSession.removeValue。
构造函数
public HttpSessionBindingEvent(HttpSession session, String name);
通过引起这个事件的Session和发生绑定或取消绑定的对象名构造一个新的HttpSessionBindingEvent。
方法
1、getName
public String getName();
返回发生绑定和取消绑定的对象的名字。
2、getSession
public HttpSession getSession();
返回发生绑定和取消绑定的session的名字。

九、HttpUtils类\
定义\
public class HttpUtils
收集HTTP Servlet使用的静态的有效的方法。
方法
1、getRequestURL
public static StringBuffer getRequestURL(HttpServletRequest
request);
在服务器上重建客户端用来建立请求的URL。这个方法反映了不同的协议（例如http和https）和端口，但不包含查询字符串。
这个方法返回一个StringBuffer而不是一个String，这样URL可以被Servlet开发者有效地修改。
2、parsePostData
public static Hashtable parsePostData(int len,
ServletInputstream in);
解析一个包含MIME类型application/x-www-form-urlencoded的数据的流，并创建一个具有关键值-数据对的 hash table。这里的关键值是字符串，数据是该字符串所对应的值的列表。一个关键值可以在POST的数据中出现一次或多次。这个关键值每出现一次，它的相应的值就被加入到hash table中的字符串所对应的值的列表中。
从POST数据读出的数据将经过URL解码，+将被转换为空格以十六进制传送的数据（例如%xx）将被转换成字符。
当POST数据无效时，该方法抛出一个IllegalArgumentException。
3、parseQueryString
public static Hashtable parseQueryString(String s);
解析一个查询字符串，并创建一个具有关键值-数据对的hash table。这里的数据是该字符串所对应的值的列表。一个关键值可以出现一次或多次。这个关键值每出现一次，它的相应的值就被加入到hash table中的字符串所对应的值的列表中。
从查询字符串读出的数据将经过URL解码，+将被转换为空格以十六进制传送的数据（例如%xx）将被转换成字符。
当查询字符串无效时，该方法抛出一个IllegalArgumentException。

术语表
bytecode
字节码：由Java编译器和Java解释程序生成的机器代码。
cookie
由Web服务器建立的数据，该数据存储在用户的计算机上，提供了一个Web站点跟踪用户的参数并存储在用户自己硬盘上的方法。
HTTP
超文本传输协议。一个请求响应协议用来连接WWW服务器向客户端浏览器传输HTML页面。
输入流对象
一个对象，由ServletInputStream类定义，被Servlet用来从客户端读取请求。
映射
由Servlet实例和Servlet返回数据的URL组成的一对，例如，HelloServlet和/hello/index.html。
输出流对象
一个对象，由ServletOutputStream class类定义，被Servlet用来向客户端返回数据。
request dispatcher object
由RequestDispatcher接口定义的一个对象，用来从客户端接收请求，并将其发送到Web服务器上可用的其他资源（例如Servlet、CGI、HTML文件或JSP文件）。
sandboxed servlet
在一个安全性约束下运行的Servlet。
servlet
一个小的，具有平台无关性的，没有图形用户界面的Java程序。它可以在许多方面扩充Web服务的功能。
servlet configuration object
ServletConfig接口定义的一个对象，用来配置一个Servlet。
servlet context object
ServletContext接口定义的一个对象。给予Servlet有关Servlet引擎的信息。
servlet引擎
由Web服务器提供商制作的一个环境，可以允许Servlet在具体的Web服务器上运行。
servlet请求对象
由ServletRequest接口定义的一个对象，允许Servlet获得用关客户端请求的数据。
servlet response object
由ServletResponse接口定义的一个对象，允许Servlet作出响应。
servlet runner
Java Servlet Developer’s Kit (JSDK)中的sun.servlet.http.HttpServer过程，它使得Servlet得以运行。
会话跟踪
在一个Web应用程序中，识别一个从同一个客户端发出的连续的唯一的请求的能力。
SSL
加密套接字协议层。一个安全协议，用来在Iternet上的客户端浏览器和服务器交换密钥和加密数据。
URI
统一资源标识。定义一个Internet地址，它是一个URL的超集。
URL
统一资源路径。这个地址定义了到达一个WWW上的文件的路线，通常由协议前缀、域名、目录名和文件名组成。
posted @ 2006-09-01 17:06 阿成 阅读(231) | 评论 (0) | 编辑 收藏
servlet 相关的Listener应用 作者： colin_ch （抄自javaeye）
从作用域范围来说,Servlet的作用域有ServletContext,HttpSession,ServletRequest.

Context范围:

ServletContextListener:
对一个应用进行全局监听.随应用启动而启动,随应用消失而消失主要有两个方法:
contextDestroyed(ServletContextEvent event)
在应用关闭的时候调用
contextInitialized(ServletContextEvent event)
在应用启动的时候调用

这个监听器主要用于一些随着应用启动而要完成的工作,也就是很多人说的我想在容器
启动的时候干..........
一般来说对"全局变量"初始化,如
public void contextInitialized(ServletContextEvent event){
ServletContex sc = event.getServletContext();
sc.setAttribute(name,value);
}
以后你就可以在任何servlet中getServletContext().getAttribute(name);
我最喜欢用它来做守护性工作,就是在contextInitialized(ServletContextEvent event)
方法中实现一个Timer,然后就让应用在每次启动的时候让这个Timer工作:
public void contextInitialized(ServletContextEvent event){
timer = new Timer();
timer.schedule(new TimerTask(){
public void run(){
//do any things
}
},0,时间间隔);
}

有人说Timer只能规定从现在开始的多长时间后,每隔多久做一次事或在什么时间做
一次事,那我想在每月1号或每天12点做一项工作如何做呢?
你只要设一个间隔,然后每次判断一下当时是不是那个时间段就行了啊,比如每月一号做,那你
时间间隔设为天,即24小时一个循环,然后在run方法中判断当时日期new Date().getDate()==1
就行了啊.如果是每天的12点,那你时间间隔设为小时,然后在run中判断new Date().getHour()
==12,再做某事就行了.

ServletContextAttributeListener:

这个监听器主要监听ServletContex对象在setAttribute()和removeAttribute()的事件,注意
也就是一个"全局变量"在被Add(第一次set),replace(对已有的变量重新赋值)和remove的时候.
分别调用下面三个方法:
public void attributeAdded(ServletContextAttributeEvent scab)这个方法不仅可以知道
哪些全局变量被加进来,而且可获取容器在启动时自动设置了哪些context变量:

public void attributeAdded(ServletContextAttributeEvent scab){
System.out.println(scab.getName());
}
public void attributeRemoved(ServletContextAttributeEvent scab)

public void attributeReplaced(ServletContextAttributeEvent scab)










Session范围:
HttpSessionListener:
这个监听器主要监听一个Session对象被生成和销毁时发生的事件.对应有两个方法:
public void sessionCreated(HttpSessionEvent se)

public void sessionDestroyed(HttpSessionEvent se)

一般来说,一个session对象被create时,可以说明有一个新客端进入.可以用来粗略统计在线人
数,注意这不是精确的,因为这个客户端可能立即就关闭了,但sessionDestroyed方法却会按一定
的策略很久以后才会发生.

HttpSessionAttributeListener:
和ServletContextAttributeListener一样,它监听一个session对象的Attribut被Add(一个特定
名称的Attribute每一次被设置),replace(已有名称的Attribute的值被重设)和remove时的事件.
对就的有三个方法.
public void attributeAdded(HttpSessionBindingEvent se)

public void attributeRemoved(HttpSessionBindingEvent se)

public void attributeReplaced(HttpSessionBindingEvent se)

上面的几个监听器的方法,都是在监听应用逻辑中servlet逻辑中发生了什么事,一般的来说.
我们只要完成逻辑功能,比如session.setAttribute("aaa","111");我只要把一个名为aaa的变量
放在session中以便以后我能获取它,我并不关心当session.setAttribute("aaa","111");发生时
我还要干什么.(当然有些时候要利用的),但对于下面这个监听器,你应该好好发解一下:

HttpSessionBindingListener:
上面的监听器都是作为一个独立的Listener在容器中控制事件的.而HttpSessionBindingListener
对在一对象中监听该对象的状态,实现了该接口的对象如果被作为value被add到一个session中或从
session中remove,它就会知道自己已经作为一个session对象或已经从session删除,这对于一些非
纯JAVA对象,生命周期长于session的对象,以及其它需要释放资源或改变状态的对象非常重要.
比如:
session.setAttribute("abcd","1111");
以后session.removeAttribute("abcd");因为abcd是一个字符中,你从session中remove后,它就会
自动被垃圾回收器回收,而如果是一个connection:(只是举例,你千万不要加connection往session
中加入)
session.setAttribute("abcd",conn);
以后session.removeAttribute("abcd");这时这个conn被从session中remove了,你已经无法获取它
的句柄,所以你根本没法关闭它.而在没有remove之前你根本不知道什么时候要被remove,你又无法
close(),那么这个connection对象就死了.另外还有一些对象可以在被加入一个session时要锁定
还要被remove时要解锁,应因你在程序中无法判断什么时候被remove(),add还好操作,我可以先加锁
再add,但remove就后你就找不到它的句柄了,根本没法解锁,所以这些操作只能在对象自身中实现.
也就是在对象被add时或remove时通知对象自己回调相应的方法:

MyConn extends Connection implements HttpSessionBindingListener{
public void valueBound(HttpSessionBindingEvent se){
this.initXXX();
}
public void valueUnbound(HttpSessionBindingEvent se){

this.close();
}
}

session.setAttribute("aaa",new MyConn());
这时如果调用session.removeAttribute("aaa"),则触发valueUnbound方法,就会自动关闭自己.
而其它的需要改变状态的对象了是一样.
posted @ 2006-09-01 16:55 阿成 阅读(213) | 评论 (0) | 编辑 收藏
JSP学习经验总结【转载】
一、JSP工作原理 

在一个JSP文件第一次被请求时，JSP引擎把该JSP文件转换成为一个servlet。而这个引擎本身也是一个servlet，在JSWDK或WEBLOGIC中，它就是JspServlet。 JSP引擎先把该JSP文件转换成一个Java源文件，在转换时如果发现jsp文件有任何语法错误，转换过程将中断，并向服务端和客户端输出出错信息；如果转换成功， JSP引擎用javac把该Java源文件编译成相应的class文件。然后创建一个该SERVLET的实例，该SERVLET的jspInit()方法被执行，jspInit()方法在servlet的生命周期中只被执行一次。然后jspService()方法被调用来处理客户端的请求。对每一个请求，JSP引擎创建一个新的线程来处理该请求。如果有多个客户端同时请求该JSP文件，则JSP引擎会创建多个线程。每个客户端请求对应一个线程。以多线程方式执行可大大降低对系统的资源需求,提高系统的并发量及响应时间.但应该注意多线程的编程限制，由于该servlet始终驻于内存，所以响应是非常快的。 如果.jsp文件被修改了，服务器将根据设置决定是否对该文件重新编译，如果需要重新编译，则将编译结果取代内存中的servlet，并继续上述处理过程。 虽然JSP效率很高，但在第一次调用时由于需要转换和编译而有一些轻微的延迟。 此外，如果在任何时候如果由于系统资源不足的原因，JSP引擎将以某种不确定的方式将servlet从内存中移去。当这种情况发生时jspDestroy()方法首先被调用, 然后servlet实例便被标记加入"垃圾收集"处理。 jspInit()及jspDestory()格式如下：可在jspInit()中进行一些初始化工作,如建立与数据库的连接，或建立网络连接，从配置文件中取一些参数等，在jspDestory()中释放相应的资源。  

<%! 
public void jspInit() 
{ 
       System.out.println("jspinit");  
} 
  
%> 
  
<%! 
public void jspDestory() 
{ 
       System.out.println("jspDestory");  
} 
%> 

二、服务端的输出缓冲区 

缺省情况下:服务端要输出到客户端的内容,不直接写到客户端,而是先写到一个输出缓冲区中.只有在下面三中情况下，才会把该缓冲区的内容输出到客户端上： 


该JSP网页已完成信息的输出  
输出缓冲区已满  
JSP中调用了out.flush()或response.flushbuffer()  
输出缓冲区的大小可以用:或response.setBufferSize()设置,如下：  
设置输出缓冲区的大小为1KB。或response.setBufferSize(1);  
设置输出缓冲区的大小为0，即不缓冲。或response.setBufferSize(0);  
用response.getBufferSize()或out.getBufferSize()可取的输出缓冲区的大小,单位为字节. 用response.isCommitted()可检查看服务端是否已将数据输出到客户端. 如果返回值是TRUE则已将数据输出到客户端,是FALSE则还没有.  

三、服务端输出重定向 

有以下3种方法可以做到输出重定向:  

RESPONSE.SETREDERECT("URL") 该方法通过修改HTTP协议的HEADER部分,对浏览器下达重定向指令的,使浏览器显示重定向网页的内容. response.sendRedirect("http://localhost:7001/index.html");  
下面的方法也能改变HTTP HEADER属性，它的原理和 1 是一样的.  
<%  
response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);  
String newLocn="/index.html";  
response.setHeader("Location",newLocn);  
% >  
采用<JSP:FORWORD> 该方法是利用服务器端先将数据输出到缓冲区的机制,在把缓冲区的内容发送到客户端之前,原来的不发送,改为发送该页面的内容,如果在<JSP:FORWORD>之前有很多输出,前面的输出已使缓冲区满,将自动输出到客户端,那么该语句将不起作用,这一点应该特别注意. 如下面的例子中(1)会输出index.html的内容，2 不会输出index.html的内容，而是输出out.println("@@@@@@@@@@@@@@@@@"); 中的内容,并且在服务端会抛出:java.lang.IllegalStateException: Response already committed 异常，但客户端没有任何错误输出。  
(1) 
<%@page buffer="1kb"%> 
  
<% 
long i=0; 
  
for(i=0;i<10;i++) 
{ 
       out.println("@@@@@@@@@@@@@@@@@"); 
} 
%> 
  
<jsp:forward page="./index.html" /> 
  
  
(2) 
<%@page buffer="1kb"%> 
  
<% 
long i=0; 
  
for(i=0;i<600;i++) 
{                  
       out.println("@@@@@@@@@@@@@@@@@"); 
} 
%> 
  

说明： 
1. 方法(1),(2)可以使用变量表示重定向的地址;方法(3)不能使用变量表示重定向的地址。 
String add="./index.html";  
<jsp:forward page= add />  
无法重定向到index.html中去  

String add=http://localhost:7001/index.html  
response.sendRedirect(add);  
可以重定向到http://localhost:7001/index.html中去。  

2. 采用方法(1),(2)request中的变量(通过request.setAttribute()保存到request中的值)不能在新的页面中采用,采用方法(3)能. 综上,我们应该采用(1),(2)重定向比较好.  


四、JSP中正确应用类:  

应该把类当成JAVA BEAN来用，不要在<% %> 中直接使用. 如下的代码(1)经过JSP引擎转化后会变为代码(2): 
从中可看出如果把一个类在JSP当成JAVA BEAN 使用,JSP会根据它的作用范围把它保存到相应的内部对象中. 
如作用范围为request,则把它保存到request对象中.并且只在第一次调用(对象的值为null)它时进行实例化. 而如果在<% %>中直接创建该类的一个对象,则每次调用JSP时,都要重新创建该对象,会影响性能.  

代码(1) 
<jsp:useBean id="test" scope="request" class="demo.com.testdemo"> 
</jsp:useBean> 
  
<% 
test.print("this is use java bean"); 
  
testdemo td= new testdemo(); 
td.print("this is use new"); 
%> 
  


代码(2) 
demo.com.testdemo test = (demo.com.testdemo)request.getAttribute("test");  
if (test == null)  
{  
       try  
       {  
                 test = (demo.com.testdemo) java.beans.Beans.instantiate(getClass().getClassLoader(),"demo.com.testdemo");  
       }  
       catch (Exception _beanException)  
       { 
               throw new weblogic.utils.NestedRuntimeException("cannot instantiate 'demo.com.testdemo'",_beanException);  
       }  
       request.setAttribute("test", test);  
       out.print("\r\n"); 
}  
out.print("\r\n\r\n\r\n"); 
test.print("this is use java bean");  
  
testdemo td= new testdemo(); 
td.print("this is use new"); 

  



五、JSP的调试  

JSP的调试比较麻烦,特别是当bean是在一个session中存在时，更加困难。得从好几个页面开始往里面走才行。通常是用out.println()或System.out.print()来打一大堆的信息来查问题。如果是用jbuilder做开发,它能直接调试JSP.不过更重要的是知道错误产生的原因及解决方法。下面对一些JSP编程常见错误进行分析。  

(1).java.lang.NullPointerException异常 
一般是对一个为NULL值的变量进行操作引起的.如下面的操作就会抛出 
java.lang.NullPointerException 
String a = null;  
a.substring(0,1);  
  
为避免这种异常最好在对变量操作之前检查看它是否为NULL值.如: 
<% String ss=Session.getAttribute("NAME")  
if isnull(ss)  
{  

}  
else  
{  

}  
%>  

(2).JSP是用JAVA写的，所以它是大小写敏感的，用过其他编程语言的人最容易犯这个错误。另外在浏览器的地址栏中输入的访问JSP的地址也是区分大小写的.如http://localhost:7001/demo/t.jsp与http://localhost:7001/Demo/t.jsp是不一样的 

(3).在jsp中判断字符串要使用compareTo方法，不要用==，因为在java中String变量不是一个简单的变量而是一个类实例，不同的方法会得到 不同的结果，如下所示：  

　　 

　　String str1="ABCD";  
　　String str2="ABCD"; (或 String str2="AB"+"CD";   
　　if (str1==str2)  
　　 out.print("yes");  
　　else  
　　 out.print("no");  
　　结果是"yes"。  
　  

　　String str1,str2,str3;  
　　str1="ABCD";  
　　str2="AB";  
　　str3=str2+"CD";  
　　if (str1==str3)  
　　 out.print("yes");  
　　else  
　　 out.print("no");  
　　结果是"no"。  


String str1=new String("ABCD");  
　　String str2=new String("ABCD");  
　　if (str1==str2)  
　　 out.print("yes");  
　　else  
　　 out.print("no");  
　　结果是"no"。  


String str1=new String("ABCD");  
　　String str2=new String("ABCD");  
　　if (str1.compareTo(str2)==0)  
　　 out.print("yes");  
　　else  
　　 out.print("no");  
　　结果是"yes"。  

(4)防止JSP或SERVLET中的输出被浏览器保存在缓冲区中: 
浏览器在默认情况下会把浏览过的网页保存在缓冲区中,在调试时,一般不希望这样.把下面的脚本加入程序中,就可防止JSP或SERVLET中的输出被浏览器保存在缓冲区中  
<%  
response.setHeader("Cache-Control","no-store"); //HTTP 1.1  
response.setHeader("Pragma","no-cache"); //HTTP 1.0  
response.setDateHeader ("Expires", 0); //prevents caching at the proxy server  
%>  
在IE中也可通过设置实现：把/工具/INTERNET选项/常规/设置/的检察所存页面的较新版本,设为每次访问该页时都检查. 


六、COOKIE 

HTTP COOKIE实质是服务端与在客户端之间传送的普通HTTP头,可保存也可不保存在客户的硬盘上.如果保存,每一个文件大小不超过4K的文本文件.多个COOKIE可保存到同一个文件中. 如果从编程角度来看,在JSP中COOKIE就是JAVA提供的一个类.常用的方法如下所表示，因为客户端可能不接受COOKIE，所以建议不用它，改用SESSION等其他方式。  


public class cookie  
{  
public String getDomain() //返回该COOKIE的有效域  
public int getMaxAge() //返回该COOKIE的有效期,单位为秒  
public String getName() //返回该COOKIE的名称  
public String getPath() //返回该COOKIE的有效路径  
public boolean getSecure() //返回该COOKIE的安全设置  
public String getValue() //返回该COOKIE的值  
public void setDomain(java.lang.String pattern) //设置该COOKIE的有效域  
public void setMaxAge(int expiry) //设置该COOKIE的有效期,单位为秒  
public void setPath(java.lang.String uri) //设置该COOKIE的有效路径  
public void setSecure(boolean flag) //设置该COOKIE的安全设置  
public void setValue(java.lang.String newValue) //设置该COOKIE的值  
}  
一个COOKIE包含以下五部分:  

NAME/VALUE对,设置该COOKIE的名字及它保存的值  
COOKIE通常和服务器相关,如果将域设为JAVA.SUN.COM,那么该COOKIE就和这个域相关,只对该网址起作用,当浏览该网址时,浏览器将把该COOKIE的内容发送给服务端,COOKIE是作为HTTP HEADER的一部分被发送的，如果没有设置域,那么COOKIE就只和创建该COOKIE的服务器相关.  
路径用于指定服务器上可以使用该COOKIE的文件所在的路径,它只对该网址下的该路径下的应用起作用."/"表示服务器上所有目录都可以使用该COOKIE.  
COOKIE都有一个有效期,有效期默认值为-1,这表示没有保存该COOKIE,当该浏览器退出时,该COOKIE立即失效.  
安全选项true/false,如果设置为true,那么在服务端与在客户端之间传送该COOKIE的内容时,采用HTTPS协议.  
如何检查一个客户端是否支持COOKIE的方法:  
用下面的方法写一个COOKIE到客户端,并确认成功  
try  
{  
Cookie c = new Cookie("mycookie","COOKIE TEST");  
response.addCookie(c);  
}  
catch(Exception e)  
{  
      System.out.println(e);  
}  


然后在一个新的JSP文件中:用下面的方法取客户端的COOKIE到cookies中, 如果cookies.length ==0,说明该客户端的浏览器不支持COOKIE  
try  
{  
Cookie[] cookies = request.getCookies();  
if(cookies.length ==0)  
{  
      System.out.println("not support cookie");  
}  
}  
catch(Exception e)  
{  
      System.out.println(e);  
}  



七、JSP和SERVLET的区别: 

SUN首先发展出SERVLET，其功能比较强劲，体系设计也很先进，只是，它输出HTML语句还是采用了老的CGI方式，是一句一句输出，所以，编写和修改HTML非常不方便。 后来SUN推出了类似于ASP的JSP，把JAVA代码嵌套到HTML语句中，这样，就大大简化和方便了网页的设计和修改。ASP，PHP，JSP都是嵌套型的SCRIPT语言。 一个分布式系统应分为三层：表示层,业务逻辑层,数据存取层,在J2EE体系结构中,SERVLET用来写业务逻辑层是很强大的，但是对于写表示层就很不方便。JSP则主要是为了方便写表示层而设计的。ENTITY BEAN实现数据存取层，SESSION BEAN实现业务逻辑层。如果是简单的应用系统,可采用JSP+BEANS的结构进行设计,JSP中应该仅仅存放与表示层有关的东西，也就是说，只放输出HTML网页的部份。而所有的数据计算，数据分析，数据库联结处理，统统是属于业务逻辑层，应该放在JAVA BEANS中。通过JSP调用JAVA BEANS，实现两层的整合。 实际上，微软的DNA技术，简单说，就是ASP+COM/DCOM技术。与JSP+BEANS完全类似，所有的表示层由ASP完成，所有的业务逻辑由COM/DCOM完成。 为什么要采用这些组件技术呢？因为单纯的ASP/JSP语言是非常低效率执行的，如果出现大量用户点击，纯SCRIPT语言很快就到达了他的功能上限，而组件技术就能大幅度提高功能上限，加快执行速度。另外一方面，纯SCRIPT语言将表示层和业务逻辑层混在一起，造成修改不方便，并且代码不能重复利用，采用组件技术就只改组件就可以了。 对于复杂的应用，应该采用ENTITY BEAN实现数据存取层，SESSION BEAN实现业务逻辑层，用JSP来调用SESSION BEAN，由SESSION BEAN调用ENTITY BEAN。即采用JSP+EJB来构建一个复杂的分布式系统。它比JSP+BEAN具有更高的吞吐量，可靠性，安全性。综上所述，对简单应用，可采用JSP+BAEN，对复杂的应用系统，应采用JSP+EJB，SERVLET变的无足轻重。用JSP完全可替代它。
posted @ 2006-09-01 16:53 阿成 阅读(293) | 评论 (0) | 编辑 收藏
request.getSession()
request.getSession() will return the current session and if one does not exist, a new session will be cretaed.

request.getSession(true) will return the current session if one exists, if one doesn't exits a new one will be created.

So there is actually no difference between the two methods.
 
HOWEVER, if you use request.getSession(false), it will return the current session if one exists and if one DOES NOT exist a new one will NOT be cretaed.
posted @ 2006-09-01 13:59 阿成 阅读(673) | 评论 (0) | 编辑 收藏
Hibernate配置文件在单元测试中的灵活运用
转载－http://blog.csdn.net/ufoer23/archive/2005/02/24/299619.aspx

2005 年 1 月

Hibernate 是一个流行的开源对象关系映射工具，单元测试和持续集成的重要性也得到了广泛的推广和认同，在采用了Hibernate的项目中如何保证测试的自动化和持续性呢？本文讨论了Hibernate加载其配置文件hibernate.properties和hibernate.cfg.xml的过程，以及怎么样将hibernate提供的配置文件的访问方法灵活运用到单元测试中。

1 介绍
Hibernate 是一个流行的开源对象关系映射工具，单元测试和持续集成的重要性也得到了广泛的推广和认同，在采用了Hibernate的项目中如何保证测试的自动化和持续性呢？本文讨论了Hibernate加载其配置文件hibernate.properties和hibernate.cfg.xml的过程，以及怎么样将hibernate提供的配置文件的访问方法灵活运用到单元测试中。注意：本文以hibernate2.1作为讨论的基础，不保证本文的观点适合于其他版本。

2 读者
Java开发人员，要求熟悉JUnit和掌握Hibernate的基础知识

3 内容

3.1.准备
对于hibernate的初学者来说，第一次使用hibernate的经验通常是：

1， 安装配置好Hibernate，我们后面将%HIBERNATE_HOME%作为对Hibernate安装目录的引用，

2， 开始创建好自己的第一个例子，例如hibernate手册里面的类Cat，

3， 配置好hbm映射文件（例如Cat.hbm.xml，本文不讨论这个文件内配置项的含义）和数据库（如hsqldb），

4， 在项目的classpath路径下添加一个hibernate.cfg.xml文件，如下(第一次使用hibernate最常见的配置内容)：



<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>
<session-factory>

<property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
<property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="connection.username">sa</property>
<property name="connection.password"></property>
<property name="dialect">net.sf.hibernate.dialect.HSQLDialect</property>

        <property name="hibernate.show_sql">false</property>

        <mapping resource="Cat.hbm.xml"/>

</session-factory>
</hibernate-configuration>

5， 然后还需要提供一个类来测试一下创建，更新，删除和查询Cat，对于熟悉JUnit的开发人员，可以创建一个单元测试类来进行测试，如下：



import junit.framework.TestCase;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;


public class CatTest extends TestCase {

    private Session session;
    private Transaction tx;

    protected void setUp() throws Exception {
        Configuration cfg = new Configuration().configure();////注意这一行，这是本文重点讨论研究的地方。
        session = cfg.buildSessionFactory().openSession();
        tx = session.beginTransaction();
    }

    protected void tearDown() throws Exception {
  tx.commit();
  session.close();
    }
    
    public void testCreate()  {
     //请在此方法内添加相关的代码，本文不讨论怎么样使用Hibernate API。
    }
    public void testUpdate()  {
     //请在此方法内添加相关的代码，本文不讨论怎么样使用Hibernate API。
    }
    public void testDelete()  {
     //请在此方法内添加相关的代码，本文不讨论怎么样使用Hibernate API。
    }
    public void testQuery()  {
     //请在此方法内添加相关的代码，本文不讨论怎么样使用Hibernate API。
    }

}

3.2 new Configuration()都做了什么？
对于第一次使用hibernate的新手来说，下面的这段代码可以说是最常见的使用Configuration方式。



Configuration cfg = new Configuration().configure();

Configuration是hibernate的入口，在新建一个Configuration的实例的时候，hibernate会在classpath里面查找hibernate.properties文件，如果该文件存在，则将该文件的内容加载到一个Properties的实例GLOBAL_PROPERTIES里面，如果不存在，将打印信息



hibernate.properties not found

然后是将所有系统环境变量（System.getProperties()）也添加到GLOBAL_PROPERTIES里面（注1）。如果hibernate.properties文件存在，系统还会验证一下这个文件配置的有效性，对于一些已经不支持的配置参数，系统将打印警告信息。

3.3. configure()在做什么？
new Configuration()讨论至此，下面讨论configure()方法。

configure()方法默认会在classpath下面寻找hibernate.cfg.xml文件，如果没有找到该文件，系统会打印如下信息并抛出HibernateException异常。



hibernate.cfg.xml not found

如果找到该文件，configure()方法会首先访问< session-factory >，并获取该元素的name属性，如果非空，将用这个配置的值来覆盖hibernate.properties的hibernate.session_factory_name的配置的值，从这里我们可以看出，hibernate.cfg.xml里面的配置信息可以覆盖hibernate.properties的配置信息。

接着configure()方法访问<session-factory>的子元素，首先将使用所有的<property>元素配置的信息（注2），如前面我们使用的配置文件



    <property name="connection.url">jdbc:hsqldb:hsql://localhost</property>
  <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
  <property name="connection.username">sa</property>
  <property name="connection.password"></property>
  <property name="dialect">net.sf.hibernate.dialect.HSQLDialect</property>

会覆盖hibernate.properties里面对应的配置，hibernate2.1发布包里面自带的hibernate.properties文件（位于%HIBERNATE_HOME%/etc下面）里面的值，如下：



hibernate.dialect net.sf.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username sa
hibernate.connection.password
hibernate.connection.url jdbc:hsqldb:hsql://localhost

然后configure()会顺序访问以下几个元素的内容



<mapping>
<jcs-class-cache>
<jcs-collection-cache>
<collection-cache>

其中<mapping>是必不可少的，必须通过配置<mapping>，configure()才能访问到我们定义的java对象和关系数据库表的映射文件（hbm.xml），例如：



<mapping resource="Cat.hbm.xml"/>

通过以上的分析，我们对hibernate配置文件hibernate.properties和hibernate.cfg.xml的默认的加载过程就比较清楚了。

3.4 Configuration的其他用法
Configuration的configure ()方法还支持带参数的访问方式，你可以指定hbm.xml文件的位置，而不是使用默认的classpath下面的hibernate.cfg.xml这种方式，例如：



Configuration cfg = new Configuration().configure("myexample.xml");

同时Configuration还提供了一系列方法用来定制hibernate的加载配置文件的过程，让你的应用更加灵活，常用的是以下几种：



addProperties(Element)
addProperties(Properties)
setProperties(Properties)
setProperty(String, String)

通过以上几个方法，除了使用默认的hibernate.properties文件，你还可以提供多个.properties配置文件，使用Hibernate的时候根据不同的情况使用不同的配置文件，例如：



Properties properties = Properties.load("my.properties");
Configuration config = new Configuration().setProperties(properties).configure();

除了指定.properties文件之外，还可以指定.hbm.xml文件，下面列出几个常用的方法：



addClass(Class)
addFile(File)
addFile(String)
addURL(URL)

前面我们已经讲了，configure()方法默认是通过访问hibernate.cfg.xml的<mapping>元素来加载我们提供的.hbm.xml文件，上面列出的方法可以直接指定hbm.xml文件，例如addClass()方法可以直接通过指定class来加载对应的映射文件，hibernate会将提供的class的全名（包括package）自动转化为文件路径，如net.sf.hibernate.examples.quickstart.Cat.class对应了net/sf/hibernate/examples/quickstart/Cat.hbm.xml，还可以用addFile方法直接指定映射文件。

例一：



Configuration config = new Configuration().addClass(Cat.class);

例二：



Configuration config = new Configuration().addURL(Configuration.class.getResource ("Cat.hbm.xml"));

例三：



Configuration config = new Configuration().addFile("Cat.hbm.xml");

3.5 总结
Configuration提供的这些方法的好处如下：

1． 一个应用中往往有很多.hbm.xml映射文件，开发的过程中如果只是为了测试某个或几个Java PO(Persistence Object)，我们没有必要把所有的.hbm.xml都加载到内存，这样可以通过addClass或者addFile直接，显得非常灵活。

2． 学习Hibernate的过程中，往往需要通过练习来体会Hibernate提供的各种特征，而很多特征是需要修改配置文件的，如果要观察相同的代码在不同的特征下的表现，就需要手工改配置文件，这样太麻烦了，而且容易出错，我们可以提供多个配置文件，每个配置文件针对需要的特征而配置，这样我们在调用程序的时候，把不同的配置文件作为参数传递进去，而程序代码里面使用setProperties和addFile指定传入的配置文件参数就可以了。

3． 在单元测试中，特别是在集成测试里面，整个过程是自动化的，我们不能手工干预测试过程，往往需要准备多个配置文件针对不同的测试案例，这个时候setProperties和addFile方法就显得特别有用了，在不同的测试案例中用这些方法来指定相应的配置文件，这样就可以做到自动化测试，保证了持续性。

3.6 应用举例
在刚开始学习hibernate的时候，对于hibernate的hbm映射文件里的各种配置参数没有一个感性的认识，例如inverse="true",lazy="true"这样的配置参数，不通过实践是无法体会到其作用的，传统的方法就是每需要测试一种参数的效果就更改相应的配置文件，然后运行测试来观察结果，如果能够灵活的运用Configuration提供的定制配置的方法，我们可以提供多个配置文件，每个配置文件里面有不同的配置参数，配合相应的测试案例就方便多了。

例如针对ono-to-many和many-to-one的双向关联的映射关系，我们想测试在one-to-many一方使用inverse="false"和inverse="true"的不同效果，假设已经正确的配置好了hibernate.properties，那么还需要提供两个不同的hbm.xml文件，假设分别名为bidirect.inverse.false.hbm.xml和bidirect.inverse.true.hbm.xml。

然后需要写两个不同的测试案例，分别针对两个不同的配置文件进行测试就可以了，这样的好处是，不用针对不同的测试案例修改配置文件，特别是在集成测试的时候，一切都是自动化的，如果每测试一个案例就需要手工去更改配置文件，这肯定是一个失败的测试。

代码模板如下：



FalseInverseTest.java文件
import junit.framework.TestCase;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;

/**
 * test false inverse
 */
public class FalseInverseTest extends TestCase {

    private Session session;
    private Transaction tx;

    protected void setUp() throws Exception {
        Configuration cfg = new Configuration().addFile("bidirect.inverse.false.hbm.xml");
        session = cfg.buildSessionFactory().openSession();
        tx = session.beginTransaction();
    }

    protected void tearDown() throws Exception {
tx.commit();
      session.close();
    }
    
    public void testLogic()  {
     //在此编写测试代码
    }

}

TrueInverseTest.java文件



import junit.framework.TestCase;
import net.sf.hibernate.HibernateException;
import net.sf.hibernate.Session;
import net.sf.hibernate.Transaction;
import net.sf.hibernate.cfg.Configuration;

/**
 * test true inverse
 */
public class TrueInverseTest extends TestCase {

    private Session session;
    private Transaction tx;

    protected void setUp() throws Exception {
        Configuration cfg = new Configuration().addFile("bidirect.inverse.true.hbm.xml");
        session = cfg.buildSessionFactory().openSession();
        tx = session.beginTransaction();
    }

    protected void tearDown() throws Exception {
      tx.commit();
      session.close();
    }
    
    public void testLogic()  {
     //在此编写测试代码
    }

}

结束语
通过对Hibernate默认的配置文件的加载顺序和Hibernate提供的加载配置文件的方法的讨论，我们对在使用到Hibernate的项目的单元测试中使用多个Hibernate配置文件有了比较清楚的认识。

持续集成中的测试的特征是自动化和持续性，不能手工干预其过程，在使用到Hibernate的项目如果要实现持续集成，就要为不同的测试案例提供不同的配置文件，而不是针对不同的测试案例进行手工调整，因此，在使用到Hibernate的项目中灵活的运用多配置文件，可以提高测试的效率，保证自动化和持续性。

注1：有关的代码请参考Environment类的static{}。

注2：如果在hibernate.cfg.xml的<property/>配置的name没有以hibernate开头，那么configure()内部会自动在前面添加hibernate，例如connection.url，hibernate会自动将其转化为hibernate.connection.url。

参考资料

posted @ 2006-08-31 09:47 阿成 阅读(217) | 评论 (0) | 编辑 收藏
模式
Interpreter（解释器）模式

Memento（备望录）模式
 
用composite模式写的一个二叉树的例子
 
Composite（组合）模式
 
Proxy（代理）模式
 
模式间区别（不断更新）
 
Prototype（原型）模式
 
Builder（生成器）模式
 
Template Method（模板方法）模式
 
Observer（观察者）模式
 
Decorator（装饰）模式
 
Strategy（策略）模式
简单工厂，Factory Method（工厂方法）和Abstract Factory（抽象工厂）模式
 
Singleton（单态）模式 和 Double-Checked Locking（双重检查锁定）模式
 
设计模式的原则和策略
 
Adapter（适配器）模式
Facade（外观）模式
 
Bridge（桥接）模式
 
posted @ 2006-08-29 09:56 阿成 阅读(248) | 评论 (0) | 编辑 收藏
简化Spring
简化Spring(1)--配置文件

简化Spring(2)--Model层

简化Spring(3)--Controller层

简化Spring(4)--View层
posted @ 2006-08-29 08:58 阿成 阅读(220) | 评论 (0) | 编辑 收藏
Oracle 10G -- Pl/sql 基础
     摘要: 1.   简介 1.1     结构 DECLARE -- 定义 BEG...  阅读全文
posted @ 2006-08-29 08:52 阿成 阅读(349) | 评论 (0) | 编辑 收藏
用过的类包
JDK
java.lang.*;
java.io.*;
java.util.*;
java.sql.*;
posted @ 2006-08-25 14:41 阿成 阅读(210) | 评论 (0) | 编辑 收藏
同学要结婚了
最近知道一个大学同学10月中旬结婚，

一个初中同学10月底结婚，好快呀，咱哥们的个人问题还没普呢！
posted @ 2006-08-25 10:35 阿成 阅读(208) | 评论 (0) | 编辑 收藏
名次解释－省得忘
1、I18N －Internationalization的简称，国际化的意思，因为该单词的首字母I与尾字母N中间隔着18个字母，由此得名。够忽悠的。

2、PM
      公司里的PM：Project Management 项目管理 
      论坛里的PM：Private Message 站内短消息 
      化学里的PM：Polymethyl Methacrylate 聚甲基丙烯酸甲酯

    时间里的PM：prior to midnight 下午 
     拼音里的PM：拍马、拍卖
posted @ 2006-08-23 20:26 阿成 阅读(215) | 评论 (0) | 编辑 收藏
Days On My Past：英文版《童年》
http://www.mqxx.com/wgl/music/music2/13.mp3

罗大佑那首广为传唱的《童年》的英文版：回到那懵懂童年，会和邻居家的孩子在小小的游戏里一争高下；回到那青涩过往，烛光晚会、海边沙滩就这样送出了自己的初吻；回到那刚出茅庐的岁月，初尝生活的艰辛，爸爸告诫说慢慢来……直到有了自己的小家、有了孩子，“多么想念我的家乡，多么想念那过去的日子”，可这一切已经过去了……相同的旋律，不同的语言，别有一番风味，很亲切的。

Days On My Past

I recall when I was young. Oh I will play and always having fun
With the neighbours next to me and we'll play until the setting sun
Try to be the best among the others in a game call the "spider battle"
It doesn't matter who is the best now. Those were the days of my past

A few years later when I got to school and was late for lesson all the time
Always day dreaming in the class, till I don't even know the lesson's done
Then my teacher always tell me never ever be lazy again
What can I do now? What can I say now? Those were the days of my past

As the days go on and on I grew up and had my first love
Candel light and sandy beach finally give away my first kiss
Mother said I was too young to fall in love and then I will one day regret
So love was over, but I do miss her. Those were the days of my past

Just when I left my high school and got my first job as salesmen
Working hard all day and night. No one there to lend a helping hand
Dady told me not to worry and said that l should go on step by step
What can I say now? What can I do now? Those were the days of my past

Then once day I settled down with the only one I really love
Got a small family with two kids that is what I'm always hoping for
But I still remember having fun with all my friends when I was young
I miss my home town. I miss my old friends, those the days of my past
Oh I miss my home town I miss my old friends. When will I see them again?

重点词汇

setting  n.  （太阳）落山

spider  n. 蜘蛛，设圈套者

give away  v. 送掉，分发

regret  v. 感到遗憾，后悔，惋惜，哀悼

step by step  adv. 逐步地

settle down  v. 定居，安定下来


歌曲名：童年
词/曲：罗大佑 
编曲：山崎稔 

池塘边的榕树上 知了在声声叫着夏天 

操场边的秋千上 只有蝴蝶停在上面

黑板上老师的粉笔 还在拼命唧唧喳喳写个不停 

等待着下课 等待着放学 等待游戏的童年

福利社里面什么都有 就是口袋里没有半毛钱 

诸葛四郎和魔鬼党 到底谁抢到那支宝剑

隔壁班的那个女孩 怎么还没经过我的窗前 

嘴里的零食 手里的漫画 心里初恋的童年

总是要等到睡觉前 才知道功课只做了一点点 

总是要等到考试以后 才知道该念的书都没有念

一寸光阴一寸金 老师说过寸金难买寸光阴 

一天又一天 一年又一年 迷迷糊糊的童年

没有人知道为什么 太阳总下到山的那一边 

没有人能够告诉我 山里面有没有住着神仙 

多少的日子里 总是一个人面对着天空发呆 

就这么好奇 就这么幻想 这么孤单的童年

阳光下蜻蜓飞过来 一片片绿油油的稻田 

水彩蜡笔和万花筒 画不出天边那一道彩虹 

什么时候才能像高年级的同学有张成熟与长大的脸 

盼望着假期 盼望着明天 盼望长大的童年

一天又一天 一年又一年 盼望长大的童年
 
posted @ 2006-08-23 20:12 阿成 阅读(378) | 评论 (0) | 编辑 收藏
Proud Of You：挥着翅膀的女孩
http://210.82.53.59/down/music/proudofyou.mp3

Proud Of You
Fiona Fung

Love in your eyes, sitting silent by my side
Going on, holding hand, walking through the nights
Hold me up, hold me tight, lift me up to touch the sky
Teaching me to love with heart, helping me open my mind

I can fly. I'm proud that I can fly
To give the best of mine till the end of the time
Believe me I can fly. I'm proud that I can fly
To give the best of mine. The heaven in the sky

Stars in the sky wishing once upon a time
Give me love, make me smile till the end of life
Hold me up. Hold me tight. Lift me up to touch the sky
Teaching me to love with heart, helping me open my mind

I can fly. I'm proud that I can fly
To give the best of mine till the end of the time
Believe me I can fly. I'm proud that I can fly
To give the best of mine. The heaven in the sky

Can't you believe that you light up my way?
No matter how that ease my path I'll never lose my faith

See me fly I'm proud to fly up high
Show you the best of mine till the end of the time
Believe me I can fly I'm singing in the sky
Show you the best of mine The heaven in the sky

Nothing can stop me spread my wings so wide

参考译文（来自互联网）

你眼中充满爱意，静静的坐在我身旁。沿途挽着你的手，慢步整个晚上
抱起我，抱紧我，让我能触摸到天空。懂得了用心去爱，助我把心窗打开

我会飞了，飞让我骄傲。给你我的全部，直至时光停顿
我真的会飞，飞令我骄傲。给你我的全部，天上的天国

天上繁星，希望有一天。爱的降临让我欢笑，直至我的一生

我会飞了，飞让我骄傲。给你我的全部，直至时光停顿
我真的会飞，飞令我骄傲。给你我的全部，天上的天国

你可相信、你已照亮了我的前路。我的路途如何已不重要，我决不失去信心

看我飞，高飞让我骄傲。给你展现最佳的我，直至时光停顿
我真的会飞，在天上高歌。给你展现最佳的我，天上的天国

没什么能停止我展翅高飞。

posted @ 2006-08-22 21:16 阿成 阅读(391) | 评论 (0) | 编辑 收藏
Struts加载spring的问题－zt

前几天不是一个同事使用OpenSessionInView pattern时,遇到Hibernate 3的mappinglazy="true"的问题,也不会想到它
struts启动spring的WebApplicationContext
spring有三种启动方式,使用ContextLoaderServlet,ContextLoaderListener和ContextLoaderPlugIn.
看一下ContextLoaderListener的源码,这是一个ServletContextListener
/**
  * Initialize the root web application context.
  */
 public void contextInitialized(ServletContextEvent event) {
  this.contextLoader = createContextLoader();
  this.contextLoader.initWebApplicationContext(event.getServletContext());
 }
 
  /**
  * Create the ContextLoader to use. Can be overridden in subclasses.
  * @return the new ContextLoader
  */
 protected ContextLoader createContextLoader() {
  return new ContextLoader();
 }
 contextLoader的源码
 public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
   throws BeansException {

  long startTime = System.currentTimeMillis();
  if (logger.isInfoEnabled()) {
   logger.info("Root WebApplicationContext: initialization started");
  }
  servletContext.log("Loading Spring root WebApplicationContext");

  try {
   // Determine parent for root web application context, if any.
   ApplicationContext parent = loadParentContext(servletContext);

   WebApplicationContext wac = createWebApplicationContext(servletContext, parent);
   servletContext.setAttribute(
     WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);

   if (logger.isInfoEnabled()) {
    logger.info("Using context class [" + wac.getClass().getName() +
      "] for root WebApplicationContext");
   }
   if (logger.isDebugEnabled()) {
    logger.debug("Published root WebApplicationContext [" + wac +
      "] as ServletContext attribute with name [" +
      WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
   }

   if (logger.isInfoEnabled()) {
    long elapsedTime = System.currentTimeMillis() - startTime;
    logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
   }

   return wac;
  }
  catch (RuntimeException ex) {
   logger.error("Context initialization failed", ex);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
   throw ex;
  }
  catch (Error err) {
   logger.error("Context initialization failed", err);
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
   throw err;
  }
 }
 注意WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,这里面放了WebApplicationContext,需要使用时从ServletContext取出
 可以使用WebApplicationContextUtils得到WebApplicationContext
 public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
  Object attr = sc.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
  if (attr == null) {
   return null;
  }
  if (attr instanceof RuntimeException) {
   throw (RuntimeException) attr;
  }
  if (attr instanceof Error) {
   throw (Error) attr;
  }
  if (!(attr instanceof WebApplicationContext)) {
   throw new IllegalStateException("Root context attribute is not of type WebApplicationContext: " + attr);
  }
  return (WebApplicationContext) attr;
 }
 关键的问题在于struts如何启动的spring的,ContextLoaderPlugIn的源码
 
 // Publish the context as a servlet context attribute.
  String attrName = getServletContextAttributeName();
  getServletContext().setAttribute(attrName, wac);
 
 public String getServletContextAttributeName() {
  return SERVLET_CONTEXT_PREFIX + getModulePrefix();
 }
 不同加载的Key竟然不同,原因就是WebApplicationContext放在那里的问题,可spring调用的时候会根据WebApplicationContext里面定义的那个名字去找的,问题出在这里


 在struts-config.xml中配置
    <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
      <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />
    </plug-in>

    <controller>
        <set-property property="processorClass" value="org.springframework.web.struts.DelegatingRequestProcessor" />
    </controller>
 原理是这样的,Struts虽然只能有一个ActionServlet实例,但是对于不同的子应用分别能有自己的RequestProcessor实例每个RequestProcessor实例分别对应不同的struts配置文件。
   子应用的ProcessorClass类必须重写一般就是继承RequestProcessor类，然后再其配置文件的controller元素中的<processorClass>属性中作出修改。那么当
  getRequestProcessor(getModuleConfig(request)).process(request,response);就能根据request选择相应的moduleconfig,再根据其<processorClass>属性选择相应的RequestProcessor子类来处理相应的请求了。

posted @ 2006-08-22 16:14 阿成 阅读(330) | 评论 (0) | 编辑 收藏
Tomcat的class加载的优先顺序一览
Tomcat的class加载的优先顺序一览

1.最先是$JAVA_HOME/jre/lib/ext/下的jar文件。

2.环境变量CLASSPATH中的jar和class文件。

3.$CATALINA_HOME/common/classes下的class文件。

4.$CATALINA_HOME/commons/endorsed下的jar文件。

5.$CATALINA_HOME/commons/i18n下的jar文件。

6.$CATALINA_HOME/common/lib 下的jar文件。
（JDBC驱动之类的jar文件可以放在这里，这样就可以避免在server.xml配置好数据源却出现找不到JDBC D
posted @ 2006-08-22 16:11 阿成 阅读(220) | 评论 (0) | 编辑 收藏
数据库模型大全
http://www.databaseanswers.org/data_models/index.htm
posted @ 2006-08-22 09:30 阿成 阅读(288) | 评论 (0) | 编辑 收藏
关于Hibernate缓存的使用－－（ZT－http://blog.csdn.net/woshichenxu/archive/2006/01/22/586361.aspx）
     摘要: 1.      关于 hibernate 缓存的问题：...  阅读全文
posted @ 2006-08-22 09:23 阿成 阅读(387) | 评论 (0) | 编辑 收藏
让你的struts能处理日期类型
struts使用日期包括将string自动转化为日期fill到form中，以及将form中的日期按照指定格式显示在html的textfield中。首先讲第一种情况的解决方法：

创建如下类：

import java.util.*;
import org.apache.commons.beanutils.*;
import java.text.SimpleDateFormat;

public class DateConvert implements Converter
{
  static SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd");
  public DateConvert()
  {

  }
  public Object convert(Class type, Object value)
  {
    
    if(value==null)return null;
    if(((String)value).trim().length()==0) return null;

    if(value instanceof String)
    {
      try
      {
        return df.parse((String)value);
      }
      catch (Exception ex)
      {
        throw new ConversionException("输入的日期类型不合乎yyyy/MM/dd"
          + value.getClass());
      }

    }
    else
    {
      throw new ConversionException("输入的不是字符类型"+value.getClass());
    }

  }
}

然后在你的系统某出使用如下（如web的init方法）
ConvertUtils.register(new DateConvert(),java.util.Date.class);
参数用于表示DateConvert类负责处理java.util.Date类型的转化

第二种情况是如何显示form中日期类型到html:text中，我用的办法是修改struts的代码，重新生成一个新的struts.jar
org.apache.struts.taglib.html.BaseFieldTag的doStartTag的方法
找到 if (value != null) {results.append(ResponseUtils.filter(value))代码行下面的内容，需要修改此处代码，以便输出日期类型
如下：
if (value != null) {
            results.append(ResponseUtils.filter(value));
        } else if (redisplay || !"password".equals(type)) {
            Object value = RequestUtils.lookup(pageContext, name, property, null);
            //System.out.println("lijz "+value);
            if(value instanceof java.util.Date)
            {
               //System.out.println("date="+value);
               if (value == null)
                   value = "";
        else
        {
          java.util.Date d= (java.util.Date)value;
          try
           {

            results.append(ResponseUtils.filter(df.format(d)));
          }
          catch(Exception ex)
          {
            System.out.println("form error:"+ex.getMessage());
          }
          }
            }
           else
           {
               if (value == null)
                value = "";
                results.append(ResponseUtils.filter(value.toString()));
           }
           
       }
        results.append("\"");
        results.append(prepareEventHandlers());
        results.append(prepareStyles());
        results.append(getElementClose());

        // Print this field to our output writer
        ResponseUtils.write(pageContext, results.toString());

        // Continue processing this page
        return (EVAL_BODY_TAG);      
 
 重新编译struts成struts.jar.放到你需要的项目中 

作者Blog：http://blog.csdn.net/chensheng913/
posted @ 2006-08-21 16:02 阿成 阅读(230) | 评论 (0) | 编辑 收藏
Tomcat Server启动分析

1 - Tomcat Server的组成部分


1.1 - Server


A Server element represents the entire Catalina servlet container. (Singleton)


1.2 - Service


A Service element represents the combination of one or more Connector components that share a single Engine
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求


1.3 - Connector


一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求


1.4 - Engine


The Engine element represents the entire request processing machinery associated with a particular Service
It receives and processes all requests from one or more Connectors
and returns the completed response to the Connector for ultimate transmission back to the client
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理


1.5 - Host



代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配


1.6 - Context


一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类
如果找到，则执行该类，获得请求的回应，并返回


2 - Tomcat Server的结构图



3 - 配置文件$CATALINA_HOME/conf/server.xml的说明


该文件描述了如何启动Tomcat Server




4 - Context的部署配置文件web.xml的说明


一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类
web.xml文件有两部分：servlet类定义和servlet映射定义
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应


分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入




5 - Tomcat Server处理一个http请求的过程


假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp


1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser


				
						
<!----------------------------------------------------------------------------------------------->

				

				
<web-app>


  <!-- 概述：
       该文件是所有的WEB APP共用的部署配置文件，
       每当一个WEB APP被DEPLOY，该文件都将先被处理，然后才是WEB APP自己的/WEB-INF/web.xml
       -->



  <!--  +-------------------------+  -->
  <!--  |    servlet类定义部分    |  -->
  <!--  +-------------------------+  -->



  <!-- DefaultServlet
       当用户的HTTP请求无法匹配任何一个servlet的时候，该servlet被执行
       URL PATTERN MAPPING : /
       -->

    <servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>
          org.apache.catalina.servlets.DefaultServlet
        </servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>


  <!-- InvokerServlet
       处理一个WEB APP中的匿名servlet
       当一个servlet被编写并编译放入/WEB-INF/classes/中，却没有在/WEB-INF/web.xml中定义的时候
       该servlet被调用，把匿名servlet映射成/servlet/ClassName的形式
       URL PATTERN MAPPING : /servlet/*
       -->

    <servlet>
        <servlet-name>invoker</servlet-name>
        <servlet-class>
          org.apache.catalina.servlets.InvokerServlet
        </servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>


  <!-- JspServlet
       当请求的是一个JSP页面的时候（*.jsp）该servlet被调用
       它是一个JSP编译器，将请求的JSP页面编译成为servlet再执行
       URL PATTERN MAPPING : *.jsp
       -->

    <servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>logVerbosityLevel</param-name>
            <param-value>WARNING</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>



  <!--  +---------------------------+  -->
  <!--  |    servlet映射定义部分    |  -->
  <!--  +---------------------------+  -->


    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>invoker</servlet-name>
        <url-pattern>/servlet/*</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
    </servlet-mapping>


  <!--  +------------------------+  -->
  <!--  |    其它部分，略去先    |  -->
  <!--  +------------------------+  -->

    ... ... ... ...

</web-app>


<!----------------------------------------------------------------------------------------------->

				
						
<!----------------------------------------------------------------------------------------------->

				

				

				
						
<!-- 启动Server
     在端口8005处等待关闭命令
     如果接受到"SHUTDOWN"字符串则关闭服务器
     -->

				
<Server port="8005" shutdown="SHUTDOWN" debug="0">


  <!-- Listener ???
       目前没有看到这里
       -->

  <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" debug="0"/>
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" debug="0"/>


  <!-- Global JNDI resources ???
       目前没有看到这里，先略去
       -->

  <GlobalNamingResources>
    ... ... ... ...
  </GlobalNamingResources>


  <!-- Tomcat的Standalone Service
       Service是一组Connector的集合
       它们共用一个Engine来处理所有Connector收到的请求
       -->

  <Service name="Tomcat-Standalone">


    <!-- Coyote HTTP/1.1 Connector
         className : 该Connector的实现类是org.apache.coyote.tomcat4.CoyoteConnector
         port : 在端口号8080处侦听来自客户browser的HTTP1.1请求
         minProcessors : 该Connector先创建5个线程等待客户请求，每个请求由一个线程负责
         maxProcessors : 当现有的线程不够服务客户请求时，若线程总数不足75个，则创建新线程来处理请求
         acceptCount : 当现有线程已经达到最大数75时，为客户请求排队
                       当队列中请求数超过100时，后来的请求返回Connection refused错误
         redirectport : 当客户请求是https时，把该请求转发到端口8443去
         其它属性略
         -->

    <Connector className="org.apache.coyote.tomcat4.CoyoteConnector" 
               port="8080" 
               minProcessors="5" maxProcessors="75" acceptCount="100" 
               enableLookups="true" 
               redirectPort="8443" 
               debug="0" 
               connectionTimeout="20000" 
               useURIValidationHack="false" 
               disableUploadTimeout="true" />


    <!-- Engine用来处理Connector收到的Http请求
         它将匹配请求和自己的虚拟主机，并把请求转交给对应的Host来处理
         默认虚拟主机是localhost
         -->

    <Engine name="Standalone" defaultHost="localhost" debug="0">


      <!-- 日志类，目前没有看到，略去先 -->

      <Logger className="org.apache.catalina.logger.FileLogger" .../>

      <!-- Realm，目前没有看到，略去先 -->

      <Realm className="org.apache.catalina.realm.UserDatabaseRealm" .../>


      <!-- 虚拟主机localhost
           appBase : 该虚拟主机的根目录是webapps/
           它将匹配请求和自己的Context的路径，并把请求转交给对应的Context来处理
           -->

      <Host name="localhost" debug="0" appBase="webapps" unpackWARs="true" autoDeploy="true">


        <!-- 日志类，目前没有看到，略去先 -->

        <Logger className="org.apache.catalina.logger.FileLogger" .../>


        <!-- Context，对应于一个Web App
             path : 该Context的路径名是""，故该Context是该Host的默认Context
             docBase : 该Context的根目录是webapps/mycontext/
             -->

        <Context path="" docBase="mycontext" debug="0"/>


        <!-- 另外一个Context，路径名是/wsota -->

        <Context path="/wsota" docBase="wsotaProject" debug="0"/>


      </Host>

    </Engine>

  </Service>

</Server>


<!----------------------------------------------------------------------------------------------->
posted @ 2006-08-21 11:41 阿成 阅读(190) | 评论 (0) | 编辑 收藏
正则表达式不断积累中
1、将com.regex.test转换成com/regex/test
用replaceAll转换
replaceAll中的第一个参数是一个正则表达示，不是普通的字符串组合

replaceAll(".", "/") <===>Pattern.compile(".").matcher(str).replaceAll("/")

"."需加转义符，要写成"\\.",如replaceAll("\\.", "/") 即可。
posted @ 2006-08-21 10:02 阿成 阅读(215) | 评论 (0) | 编辑 收藏
技术类人员的职业发展方向--ZT
几乎每个企业都需要技术人员的支持，生产制造型企业需要现场生产控制和工艺流程方面的技术人才；IT等高科技行业需要大量软件研发和设备维护的硬件工程师；房地产、建筑工程领域需要建筑设计师、土木工程师和施工技术人员。此外，不论是国企、民营企业还是外资公司，都需要大量的基础技术工人。甚至很多在豪华写字楼office内工作的白领，从事的工作都是和技术相关的。

　　不过，一个严峻的现实是，大量的技术类人员对自己的职业定位和职业生涯规划显得非常迷茫和困惑。中国有句古话：劳心者治人，劳力者治于人。与管理类岗位相比，技术人员往往被人看低一等，他们虽然从事着非常重要、繁琐的技术性工作，但更多的是扮演着幕后英雄的角色。在社会地位、经济收入方面与分光无限的各级管理层普遍存在差距，这一现实造就了技术人员的巨大心理落差。第二个造成职业规划困惑的原因是部分技术性工作的局限性。拿IT行业来说，由于技术和知识更新的速度太快，软件开放人员普遍被认为是吃“青春饭”的职位，谁学习的更快、谁的精力更旺盛、谁更能熬夜，谁就更有竞争力，因为这时经验已经不再重要。如果超过35岁还从事软件开发的话，将很难在本职岗位取得突破。

　　那么，对于技术类人员来说，难道他们的职业发展前景真的如此黯淡？事实当然不会如此悲观，做技术工作同样有着非常广阔的空间，当然，关键一点你要令自己的视野更开阔些，从长远的角度来看待这个问题。根据我的经验，技术人员的职业方向可以有以下几个选择：

　　方向一、成为项目经理

　　对于很多从事技术方面工作的人员来说，发展成为项目经理是一个相当好的工作。项目管理工作既需要扎实的技术背景支持，又涉及多方面的管理工作，最适合那些技术出身但又不甘于只做技术工作的人员。成为项目经理，一方面可以充分发挥技术人员的专业优势，同时又可在团队管理、协调各方资源、内外部沟通等工作中体验和发挥作为管理者的角色和作用，从而让自身价值更为充分的实现和得到认可。优秀的项目管理人才，也是今后很长时期内的一个热门职业方向。

　　方向二、成为行业资深专家

　　如果的确非常喜爱技术工作，而不擅长和喜欢与人沟通，则可以完全专注于自身的领域，以发展成为行业资深专家为方向和目标，当然，这一发展过程可能会比较漫长，任何一个领域的顶尖技术人才都需要长期的行业经验的累积和个人孜孜不倦的投入。不过这类人才的一个优势是越老越吃香，当别人随着年龄的逐步增长而开始担心饭碗问题时，你则渐入佳境，开始进入职业发展的黄金时期。

　　方向三、成为研发经理或技术总监

　　事实上，在某些行业和企业，技术研发人员的地位是非常高的。譬如在微软、诺基亚、华为等IT产业，技术的支持和研发的速度，成为企业利润增长的最主要来源，在这些行业，技术研发部门就是企业的主战场。在不少国企和政府部门，也非常重视科技和技术工作，例如，我所知道的广州市市政园林局，就设有总工程师、副总工程师等技术职位，其中总工程师的职务级别相当于副局级，在这种氛围影响下，技术岗位人才和行政领导同样受人尊敬。所以，在一个尊重和重视技术工作的行业和企业中，发展成为研发经理、技术总监或总工程师都是一个很好的选择。

　　方向四、做技术型销售和服务

　　技术工作的领域其实非常广泛，如果感觉纯技术工作发展潜力不大，可以考虑转向做销售或技术支持方面。华为、中兴等通信技术公司的销售人员，很少是不具有专业技术背景的；甲骨文等软件巨头的市场推广，第一步常常是从销售工程师拜访客户开始的。这类高价值、高科技的产品销售推广，非常需要具有丰富技术经验的销售人员。

　　技术人员转向售后服务，也是非常有前途的。我认识的一个朋友，大学是施工机械专业，毕业后一直在市政工程行业做非开挖顶管施工，在几年的工作中积累了丰富的地下顶进设备的应用和维修经验，一个合适的机会跳槽到著名的顶管设备生产商－德国海瑞克公司，成为其售后服务工程师，工作上得心应手，收入也有了数倍的增长。

　　方向五、转向管理岗位

　　总有一些人，虽然是理工科出身、从事着技术岗位工作，但他们似乎天生就是具有管理天赋的人。这些人会在工作中逐步展现出管理潜质和优秀的领导能力，他们往往更喜欢跟人打交道，更喜欢与外界沟通。在这种条件下，以技术经验为基础和依托，适当补充学习些管理方面的知识，例如可以在职攻读MBA，假以时日，完全可以成长为出色的职业经理人。

　　方向六、高级技术操作人员

　　刚才所谈的职业发展方向，适用群体多为高校理工专业出身的人士，但对于数量众多的中等专科学校、技校毕业的一线技术工人来说，成为行业技术专家或研发总监的机会显然非常微小。这一群体的职业人士，最佳的技术发展路线是立足本职岗位，成为高级操作型技术人员。

　　广州市2006年出台的各类岗位工资指导价格中，高级技师就业的工资比博士还要高出500元。出现这一现象的原因很简单，从全国层面来说，产业工人数量虽然巨大，但高级技工的比例却非常小，“高级技工”的缺乏已经成为制约许多企业发展的“瓶颈”。但随着政策环境、企业认识角度和培育机制方面的不断改善，这一现象将逐步得到改变，所以成为中高级技师将是一个非常有前途的职业发展方向。

　　最后，我再次拿IT行业为例来具体谈谈技术人员的职业轨迹。

　　IT(Information Technology)行业的分类相当复杂，我这里仅仅分析最典型的三个部分:

　　第一部分是软件开发，通俗来说就是编程。实际上我认为真正的软件开发人员和制鞋工厂中的工人处在一个地位，是企业产品的最终生产者(当然这里没有贬义)。

　　第二个部分是MIS: Management Information Service/System（管理信息系统），主要负责基础IT建设、网络、通讯、软硬件支持、简单开发等职能，为公司其他部门提供IT基础服务。

　　第三部分是ERP: Enterprise Resource Planning（企业资源计划系统），主要涉及企业管理类软件实施、维护、管理。通过是引入信息化手段在企业现实的实现企业的资源管理，协调企业各方面的生产运作，它对业务的规范和企业的管理机制有很大的依赖。

　　让我们来分别看看这三部分人员的职业发展空间：

　　1. 开发人员

　　我的观点是，在中小企业做纯粹的软件开发很可能走上一条不归路，长期从事开发的人一般处世能力不足，升任管理人员的机会不大。而还有一个更重要的问题是中国目前开发行业的环境很不好，正如我之前谈到的基本是在吃青春饭，30往后就很难做下去了。而在美国40岁的开发人员是正吃香的年龄。虽然可能业务越来越精，但可能会离IT越来越远，向纯蓝领工人发展。

　　如果真的要做开发，应该找一个更好的平台，最好是进入跨国企业或国内龙头企业。如果数据方面的技术很强，可以考虑转向互联网搜索方向；如果在电子和通信设备方面有优势，可以从简单的程序开发转向通信产品的开发。

　　2. MIS人员

　　MIS内容广泛，可从事的职业很多:网管、技术支持等，而且通过努力可以得到提升成为小小的主管(当然要有自身的素质)，进而成为MIS Manager，但做到MIS Manager基本也就到头了，不过倒是可以考虑转到不同的行业或企业做MIS。

　　同样是做IT服务，在不同公司内IT部门的地位还是非常巨大的。就我所了解的，雅芳（中国）公司的IT部门就有100多人，在公司总部的各职能部门中的地位相当高；而南方航空公司的IT部门竟然达到800多人，这个规模已经远远超过一般的IT公司，其IT部门的总裁也是公司决策层的重要成员。所以，在这些公司内做IT技术支持工作，既避免了纯编程式的软件开发人员遇到的“人老珠黄”的被动局面，也不必担心IT产业泡沫破灭而产生的生存危机。

　　3. ERP类人员

　　从事企业管理类软件的人员一般起点比较高(公司的起点就比较高)，要求对财务、生产、销售等流程都有清楚地认识，从业人员不一定为IT出身，而有可能是财务人员或理工科人员等转行而来。IT的迅速发展和企业经营领域的不断拓展，为ERP的推广和发展创造了良好的发展空间。事实上，一个从事企业管理类软件的技术人员完全可以胜任一个企业的管理者，在这一领域技术人员的前景可以说是非常广阔的。

　　我认识的一位朋友，本科读的是工业装备控制专业，毕业后一直从事ERP方面的应用推广和管理咨询，虽然他对纯粹的IT技术了解并不是特别深刻，但在ERP系统在企业中的应用方面经验非常丰富，在别人眼中他更像是一名管理咨询师，五年下来已经是这一领域的专家级人物，在个人收入方面也非常可观。
posted @ 2006-08-21 08:53 阿成 阅读(188) | 评论 (0) | 编辑 收藏
Strategy（策略）模式

Strategy策略模式是属于设计模式中 对象行为型模式,主要是定义一系列的算法,把这些算法一个个封装成单独的类.

Stratrgy应用比较广泛,比如, 公司经营业务变化图, 可能有两种实现方式,一个是线条曲线,一个是框图(bar),这是两种算法,可以使用Strategy实现.

这里以字符串替代为例, 有一个文件,我们需要读取后,希望替代其中相应的变量,然后输出.关于替代其中变量的方法可能有多种方法,这取决于用户的要求,所以我们要准备几套变量字符替代方案.

 

首先,我们建立一个抽象类RepTempRule 定义一些公用变量和方法:

public abstract class RepTempRule{

protected String oldString="";
public void setOldString(String oldString){
　　this.oldString=oldString;
}

protected String newString="";
public String getNewString(){
　　return newString;
}



public abstract void replace() throws Exception;


}

在RepTempRule中 有一个抽象方法abstract需要继承明确,这个replace里其实是替代的具体方法.
我们现在有两个字符替代方案,
1.将文本中aaa替代成bbb;
2.将文本中aaa替代成ccc;

对应的类分别是RepTempRuleOne RepTempRuleTwo

public class RepTempRuleOne extends RepTempRule{


public void replace() throws Exception{

　　//replaceFirst是jdk1.4新特性
　　newString=oldString.replaceFirst("aaa", "bbbb")
　　System.out.println("this is replace one");
　　
}


}
public class RepTempRuleTwo extends RepTempRule{


public void replace() throws Exception{

　　newString=oldString.replaceFirst("aaa", "ccc")
　　System.out.println("this is replace Two");
　　
}


}

第二步：我们要建立一个算法解决类，用来提供客户端可以自由选择算法。

public class RepTempRuleSolve {

　　private RepTempRule strategy;

　　public RepTempRuleSolve(RepTempRule rule){
　　　　this.strategy=rule;
　　}

　　public String getNewContext(Site site,String oldString) {
　　　　return strategy.replace(site,oldString);
　　}

　　public void changeAlgorithm(RepTempRule newAlgorithm) {
　　　　strategy = newAlgorithm;
　　}

}

 

 

调用如下:

public class test{

......

　　public void testReplace(){

　　//使用第一套替代方案
　　RepTempRuleSolve solver=new RepTempRuleSolve(new RepTempRuleSimple());
　　solver.getNewContext(site,context);

　　//使用第二套

　　solver=new RepTempRuleSolve(new RepTempRuleTwo());
　　solver.getNewContext(site,context);

　　}

.....

}

我们达到了在运行期间，可以自由切换算法的目的。

实际整个Strategy的核心部分就是抽象类的使用,使用Strategy模式可以在用户需要变化时,修改量很少,而且快速.

Strategy和Factory有一定的类似,Strategy相对简单容易理解,并且可以在运行时刻自由切换。Factory重点是用来创建对象。

Strategy适合下列场合:

1.以不同的格式保存文件;

2.以不同的算法压缩文件;

3.以不同的算法截获图象;

4.以不同的格式输出同样数据的图形,比如曲线 或框图bar等

posted @ 2006-08-18 09:09 阿成 阅读(271) | 评论 (0) | 编辑 收藏
Struts 表单验证流程－孙卫琴
一、表单验证的流程

在 hello.jsp 网页上，不输入姓名，直接单击【 Submit 】 按钮，会看到如图 2-6 所示的网页。

图 2-6  表单验证失败的 hello.jsp 网页

当客户提交 HelloForm 表单时， 请求路径为 “ /HelloWorld.do ”：

<html:form action="/HelloWorld.do" focus="userName" >

服务器端执行表单验证流程如下。

（ 1 ） Servlet 容器在 web.xml 文件中寻找 <url-pattern> 属性为“ *.do ”的 <servlet-mapping> 元素：

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

（ 2 ） Servlet 容器依据以上 <servlet-mapping> 元素的 <servlet-name> 属性“ action ”，在 web.xml 文件中寻找匹配的 <servlet> 元素：

<servlet>

<servlet-name>action</servlet-name>

<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

</servlet>

（ 3 ） Servlet 容器把请求转发给以上 <servlet> 元素指定的 ActionServlet ， ActionServlet 依据用户请求路径 “ /HelloWorld.do ”， 在 Struts 配置文件中检索 path 属性为 “ /HelloWorld ” 的 <action> 元素 ：

<action    path      = "/HelloWorld"

          type      = "hello.HelloAction"

          name      = "HelloForm"

          scope     = "request"

          validate  = "true"

          input     = "/hello.jsp"

 >

        <forward name="SayHello" path="/hello.jsp" />

 </action>

 

更确切地说， ActionServlet 此时检索的是 ActionMapping 对象，而不是直接访问 Struts 配置文件中的 <action> 元素。因为 在 ActionServlet 初始化的时候，会加载 Struts 配置文件，把各种配置信息保存在相应的配置类的实例中，例如 <action> 元素的配置信息存放在 ActionMapping 对象中。



（ 4 ） ActionServlet 根据 <action> 元素的 name 属性，创建一个 HelloForm 对象，把客户提交的表单数据传给 HelloForm 对象，再把 HelloForm 对象保存在 <action> 元素的 scope 属性指定的 request 范围内。

（ 5 ）由于 <action> 元素的 validate 属性为 true ， ActionServlet 调用 HelloForm 对象的 validate() 方法执行表单验证：

public ActionErrors validate(ActionMapping mapping,

                                 HttpServletRequest request) {

            ActionErrors errors = new ActionErrors();

            if ((userName == null) || (userName.length() < 1))

            errors.add("username", new ActionMessage("hello.no.username.error"));

            return errors;

}

（ 6 ） HelloForm 对象的 validate() 方法返回一个 ActionErrors 对象，里面包含一个 ActionMessage 对象，这个 ActionMessage 对象中封装了错误消息，消息 key 为“ hello.no.username.error ” ， 在 Resource Bundle 中与值匹配的消息文本为：

hello.no.username.error=Please enter a <i>UserName</i> to say hello to!

（ 7 ） ActionServlet 把 HelloForm 的 validate() 方法返回的 ActionErrors 对象保存在 request 范围内，然后根据 <action> 元素的 input 属性，把客户请求转发给 hello.jsp 。

（ 8 ） hello.jsp 的 <html:errors> 标签从 request 范围内读取 ActionErrors 对象，再从 ActionErrors 对象中读取 ActionMessage 对象，把它包含的错误消息显示在网页上。

二、 逻辑验证失败的流程

接下来在 hello.jsp 的 HTML 表单中输入姓名“ Monster ”，然后单击【 Submit 】 按钮。当服务器端响应客户请求时，验证流程如下。

（ 1 ）表单验证 的流程（ 1 ）～（ 4 ）。

（ 2 ） ActionServlet 调用 HelloForm 对象的 validate() 方法，这次 validate() 方法返回的 ActionErrors 对象中不包含任何 ActionMessage 对象，表示表单验证成功。

（ 3 ） ActionServlet 查找 HelloAction 实例是否存在，如果不存在就创建一个实例。然后调用 HelloAction 的 execute() 方法。

（ 4 ） HelloAction 的 execute() 方法先进行逻辑验证，由于没有通过逻辑验证，就创建一个 ActionMessage 对象，这个 ActionMessage 对象封装了错误消息，消息 key 为“ hello.dont.talk.to.monster ”，在 Resource Bundle 中与值匹配的消息文本为：

hello.dont.talk.to.monster=We don't want to say hello to Monster!!!

execute() 方法把 ActionMessage 对象保存在 ActionMessages 对象中，再把 ActionMessages 对象存放在 request 范围内。最后返回一个 ActionForward 对象，该对象包含的请求转发路径为 <action> 元素的 input 属性指定的 hello.jsp 。

以下是 execute() 方法中进行逻辑验证的代码：

ActionMessages errors = new ActionMessages();

String userName = (String)((HelloForm) form).getUserName();

String badUserName = "Monster";

 

if (userName.equalsIgnoreCase(badUserName)) {

     errors.add("username", new ActionMessage("hello.dont.talk.to.monster", badUserName ));

     saveErrors(request, errors);

     return (new ActionForward(mapping.getInput()));

}

（ 5 ） ActionServlet 依据 HelloAction 返回的 ActionForward 对象，再把请求转发给 hello.jsp 。

（ 6 ） hello.jsp 的 <html:errors> 标签从 request 范围内读取 ActionMessages 对象，再从 ActionMessages 对象中读取 ActionMessage 对象，把它包含的错误消息显示在网页上， 如图 所示。

逻辑验证失败时的 hello.jsp 网页

三 、逻辑验证成功的流程

接下来，在 hello.jsp 的 HTML 表单中输入姓名“ Weiqin ”，然后单击【 Submit 】 按钮。当服务器端响应客户请求时，流程如下。

（ 1 ）重复 二 的流程（ 1 ）～（ 3 ）。

（ 2 ） HelloAction 的 execute() 方法先执行逻辑验证，这次通过了验证，然后执行相关的业务逻辑，最后调用 ActionMapping.findForward() 方法，参数为 “ SayHello ”：

// Forward control to the specified success URI

return (mapping.findForward("SayHello"));

（ 3 ） ActionMapping.findForward() 方法从 <action> 元素中寻找 name 属性为 “ SayHello ”的 <forward> 子元素，然后返回与之对应的 ActionForward 对象，它代表的请求转发路径为“ /hello.jsp ”。

更确切地说， ActionMapping 从本身包含的 HashMap 中查找 name 属性为 “ SayHello ” 的 ActionForward 对象。在 ActionServlet 初始化时会加载 Struts 配置文件，把 <action> 元素的配置信息存放在 ActionMapping 对象中。 <action> 元素中可以包含多个 <forward> 子元素，每个 <forward> 子元素的配置信息存放在一个 ActionForward 对象中，这些 ActionForward 对象存放在 ActionMapping 对象的 HashMap 中。

（ 4 ） HelloAction 的 execute() 方法 然后把 ActionForward 对象返回给 ActionServlet ， ActionServlet 再把客户请求转发给 hello.jsp 。

（ 5 ） hello.jsp 的 <bean:message> 标签从 Resource Bundle 中读取文本，把它们输出到网页上，最后生成 动态网页，如图 所示。

  通过数据验证的 hello.jsp 网页

posted @ 2006-08-17 20:22 阿成 阅读(1897) | 评论 (0) | 编辑 收藏
JSP、JAVA、数据库编码总结
1、JSP页面编码
<%@ page contentType="text/html;charset=........"%>
<%@ page language="java" pageEncoding="........"%>
pageEncoding：The encoding used for the JSP page file, as well as
the response charset if no charset is specified by contentType.

If this attribute is omitted, but a charset is specified for contentType,
that charset is also used of the page; if contentType doesn't specify a
charset, ISO-8859-1 is used for a regular JSP page, and UTF-8 is used
for a JSP Document.
posted @ 2006-08-17 10:09 阿成 阅读(357) | 评论 (0) | 编辑 收藏
传说中的100句背7000单词!
关键词： 传说中的100句背7000单词                                          

传说中的100句背7000单词!

1. Typical of the grassland dwellers of the continent is the American antelope, or pronghorn.
　　1.美洲羚羊，或称叉角羚，是该大陆典型的草原动物。
2. Of the millions who saw Haley’s comet in 1986, how many people will live long enough to see it return in the twenty-first century.
　　2. 1986年看见哈雷慧星的千百万人当中，有多少人能够长寿到足以目睹它在二十一世纪的回归呢？
　　3. Anthropologists have discovered that fear, happiness, sadness, and surprise are universally reflected in facial expressions.
　　3.人类学家们已经发现，恐惧，快乐，悲伤和惊奇都会行之于色，这在全人类是共通的。
      4. Because of its irritating effect on humans, the use of phenol as a general antiseptic has been largely discontinued.
　　4.由于苯酚对人体带有刺激性作用，它基本上已不再被当作常用的防腐剂了。
　　5. In group to remain in existence, a profit-making organization must, in the long run, produce something consumers consider useful or desirable.
　　5.任何盈利组织若要生存，最终都必须生产出消费者可用或需要的产品。
　　6. The greater the population there is in a locality, the greater the need there is for water, transportation, and disposal of refuse.
　　6.一个地方的人口越多，其对水，交通和垃圾处理的需求就会越大。
　　7. It is more difficult to write simply, directly, and effectively than to employ flowery but vague expressions that only obscure one’s meaning.
　　7.简明，直接，有力的写作难于花哨，含混而意义模糊的表达。
　　8. With modern offices becoming more mechanized, designers are attempting to personalize them with warmer, less severe interiors.
　　8.随着现代办公室的日益自动化，设计师们正试图利用较为温暖而不太严肃的内部装饰来使其具有亲切感。
　　9. The difference between libel and slander is that libel is printed while slander is spoken.
　　9.诽谤和流言的区别在于前者是书面的，而后者是口头的。
　　10. The knee is the joints where the thigh bone meets the large bone of the lower leg.
　　10.膝盖是大腿骨和小腿胫的连接处。
　　11. Acids are chemical compounds that, in water solution, have a sharp taste, a corrosive action on metals, and the ability to turn certain blue vegetable dyes red.
　　11.酸是一种化合物，它在溶于水时具有强烈的气味和对金属的腐蚀性，并且能够使某些蓝色植物染料变红。
　　12. Billie Holiday’s reputation as a great jazz-blues singer rests on her ability to give emotional depth to her songs.
　　12. Billie Holiday’s作为一个爵士布鲁斯乐杰出歌手的名声建立在能够赋予歌曲感情深度的能力。
　　13. Essentially, a theory is an abstract, symbolic representation of what is conceived to be reality.
13.理论在本质上是对认识了的现实的一种抽象和符号化的表达。
14. Long before children are able to speak or understand a language, they communicate through facial expressions and by making noises.
14.儿童在能说或能听懂语言之前，很久就会通过面部表情和靠发出噪声来与人交流了。
　　15. Thanks to modern irrigation, crops now grow abundantly in areas where once nothing but cacti and sagebrush could live.
15.受当代灌溉(技术设施)之赐，农作物在原来只有仙人掌和荞属科植物才能生存的地方旺盛的生长。
　　16. The development of mechanical timepieces spurred the search for more accurate sundials with which to regulate them.
16.机械计时器的发展促使人们寻求更精确的日晷，以便校准机械计时器。
　　17. Anthropology is a science in that anthropologists use a rigorous set of methods and techniques to document observations that can be checked by others.
17.人类学是一门科学，因为人类学家采用一整套强有力的方法和技术来记录观测结果，而这样记录下来的观测结果是供他人核查的。
　　18. Fungi are important in the process of decay, which returns ingredients to the soil, enhances soil fertility, and decomposes animal debris.
18.真菌在腐化过程中十分重要，而腐化过程将化学物质回馈于土壤，提高其肥力，并分解动物粪便。
　　19. When it is struck, a tuning fork produces an almost pure tone, retaining its pitch over a long period of time.
19.音叉被敲击时，产生几乎纯质的音调，其音量经久不衰。
　　20. Although pecans are most plentiful in the southeastern part of the United States, they are found as far north as Ohio and Illinois.
20.虽然美洲山河桃树最集中于美国的东南部但是在北至俄亥俄州及伊利诺州也能看见它们。
　　21. Eliminating problems by transferring the blame to others is often called scape-goating.
21.用怪罪别人的办法来解决问题通常被称为寻找替罪羊。
　　22. The chief foods eaten in any country depend largely on what grows best in its climate and soil.
22.一个国家的主要食物是什么，大体取决于什么作物在其天气和土壤条件下生长得最好。
　　23. Over a very large number of trials, the probability of an event’s occurring is equal to the probability that it will not occur.
23.在大量的实验中，某一事件发生的几率等于它不发生的几率。
　　24. Most substance contract when they freeze so that the density of a substance’s solid is higher than the density of its liquid.
24.大多数物质遇冷收缩，所以他们的密度在固态时高于液态。
　　25. The mechanism by which brain cells store memories is not clearly understood.
25.大脑细胞储存记忆的机理并不为人明白。
　　26. By the middle of the twentieth century, painters and sculptors in the United States had begun to exert a great worldwide influence over art.
26.到了二十一世纪中叶，美国画家和雕塑家开始在世界范围内对艺术产生重大影响。
　　27. In the eastern part of New Jersey lies the city of Elizabeth, a major shipping and manufacturing center.
27.伊丽莎白市，一个重要的航运和制造业中心，坐落于新泽西州的东部。
　　28. Elizabeth Blackwell, the first woman medical doctor in the United States, founded the New York Infirmary, an institution that has always had a completely female medical staff.
28. Elizabeth Blackwell，美国第一个女医生，创建了员工一直为女性纽约诊所。
　　29. Alexander Graham Bell once told his family that he would rather be remembered as a teacher of the deaf than as the inventor of the telephone.
29. Alexander Graham Bell曾告诉家人，他更愿意让后人记住他是聋子的老师，而非电话的发明者。
　　30. Because its leaves remain green long after being picked, rosemary became associated with the idea of remembrance.
30.采摘下的迷迭香树叶常绿不衰，因此人们把迷迭香树与怀念联系在一起。
31. Although apparently rigid, bones exhibit a degree of elasticity that enables the skeleton to withstand considerable impact.
31.骨头看起来是脆硬的，但它也有一定的弹性，使得骨骼能够承受相当的打击。
　　32. That xenon could not FORM chemical compounds was once believed by scientists.
32.科学家曾相信：氙气是不能形成化合物的。
　　33. Research into the dynamics of storms is directed toward improving the ability to predict these events and thus to minimize damage and avoid loss of life.
33.对风暴动力学的研究是为了提高风暴预测从而减少损失，避免人员伤亡。
　　34. The elimination of inflation would ensure that the amount of money used in repaying a loan would have the same value as the amount of money borrowed.
34.消除通货膨胀应确保还贷的钱应与所贷款的价值相同。
　　35. Futurism, an early twentieth-century movement in art, rejected all traditions and attempted to glorify contemporary life by emphasizing the machine and motion.
35.未来主义，二十世纪早期的一个艺术思潮。拒绝一切传统，试图通过强调机械和动态来美化生活。
　　36. One of the wildest and most inaccessible parts of the United States is the Everglades where wildlife is abundant and largely protected.
36. Everglades是美国境内最为荒凉和人迹罕至的地区之一，此处有大量的野生动植物而且大多受(法律)保护。
　　37. Lucretia Mott's influence was so significant that she has been credited by some authorities as the originator of feminism in the United States.
37. Lucretia Mott's的影响巨大，所以一些权威部门认定她为美国女权运动的创始人。
　　38. The activities of the international marketing researcher are frequently much broader than those of the domestic marketer.
38.国际市场研究者的活动范围常常较国内市场研究者广阔。
　　39. The continental divide refers to an imaginary line in the North American Rockies that divides the waters flowing into the Atlantic Ocean from those flowing into the Pacific.
39.大陆分水岭是指北美洛矶山脉上的一道想象线，该线把大西洋流域和太平洋流域区分开来。
　　40. Studies of the gravity field of the Earth indicate that its crust and mantle yield when unusual weight is placed on them.
40.对地球引力的研究表明，在不寻常的负荷之下地壳和地幔会发生位移。
　　41. The annual worth of Utah's manufacturing is greater than that of its mining and farming combined.
41.尤它州制造业的年产值大于其工业和农业的总和。
　　42. The wallflower is so called because its weak stems often grow on walls and along stony cliffs for support.
42.墙花之所以叫墙花，是因为其脆弱的枝干经常要靠墙壁或顺石崖生长，以便有所依附。
　　43. It is the interaction between people, rather than the events that occur in their lives, that is the main focus of social psychology.
43.社会心理学的主要焦点是人与人之间的交往，而不是他们各自生活中的事件。
　　44. No social crusade aroused Elizabeth Williams' enthusiasm more than the expansion of educational facilities for immigrants to the United States.
44.给美国的新移民增加教育设施比任何社会运动都更多的激发了Elizabeth Williams的热情。
　　45. Quails typically have short rounded wings that enable them to spring into full flight instantly when disturbed in their hiding places.
45.典型的鹌鹑都长有短而圆的翅膀，凭此他们可以在受惊时一跃而起，飞离它们的躲藏地。
　　46. According to anthropologists, the earliest ancestors of humans that stood upright resembled chimpanzees facially, with sloping foreheads and protruding brows.
46.根据人类学家的说法，直立行走的人的鼻祖面部轮廓与黑猩猩相似，额头后倾，眉毛突出。
　　47. Not until 1866 was the fully successful transatlantic cable finally laid.
47.直到1866年第一条横跨大西洋的电缆才完全成功的架通。
　　48. In his writing, John Crowe Ransom describes what he considers the spiritual barrenness of society brought about by science and technology.
48. John Crowe Ransom在他的著作中描述了他认为是由科学技术给社会带来的精神贫困。
　　49. Children with parents whose guidance is firm, consistent, and rational are inclined to possess high levels of self-confidence.
49.父母的教导如果坚定，始终如一和理性，孩子就有可能充满自信。
　　50. The ancient Hopewell people of North America probably cultivated corn and other crops, but hunting and gathering were still of critical importance in their economy.
50.北美远古的Hopewell人很可能种植了玉米和其他农作物，但打猎和采集对他们的经济贸易仍是至关重要的。
　　51. Using many symbols makes it possible to put a large amount of inFORMation on a single map.
51.使用多种多样的符号可以在一张地图里放进大量的信息。
　　52. Anarchism is a term describing a cluster of doctrines and attitudes whose principal uniting feature is the belief that government is both harmful and unnecessary.
52.无政府主义这个词描述的是一堆理论和态度，它们的主要共同点在于相信政府是有害的，没有必要的。
　　53. Probably no man had more effect on the daily lives of most people in the Untied States than did Henry Ford a pioneer in automobile production.
53.恐怕没有谁对大多数美国人的日常生活影响能超过汽车生产的先驱亨利.福特。
　　54. The use of well-chosen nonsense words makes possible the testing of many basic hypotheses in the field of language learning.
54.使用精心挑选的无意义词汇，可以检验语言学科里许多基本的假定。
　　55. The history of painting is a fascinating chain of events that probably began with the very first pictures ever made.
55.优化历史是由一连串的迷人事件组成，其源头大概可以上溯到最早的图画。
　　56. Perfectly matched pearls, strung into a necklace, bring a far higher price than the same pearls told individually.
56.相互般配的珍珠，串成一条项链，就能卖到比单独售出好得多的价钱。
　　57. During the eighteenth century, Little Turtle was chief of the Miami tribe whose territory became what is now Indiana and Ohio.
57.十八世纪时，"小乌龟"是迈阿密部落的酋长，该部落的地盘就是今天的印第安那州和俄亥俄州。
　　58. Among almost seven hundred species of bamboo, some are fully grown at less than a foot high, while others can grow three feet in twenty-four hours.
58.在竹子的近七百个品种中，有的全长成还不到一英尺，有的却能在二十四小时内长出三英尺。
　　59. Before staring on a sea voyage, prudent navigators learn the sea charts, study the sailing directions, and memorize lighthouse locations to prepare themselves for any conditions they might encounter.
59.谨慎的航海员在出航前，会研究航向，记录的灯塔的位置，以便对各种可能出现的情况做到有备无患。
　　60. Of all the economically important plants, palms have been the least studied.
60.在所有的经济作物中，棕榈树得到的研究最少。
　　61. Buyers and sellers should be aware of new developments in technology can and does affect marketing activities.
61.购买者和销售者都应该留意技术的新发展，原因很简单，因为技术能够并且已经影响着营销活动。
　　62. The application of electronic controls made possible by the microprocessor and computer storage have multiplied the uses of the modern typewriter.
62.电脑储存和由于电子微处理机得以实现的电控运用成倍的增加了现代打字机的功能。
　　63. The human skeleton consists of more than two hundred bones bound together by tough and relatively inelastic connective tissues called ligaments.
63.人类骨骼有二百多块骨头组成，住些骨头石油坚韧而相对缺乏弹性的，被称为韧带的结蒂组连在一起。
　　64. The pigmentation of a pearl is influenced by the type of oyster in which it develops and by the depth, temperature, and the salt content of the water in which the oyster lives.
64.珍珠的色泽受到作为其母体牡蛎种类及牡蛎生活水域的深度，温度和含盐度的制约。
　　65. Although mockingbirds superbly mimic the songs and calls of many birds, they can nonetheless be quickly identified as mockingbirds by certain aural clues.
65.尽管模仿鸟学很多种鸟的鸣叫声惟妙惟肖，但人类还是能够依其声音上的线索很快识别它们。
　　66. Not only can walking fish live out of water, but they can also travel short distances over land.
66.鲇鱼不仅可以离开水存活，还可以在岸上短距离移动。
　　67. Scientists do not know why dinosaurs became extinct, but some theories postulate that changers in geography, climate, and sea levels were responsible.
67.科学家不知道恐龙为何绝种了，但是一些理论推断是地理，气候和海平面的变化造成的。
　　68. The science of horticulture, in which the primary concerns are maximum yield and superior quality, utilizes inFORMation derived from other sciences.
68.主要目的在于丰富和优质的农艺学利用了其他科学的知识。
　　69. Snow aids farmers by keeping heart in the lower ground levels, thereby saving the seeds from freezing.
69.雪对农民是一种帮助，因为它保持地层土壤的温度，使种子不致冻死。
　　70. Even though the precise qualities of hero in literary words may vary over time, the basic exemplary function of the hero seems to remain constant.
70.历代文学作品中的英雄本色虽各有千秋，但其昭世功力却是恒古不变的。
　　71. People in prehistoric times created paints by grinding materials such as plants and clay into power and then adding water.
71.史前的人们制造颜料是将植物和泥土等原料磨成粉末，然后加水。
　　72. Often very annoying weeds, goldenrods crowd out less hardy plants and act as hosts to many insect pests.
72.黄菊花通常令人生厌，它挤走不那么顽强的植物，并找来很多害虫。
　　73. Starting around 7000 B.C., and for the next four thousand years, much of the Northern Hemisphere experienced temperatures warmer than at present.
73.大约从公元前七千年开始，在四千年当中，北半球的温度比现在高。
　　74. When Henry Ford first sought financial backing for making cars, the very notion of farmers and clerks owning automobiles was considered ridiculous.
74.当亨利.福特最初制造汽车为寻求资金支持时，农民和一般职员也能拥有汽车的想法被认为是可笑的。
　　75. Though once quite large, the population of the bald eagle across North America has drastically declined in the past forty years.
75.北美秃头鹰的数量一度很多，但在近四十年中全北美的秃头鹰数量急剧下降。
　　76. The beaver chews down trees to get food and material with which to build its home.
76.水獭啃倒树木，以便取食物并获得造窝的材料。
　　77. Poodles were once used as retrievers in duck hunting, but the American Kennel Club does not consider them sporting dogs because they are now primarily kept as pets.
77.长卷毛狗曾被用作猎鸭时叼回猎物的猎犬，但是美国Kennel Club却不承认它们为猎犬，因为它们现在大多数作为宠物饲养。
　　78. As a result of what is now know in physics and chemistry, scientists have been able to make important discoveries in biology and medicine.
78.物理学和化学的一个成果是使得科学家们能在生物学和医学上获得重大发现。
　　79. The practice of making excellent films based on rather obscure novels has been going on so long in the United States as to constitute a tradition.
79.根据默默无闻的小说制作优秀影片在美国由来已久，已经成为传统。
　　80. Since the consumer considers the best fruit to be that which is the most attractive, the grower must provide products that satisfy the discerning eye.
80.因为顾客认为最好的水果应该看起来也是最漂亮的，所以种植者必须提供能满足挑剔眼光的产品。
　　81. Television the most pervasive and persuasive of modern technologies, marked by rapid change and growth, is moving into a new era, an era of extraordinary sophistication and versatility, which promises to reshape our lives and our world.
81.电视，这项从迅速变化和成长为标志的最普及和最有影响力的现代技术，正在步入一个新时代，一个极为成熟和多样化的时代，这将重塑我们的生活和世界。
　　82. Television is more than just an electronics; it is a means of expression, as well as a vehicle for communication, and as such becomes a powerful tool for reaching other human beings.
82.电视不仅仅是一件电器；它是表达的手段和交流的载体并因此成为联系他人的有力工具。
　　83. Even more shocking is the fact that the number and rate of imprisonment have more than doubled over the past twenty years, and recidivism------that is the rate for re-arrest------is more than 60 percent.
83.更让人吃惊的事实是监禁的数目和比例在过去的二十年中翻了一番还有余，以及累犯率——即再次拘押的比例——为百分之六十强。
　　84. His teaching began at the Massachusetts Institute of Technology, but William Rainey Harper lured him to the new university of Chicago, where he remained officially for exactly a generation and where his students in advanced composition found him terrifyingly frigid in the classroom but sympathetic and understanding in their personal conferences.
84.他的教书生涯始于麻省理工学院，但是William Rainey Harper把他吸引到了新成立的芝加哥大学。他在那里正式任职长达整整一代人的时间。他的高级作文课上的学生觉得他在课上古板得可怕，但私下交流却富有同情和理解。
　　85. The sloth pays such little attention to its personal hygiene that green algae grow on its coarse hair and communities of a parasitic moth live in the depths of its coat producing caterpillars which graze on its mouldy hair. Its muscles are such that it is quits incapable of moving at a speed of over a kilometer an hour even over the shortest distances and the swiftest movement it can make is a sweep of its hooked arm.
85.树獭即不讲究卫生，以至于它粗糙的毛发上生出绿苔，成群的寄生蛾生长在它的皮毛深处，变成毛毛虫，并以它的脏毛为食。她的肌肉不能让他哪怕在很短的距离以内以每小时一公里的速度移动。它能做的最敏捷的动作就是挥一挥它弯曲的胳膊。
　　86. Artificial flowers are used for scientific as well as for decorative purposes. They are made from a variety of materials, such as way and glass, so skillfully that they can scarcely be distinguished from natural flowers.
86.人造花卉即可用于科学目的，也可用于装饰目的，它们可以用各种各样的材料制成，臂如蜡和玻璃；其制作如此精巧，几乎可以以假乱真。
　　87. Three years of research at an abandoned coal mine in Argonne, Illinois, have resulted in findings that scientists believe can help reclaim thousands of mine disposal sites that scar the coal-rich regions of the United States.
87.在伊利诺州Angonne市的一个废弃煤矿的三年研究取得了成果，科学家们相信这些成果可以帮助改造把美国产煤区弄得伤痕累累的数千个旧煤场。
　　88. When the persuading and the planning for the western railroads had finally been completed, the really challenging task remained: the dangerous, sweaty, backbreaking, brawling business of actually building the lines.
88.当有关西部铁路的说服和规划工作终于完成后，真正艰难的任务还没有开始；即危险，吃力，需要伤筋动骨和吵吵嚷嚷的建造这些铁路的实际工作。
　　89. Because of the space crunch, the Art Museum has become increasingly cautious in considering acquisitions and donations of art, in some cases passing up opportunities to strengthen is collections.
89.由于空间不足，艺术博物馆在考虑购买和接受捐赠的艺术品是越来越慎重，有些情况下放弃其进一步改善收藏的机会。
　　90. The United States Constitution requires that President be a natural-born citizen, thirty-five years of age or older, who has lived in the United States for a minimum of fourteen years.
90.美国宪法要求总统是生于美国本土的公民，三十五岁以上，并且在美国居住了至少十四年。
　　91. Arid regions in the southwestern United States have become increasingly inviting playgrounds for the growing number of recreation seekers who own vehicles such as motorcycles or powered trail bikes and indulge in hill-climbing contests or in caving new trails in the desert.
91.美国西部的不毛之地正成为玩耍的地方，对越来越多拥有摩托车或越野单车类车辆的，喜欢放纵于爬坡比赛或开辟新的沙漠通道的寻欢作乐者具有不断增长的吸引力。
　　92. Stone does decay, and so tools of long ago have remained when even the bones of the man who made them have disappeared without trace.
92.石头不会腐烂，所以以前的(石器)工具能保存下来，虽然它们的制造者已经消失的无影无踪。
　　93. Insects would make it impossible for us to live in the world; they would devour all our crops and kill our flocks and herds, if it were not for the protection we get from insect-eating animals.
93.昆虫就将会使我们无法在这个世界上居住；如果我们没有受到以昆虫为食的动物的保护，昆虫就会吞嚼掉我们所有的庄稼并杀死我们饲养的禽兽。
　　94. It is true that during their explorations they often faced difficulties and dangers of the most perilous nature, equipped in a manner which would make a modern climber shudder at the thought, but they did not go out of their way to court such excitement.
94.确实，他们在探险中遇到了极具威胁性的困难和危险，而他们的装备会让一个现代登山者想一想都会浑身颤栗。不过他们并不是刻意去追求刺激的。
　　95. There is only one difference between an old man and a young one: the young man has a glorious future before him and old one has a splendid future behind him: and maybe that is where the rub is.
95.老人和年轻人之间只有一个区别：年轻人的前面有辉煌的未来，老年人灿烂的未来却已在它们身后。这也许就是困难之所在。
　　96. I find young people exciting. They have an air of freedom, and they have not a dreary commitment to mean ambitions or love comfort. They are not anxious social climbers, and they have no devotion to material things.
96.我们位年强人振奋。它们带有自由的气息，他们不会为狭隘的野心和贪婪享受而孜孜以求。他们不是焦虑的向上爬的人，他们不会对物质性的东西难舍难分。
　　97. I am always amazed when I hear people saying that sport creates goodwill between the nations, and that if only the common peoples of the world could meet one another at football or cricket, they would have no inclination to meet on the battlefield.
97.每次我听说体育运动能够在国家间建立起友好感情，说世界各地的普通人只要能在足球场或板球场上相遇就会没有兴趣在战场上相遇的话，我都倍感诧异。
　　98. It is impossible to say simply for the fun and exercise: as soon as the question of prestige arises, as soon as you feel that you and some larger unit will be disgraced if you lose, the most savage combative instincts are around.
98.没有可能仅仅为了娱乐或锻炼而运动：一旦有了问题，一旦你觉得你输了你和你所属团体会有失体面时，你最野蛮的好斗本能就会被激发出来。
　　99. It has been found that certain bats emit squeaks and by receiving the echoes, they can locate and steer clear of obstacles------or locate flying insects on which they feed. This echo-location in bats is often compared with radar, the principle of which is similar.
99.人们已经发现，某些蝙蝠发出尖叫声并靠接受回响来锁定和避免障碍物——或者找到它们赖以为生的昆虫。蝙蝠这种回响定位法常拿来和原理与之很相近似的雷达相比。
　　100. As the time and cost of making a clip drop to a few days and a few hundred dollars, engineers may soon be free to let their imaginations soar without being penalized by expensive failure.
100.随着芯片制造时间和费用降低到了几天和几百美元，工程师们可能很快可以任他们的想象驰骋而不会被昂贵的失败所惩罚。

posted @ 2006-08-16 20:25 阿成 阅读(260) | 评论 (0) | 编辑 收藏
1000句最常用英语口语
     摘要: 1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up! ...  阅读全文
posted @ 2006-08-16 20:24 阿成 阅读(1531) | 评论 (0) | 编辑 收藏
tomcat配置手册（server.xml）——中文版

概述

本手册包含conf/server.xml文件中所有配置指示符(directives)的参考信息，这些指示符决定了Tomcat 5的行为。本手册并不描述应该使用哪个配置指示符来完成特定的任务,请参考对应的HOW-TO文件。 
配置元素的描述按照如下主目录来组织：

    顶级元素－是整个配置文件的根元素，而代表与一个引擎(Engine)相关联的一组连接器(Connectors)； 
    连接器(Connectors)-代表外部客户之间的接口。外部客户向特定的Service发送请求，并接收响应； 
    容器－代表一些组件。这些组件的功能是处理进来的请求，生成对应的响应。引擎(Engine)处理一个Service的所有请求，Host处理一个特定虚拟主机的所有请求。Context处理某个特定web应用的所有请求； 
    嵌入组件－代表可以嵌入容器的某个元素之中的元素。有些元素可以嵌入任何容器，而另一些元素只能嵌入在Context中。 

对每个元素，对应的文档按照如下方式组织： 
概述－对这个特定组件的整体描述。每个组件在org.apache.catalina包中存在一个对应的Java接口，可能有一个或多个标准实现实现了这个接口； 
属性－该元素的合法属性。一般来说，这又分成公共属性和标准实现属性。公共属性是所有实现了该Java接口的实现都具有的属性。标准实现属性是实现了该Java接口的某个特定Java类具有的属性。必需的属性用粗体标出； 
嵌套组件－列举了可以合法地嵌在这个元素下的组件； 
专有特性－描述了该接口的标准实现支持的专有特性的配置，与每个元素类型有关；

顶级元素：Server  Service

连接器：HTTP/1.1  JK 

容器：Context  Engine  Host 

嵌套组件：
Default Context 
Global Resources 
Loader 
Logger 
Manager 
Realm 
Resources 
Valve 

posted @ 2006-08-16 20:03 阿成 阅读(255) | 评论 (0) | 编辑 收藏
Log4j基本使用方法

Log4j基本使用方法
(转http://blogger.org.cn/blog/more.asp?name=dashee&id=6431)
　　Log4j由三个重要的组件构成：日志信息的优先级，日志信息的输出目的地，日志信息的输出格式。日志信息的优先级从高到低有ERROR、WARN、 INFO、DEBUG，分别用来指定这条日志信息的重要程度；日志信息的输出目的地指定了日志将打印到控制台还是文件中；而输出格式则控制了日志信息的显示内容。

　　一、定义配置文件

　　其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

　　1.配置根Logger，其语法为：

　　log4j.rootLogger = [ level ] , appenderName, appenderName, …

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指B日志信息输出到哪个地方。您可以同时指定多个输出目的地。

　　2.配置日志信息输出目的地Appender，其语法为：

　　log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.option = valueN

　　其中，Log4j提供的appender有以下几种：
　　org.apache.log4j.ConsoleAppender（控制台），
　　org.apache.log4j.FileAppender（文件），
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　　3.配置日志信息的格式（布局），其语法为：

　　log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

　　其中，Log4j提供的layout有以e几种：
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　二、在代码中使用Log4j

　　1.得到记录器

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

　　static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

　　2.读取配置文件

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

　　BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　3.插入记录信息（格式化日志信息）

　　当上两个必要步骤执行完毕，您就可以轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

　　Logger.debug ( Object message ) ;
　　Logger.info ( Object message ) ;
　　Logger.warn ( Object message ) ;
　　Logger.error ( Object message ) ;

posted @ 2006-08-16 20:02 阿成 阅读(227) | 评论 (0) | 编辑 收藏
Java Web Framework综述－ZT（buaawhl的blog）
     摘要: 本文介绍 Java Web Framework 的基本工作原理，和一些常用的开源 Web MVC Framework(Struts, Web Work, Tapestry, Echo, JSF, Maverick, Spring MVC, Turbine, Cocoon, Barracuda) 。 ...  阅读全文
posted @ 2006-08-16 19:59 阿成 阅读(170) | 评论 (0) | 编辑 收藏
span和div的区别
SPAN 和 DIV 的区别在于，DIV(division)是一个块级元素，可以包含段落、标题、表格，乃至诸如章节、摘要和备注等。而SPAN 是行内元素，SPAN 的前后是不会换行的，它没有结构的意义，纯粹是应用样式，当其他行内元素都不合适时，可以使用SPAN。

　　效果：

　　<span>SPAN标记有一个重要而实用的特性，即它什么事也不会做，它的唯一目的就是围绕你的HTML代码中的其它元素，这样你就可以为它们指定样式了。在此例中，<span>标识符允许你将一个段落分成不同的部分。

　　还有一个标识符具有类似的功能，<div>DIV也被用来在HTML文件中建立逻辑部分。但与<div>SPAN不同，<div>工作于文本块一级，它在它所包含的HTML元素的前面及后面都引入了行分隔。

posted @ 2006-08-16 17:09 阿成 阅读(255) | 评论 (0) | 编辑 收藏
Ajax缘何流行—来看看大象本身
随着2005年Ajax这个名词的流行，关于Ajax技术本身的争论就一直喋喋不休。有些人为这种技术而激动，兴奋得投入到 Ajax的大潮中。有些人对Ajax大为诟病，认为其不过是一种炒作，其类似技术早已实现，毫无新意。也有些人还持一种观望的状态，等到大势所趋时，才进 行投入。

　　总之，一个新兴事物的诞生之初，有不同的观点进行争论是很正常的现象。作者作为支持Ajax的一派，对这个新生事物，可以说是倾注了很多精 力。从最初的不懂，到略知一二，再到深刻认识，发现Ajax背后隐藏的趋势，多少有些亢奋。凭此文，希望能够把自己的观点，表达一二。

　　Ajax在2005年异军突起，伴随着Web2.0，成为了本年度最为流行的名词之一。很多人看到这样一门技术，可能会很奇怪，感到很突兀。

  • 　　为什么会突然产生这样一种技术?
  • 　　类似的技术早就有，Ajax有什么突破?
  • 　　为什么这种技术如此盛行，并被某些人认为是一种趋势呢?

　　如果你仅仅试图从Ajax本身去寻找这些问 题的答案，你可能会一无所获。如果你仅能够看到Ajax本身，那就如同瞎子摸象、管中窥豹，不能领略全局，当然也不能领会其意义。相反，如果你能够从一个 更好的高度上去思考Ajax所带来的好处，把Ajax放到一个相关的语境中去体会，你就会有另一番发现。

　　与Ajax相连的，还有这么两个名词—RiA和Web2.0。

　　什么是RiA?

　　RiA就是Rich Internet Application的缩写。

　　“Rich”代表功能强大，高交互性，高用户体验。

　　“Internet”代表方便。应用程序部署方便，用户使用方便。跨系统，跨语言。

　 　其实RiA实际上一种基于Web的C/S架构(我称之为C/S/B)。由于有一个客户端，所以RiA应用可以提供强大的功能，让用户体验到高交互性，高 用户体验。同时，RiA又是基于Internet浏览器的应用，所以，用户使用RiA非常方便。理想来说，用户使用RiA应当像现在使用普通网页一样方 便。用户不需要安装任何的客户端软件，只要拥有浏览器。当用户通过浏览器发出指令，希望运行某种RiA应用程序时，一切都会飞快的建立在客户端机器上，就 像你在Web上点击一个页面一样。

　　目前，典型的RiA的代表有如下几种技术:

  • 　　MS ClickOnce
  • 　　Sun Java Web Start
  • 　　Adobe Flash
  • 　　Ajax

　　应该说，各大厂商均看到了RiA美好的未来，纷纷行动起来希望分一杯羹。只有Ajax技术在这些技术中有些特立独行。

　 　Ajax并不属于任何厂商，相反，Ajax代表的是一种开源的风格。由于Ajax所采用的各种技术要么是基于标准的，要么也没有被各大厂商所垄断，所以 Ajax真正是一个平民化的技术，谁都可以用它。同时，由于Ajax采用的各种技术基于现有的浏览器，所以兼容性最好。用Ajax技术建立的网站，目前均 可以直接运行，不需要任何客户端的改变。

　　其他的各种技术与Ajax比较起来，目前或多或少的还有些兼容性的问题。虽然这些技术功能强 大，但是目前它们应用起来还并不是很方便。不过可以看到，随着时间的推进，相信，未来还是属于功能更强大的一方。除非Ajax本身的功能有所加强。这样， 就看Javascript的功力了。

　　RiA实际上代表的是一种回归。

　　最开始流行的C/S结构，因为功能强大，而且范围有限，不需要害怕部署问题。之后随着用户的增加，部署问题越来越大，导致B/S模式的产生。

　 　B/S模式虽然功能有限，但是却使用非常方便。从长期来看，方便的作用还是非常巨大的。功能可以不断增强，但是如果不方便，将吓走所有的客户。实际上观 察一下Web的发展，就会发现，如今百花齐放的Web开发技术，其目的都是为了提高B/S架构的交互性，让他更能适应需要而已。

　　不过， 随着目前越来越多的应用需要一直到Web上，人们终于发现B/S模式的缺点。各种技术上的硬性问题均限制着B/S模式的发展。从最基本的请求/相应模型， HTTP协议，到所有负载均运行在服务器上的事实，让我们迫切需要一种方式来提高Web的交互能力，但同时又不能丧失它的使用方便性。

　　于是，RiA诞生了。RiA就是基于浏览器的C/S结构。它将部分的服务器负载转移到客户端，同时又不会丧失使用和部署上的方便性。所以说，RiA就是一次回归，只不过这次回归我们没有原地不动，相反，我们找到了最佳结合点。如图1所示:

　　图1、RiA就是一种回归

　　但是，我们知道了RiA是一种回归。可是，为什么RiA会盛行呢?这就需要我们把RiA放到Web2.0的环境中去思考。

　　什么是Web2.0?

　　目前，对于Web2.0并没有明确的定义。在《What Is Web 2.0》这篇文章里，对Web2.0应用所需要具备的各种特点进行了总结，并且提了出来。

  • 　　Services, not packaged software, with cost-effective scalability
  • 　　Control over unique, hard-to-recreate data sources that get richer as more people use them
  • 　　Trusting users as co-developers
  • 　　Harnessing collective intelligence
  • 　　Leveraging the long tail through customer self-service
  • 　　Software above the level of a single device
  • 　　Lightweight user interfaces, development models, AND business models

　　虽然有这么多特性，但是Web2.0背后最本质的东西就只有两点:

  1. 　　软件向服务化发展，向平台化发展
  2. 　　Web由原来“Publisher”的观点，发展成“Participation”的观点。

　　正是基于这两点，Web2.0时代迫切需要一种使用方便，高交互性的应用程序，而此重任，就落在了RiA身上。

　　通过图2，你可以看到由Web1.0到Web2.0的变化。

　　图2、Web1.0向Web2.0的演变

　 　还是在《What Is Web 2.0》那篇文章里，勾勒出了一幅Web2.0的Meme Map。这张图的中心代表的是Web2.0的核心概念，而旁边是Web2.0概念的延伸。在这张图里，我试图勾勒出一些迫切需要RiA的特征点。实际上， 你可以看到，在Web2.0的Meme Map里，到处充满了RiA的倩影。如图3所示:

　　图3、Web2.0中的RiA倩影

　　看看大象本身

　　介绍了这么多，让我们总结一下。

　　随着软件和互联网的发展，需求导致一种新的计算模型出现。这种计算模型的特色就是，软件逐渐的有前台推向后台，以平台的方式提供服务，让用户在前台表演。

　　计算模型的变化，导致Web2.0的出现。尽管仅仅是开始，但是，从Web2.0的身上你依然可以依稀看到这种变化的趋势。不过Web2.0要想有如此变化，要想让用户参与进来，就必须提供一个用户功能强大的，使用方便的用户接口(UI)。

　　于是，需求导致了RiA的出现。RiA提供了一个满足需求的用户接口，使得大家可以参与到Web2.0中来。但是，RiA要想应用起来，可能还需要一个过程。

　　于是，几种RiA技术中，目前使用起来最合适的Ajax凸现出来。正是由于Ajax出色的兼容性，让他走到了历史的前台。有了它，我们开始了一场新的革命。

　　图4显示了这些名词之间的关系。把它们放在一起看，也许你会发现不一样的东西。

　　图4、Ajax、RiA与Web2.0

　　未来的样子

　　当我走在北京的街头，我在想，如果我有一台智能手机，可以访问百度的map服务，也许我就不会像现在这样担心迷路了。实际上，类似的例子还有很多。如果Web2.0的明天已经到来，我们的生活会发生很多改变。

　　我不知道，尽管我很想知道。如果我真的能够看到未来的样子，再具备一些必要的执行力的话，也许我就是下一个比尔。不过，看到目前的这一点，已经令我非常兴奋。不管怎么样，我们都有权利想象。也有权利，用我们的手去改变世界。

　　怎么样?开始吧?Let’s do it!
posted @ 2006-08-16 17:09 阿成 阅读(300) | 评论 (0) | 编辑 收藏
Ajax: A New Approach to Web Applications

by Jesse James Garrett（http://www.adaptivepath.com/publications/essays/archives/000385.php）

February 18, 2005

If anything about current interaction design can be called “glamorous,” it’s creating Web applications. After all, when was the last time you heard someone rave about the interaction design of a product that wasn’t on the Web? (Okay, besides the iPod.) All the cool, innovative new projects are online.

Despite this, Web interaction designers can’t help but feel a little envious of our colleagues who create desktop software. Desktop applications have a richness and responsiveness that has seemed out of reach on the Web. The same simplicity that enabled the Web’s rapid proliferation also creates a gap between the experiences we can provide and the experiences users can get from a desktop application.

That gap is closing. Take a look at Google Suggest. Watch the way the suggested terms update as you type, almost instantly. Now look at Google Maps. Zoom in. Use your cursor to grab the map and scroll around a bit. Again, everything happens almost instantly, with no waiting for pages to reload.

Google Suggest and Google Maps are two examples of a new approach to web applications that we at Adaptive Path have been calling Ajax. The name is shorthand for Asynchronous JavaScript + XML, and it represents a fundamental shift in what’s possible on the Web.

Defining Ajax

Ajax isn’t a technology. It’s really several technologies, each flourishing in its own right, coming together in powerful new ways. Ajax incorporates:

The classic web application model works like this: Most user actions in the interface trigger an HTTP request back to a web server. The server does some processing — retrieving data, crunching numbers, talking to various legacy systems — and then returns an HTML page to the client. It’s a model adapted from the Web’s original use as a hypertext medium, but as fans of The Elements of User Experience know, what makes the Web good for hypertext doesn’t necessarily make it good for software applications.

Ajax Overview 1

Figure 1: The traditional model for web applications (left) compared to the Ajax model (right).

This approach makes a lot of technical sense, but it doesn’t make for a great user experience. While the server is doing its thing, what’s the user doing? That’s right, waiting. And at every step in a task, the user waits some more.

Obviously, if we were designing the Web from scratch for applications, we wouldn’t make users wait around. Once an interface is loaded, why should the user interaction come to a halt every time the application needs something from the server? In fact, why should the user see the application go to the server at all?

How Ajax is Different

An Ajax application eliminates the start-stop-start-stop nature of interaction on the Web by introducing an intermediary — an Ajax engine — between the user and the server. It seems like adding a layer to the application would make it less responsive, but the opposite is true.

Instead of loading a webpage, at the start of the session, the browser loads an Ajax engine — written in JavaScript and usually tucked away in a hidden frame. This engine is responsible for both rendering the interface the user sees and communicating with the server on the user’s behalf. The Ajax engine allows the user’s interaction with the application to happen asynchronously — independent of communication with the server. So the user is never staring at a blank browser window and an hourglass icon, waiting around for the server to do something.

Ajax Overview 2

Figure 2: The synchronous interaction pattern of a traditional web application (top) compared with the asynchronous pattern of an Ajax application (bottom).

Every user action that normally would generate an HTTP request takes the form of a JavaScript call to the Ajax engine instead. Any response to a user action that doesn’t require a trip back to the server — such as simple data validation, editing data in memory, and even some navigation — the engine handles on its own. If the engine needs something from the server in order to respond — if it’s submitting data for processing, loading additional interface code, or retrieving new data — the engine makes those requests asynchronously, usually using XML, without stalling a user’s interaction with the application.

Who’s Using Ajax

Google is making a huge investment in developing the Ajax approach. All of the major products Google has introduced over the last year — Orkut, Gmail, the latest beta version of Google Groups, Google Suggest, and Google Maps — are Ajax applications. (For more on the technical nuts and bolts of these Ajax implementations, check out these excellent analyses of Gmail, Google Suggest, and Google Maps.) Others are following suit: many of the features that people love in Flickr depend on Ajax, and Amazon’s A9.com search engine applies similar techniques.

These projects demonstrate that Ajax is not only technically sound, but also practical for real-world applications. This isn’t another technology that only works in a laboratory. And Ajax applications can be any size, from the very simple, single-function Google Suggest to the very complex and sophisticated Google Maps.

At Adaptive Path, we’ve been doing our own work with Ajax over the last several months, and we’re realizing we’ve only scratched the surface of the rich interaction and responsiveness that Ajax applications can provide. Ajax is an important development for Web applications, and its importance is only going to grow. And because there are so many developers out there who already know how to use these technologies, we expect to see many more organizations following Google’s lead in reaping the competitive advantage Ajax provides.

Moving Forward

The biggest challenges in creating Ajax applications are not technical. The core Ajax technologies are mature, stable, and well understood. Instead, the challenges are for the designers of these applications: to forget what we think we know about the limitations of the Web, and begin to imagine a wider, richer range of possibilities.

It’s going to be fun.

posted @ 2006-08-16 17:08 阿成 阅读(234) | 评论 (0) | 编辑 收藏
ajax各种资源
1、表单验证，如何不提交就验证，是通过鼠标选中其他输入框表示前一个输入框输入完毕，就可以自动进行验证。

2、http://www.chinaren.com/ 大家都去过吧，首页顶部搜索条“学校、班机、同学、热贴、网页、音乐、图片”这些标签，点一个下面的内

容就换成与所点搜索项有关的，这是如何实现的呢？我要做这个功能

一.资源类网站

1,国内网站

1)Ajax中国(推荐)

一个专业的ajax技术网站,分类清晰,有大量的电子版教程,以及AJAX源码下载!

www.okajax.com

2)ajaxcn.org

李琨老师的blog。李琨:《ajax实战》译者.

www.ajaxcn.org

3)www.ajaxw3c.com

2,国外网站

1)、Ajax的诞生

Ajax:ANewApproachtoWebApplications

www.adaptivepath.com/publications/essays/archives/000385.php

2)、AJAXMatters

www.ajaxmatters.com

关于Ajax技术一个信息量非常大的网站，有点像Ajax世界中的TSS。

3)、AJAXPatterns

与AJAX设计模式相关的资源。

www.ajaxpatterns.org

www.softwareas.com/ajax-patterns

4)、http://www.ajaxian.com

二.热门文章

1.什么是AJAX

www.okajax.com/info/net/20060510.html

2.ajax技术简介

www.okajax.com/info/basic/200604654.html

3.ajax.net

www.okajax.com/info/basic/200604556.html

www.okajax.com/info/tech/200605589.html

weblogs.asp.net/mschwarz/archive/2005/04/11/399893.aspx(英文)

三.ajax相关下载（电子书教程/源码）

1.Ajax基础教程电子版

www.okajax.com/info/bookdown/200604950.htm

2.《AJAX实战》ajaxinaction电子版

www.okajax.com/info/bookdown/200604366.htm

3.AJAX开发简略

www.okajax.com/info/bookdown/20060538.htm

4.AJAX版CD管理系统(jsp)

www.okajax.com/info/codedown/200604327.htm

5.Alexa查询系统(Xmlhttp+Ajax)

www.okajax.com/info/codedown/200604982.htm

6.ASP.NET+AJAX解决网页打开等待问题

www.okajax.com/info/codedown/200604166.htm

7.Ajax技术简介(ajaxdemo)

www.okajax.com/info/codedown/200604576.htm

四.ajax相关图书

1.《Ajax实战》(目前Ajax领域最为全面深入的一本著作)

www.china-pub.com/computers/common/info.asp?id=28433

2.《Ajax基础教程》（亚马逊计算机榜首图书，国内第1本Ajax图书，中文pdf版）

http://www.devworld.cn/art2527.aspx

3.《Ajax修炼之道-Web2.0入门》（Ajax从小工到专家的首选图书）

www.china-pub.com/computers/common/info.asp?id=29430

4.《征服Ajax+Lucene构建搜索引擎》

www.china-pub.com/computers/common/info.asp?id=29996

5.《征服Ajax--Web2.0快速入门与项目实践（.net）》

www.china-pub.com/computers/common/info.asp?id=29995

6.《Ajax开发精要--概念、案例与框架》

www.china-pub.com/computers/common/info.asp?id=30006

7.AJAX——新手快车道
           
http://www.sp1.cn/ajax/info/bookdown/200605663.htm

8,Ajax 探密 (Ajax Hacks )

http://www.sp1.cn/ajax/info/bookdown/20060540.htm

9.Ajax基础教程电子版
           
http://wh.wlha.com.cn/bbs/pic/ajaxbasic.rar
               

五.部分技术文章

www.dragonson.com/doc/ajax.html

Ajax内部交流文档

info96.k12studio.com/~nio/comments.php?id=242_0_1_0_C

简单地对Ajax进行描述介绍

www.adaptivepath.com/publications/essays/archives/000385.php

Ajax:ANewApproachtoWebApplications

jibbering.com/2002/4/httprequest.html

UsingtheXMLHTTPRequestobject

developer.apple.com/internet/webcontent/xmlhttpreq.html

DynamicHTMLandXML:TheXMLHttpRequestObject

del.icio.us/popular/ajax

www.fiftyfoureleven.com/resources/programming/xmlhttprequest/examples

XMLHttpRequest&AjaxWorkingExamples

www.xml.com/lpt/a/2005/02/09/xml-http-request.html

VeryDynamicWebInterfaces

www.standards-schmandards.com/index.php?2005/03/01/16-ajax-and-accessibility

AJAXandAccessibility

www.xml.com/lpt/a/2005/05/11/ajax-error.html

ErrorsandAJAX

www.softwareas.com/ajax-patterns

AJAXPatterns:DesignPatternsforAJAXUsability

www.backbase.com/download/Whitepaper%20Backbase%20AJAX%20and%20Beyond.pdf

WhitepaperBackbaseAJAXandBeyond

www.ajaxpatterns.org/index.php?title=Main_Page

AJAXpatterns

www.onlamp.com/pub/a/onlamp/2005/05/19/xmlhttprequest.html

六、补充内容

在增加一个,有些基础教程,虽然不多，但是都蛮有用的!
http://www.sp1.cn/ajax/info/basic/index.htm 

Ajax & XMLHttpRequset
http://tech.acnow.net/Html/Web/ASP/ASP_Skill/2006-6/15/163322869.shtml

了解Ajax框架
http://kb.csdn.net/java/Articles/200606/0964add7-c017-484e-9652-5d85030222c5.html 

标题 实现无刷新闪烁二级联动下拉菜单
http://www.seaskyer.net/Index/Catalog11/266.html

标题 Ajax研究小结
http://www.seaskyer.net/Index/Catalog11/224.html
posted @ 2006-08-16 17:08 阿成 阅读(285) | 评论 (0) | 编辑 收藏
DWR让AJAX如此简单
首先了解一下什么时DWR（Direct Web Remoting ）

    DWR 是一个开放源码的使用 Apache 许可协议的解决方案，它包含服务器端 Java 库、一个 DWR servlet 以及 JavaScript 库。虽然 DWR 不是 Java 平台上唯一可用的 Ajax-RPC 工具包，但是它是最成熟的，而且提供了许多有用的功能。

    从最简单的角度来说，DWR 是一个引擎，可以把服务器端 Java 对象的方法公开给 JavaScript 代码。使用 DWR 可以有效地从应用程序代码中把 Ajax 的全部请求-响应循环消除掉。这意味着客户端代码再也不需要直接处理 XMLHttpRequest 对象或者服务器的响应。不再需要编写对象的序列化代码或者使用第三方工具才能把对象变成 XML。甚至不再需要编写 servlet 代码把 Ajax 请求调整成对 Java 域对象的调用。


    DWR 是作为 Web 应用程序中的 servlet 部署的。把它看作一个黑盒子，这个 servlet 有两个主要作用：首先，对于公开的每个类，DWR 动态地生成包含在 Web 页面中的 JavaScript。生成的 JavaScript 包含存根函数，代表 Java 类上的对应方法并在幕后执行 XMLHttpRequest。 这些请求被发送给 DWR，这时它的第二个作用就是把请求翻译成服务器端 Java 对象上的方法调用并把方法的返回值放在 servlet 响应中发送回客户端，编码成 JavaScript。DWR 还提供了帮助执行常见的用户界面任务的 JavaScript 工具函数。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
概述

这篇文章阐述了使用开源项目DWR(直接Web远程控制)和AJAX(异步JavaScript和XML)的概念来提高Web应用的可用性。作者一步步来展示DWR如何使得AJAX的应用既简单又快捷。（1600字;2005年6月20日）

AJAX， 或者说是异步JavaScript和XML，描述了一种使用混合了HTML(或XHTML)和层叠样式表作为表达信息,来创建交互式的Web应用的开发技 术;文档对象模型（DOM），JavaScript,动态地显示和与表达信息进行交互;并且，XMLHttpRequest对象与Web服务器异步地交换 和处理数据。

因特网上许多例子展示了在一个HTML文件内部使用XMLHttpRequest与服务器端进行交互的必要的步骤。当手工地 编写和维护XMLHttpRequest代码时，开发者必须处理许多潜在的问题，特别是类似于跨浏览器的DOM实现的兼容性这样的问题。这将会导致在编码 和调试Javascript代码上面花费数不清的时间，这显然对开发者来说很不友好。

DWR(直接Web远程控制)项目是在Apache 许可下的一个开源的解决方案，它供给那些想要以一种简单的方式使用AJAX和XMLHttpRequest的开发者。它具有一套Javascript功能 集，它们把从HTML页面调用应用服务器上的Java对象的方法简化了。它操控不同类型的参数，并同时保持了HTML代码的可读性。

DWR 不是对一个设计的插入，也不强迫对象使用任何种类的继承结构。它和servlet框架内的应用配合的很好。对缺少DHTML编程经验的开发者来说，DWR 也提供了一个JavaScript库包含了经常使用的DHTML任务，如组装表，用item填充select下拉框，改变HTML元素的内容，如< div>和<span>
DWR网站是详尽的并且有大量的文档，这也是这篇文章的基础。一些例子用来展示DWR如何使用和用它的库可以完成什么样的工作。

这篇文章让读者看到了一个使用了DWR的Web应用是如何一步步建立的。我会展示创建这个简单的示例应用的必要的细节，这个应用是可下载的并且可以在你的环境中布署来看看DWR如何工作。
注意：找到有关AJAX的信息并不困难;网页上有几篇文章和博客的条目涵盖了这个主题，每一个都试图指出和评论这个概念的不同的方面。在资源部分，你会找到一些有趣的指向示例和文章的链接，来学习AJAX的更多的内容。

示例应用
这篇文章使用的示例应用模拟了多伦多的一个公寓出租搜索引擎。用户可以在搜索前选择一组搜索标准。为了提高交互性，AJAX中以下两种情况下使用：
·应用通告用户配合他的选择会返回多少搜索结果。这个数字是实时更新的-使用AJAX-当用户选择的卧室和浴室的数量，或者价格范围变化时。当符合标准的搜索结果没有或太多时，用户就没有必要点击搜索按纽。
·数据库查询并取回结果是由AJAX完成的。当用户按下显示结果按钮时，数据库执行搜索。这样，应用看起来更具响应了，而整个页面不需要重载来显示结果。

数据库
我们使用的数据库是HSQL，它是一种占用资源很小的Java SQL数据库引擎，可以不需要安装和配置的与Web应用捆绑在一起。一个SQL文件被用来在Web应用的上下文启动时创建一个内存中的表并添加一些记录。

Java类
应 用包含了两个主要的类叫Apartment和ApartmentDAO。Apartment.java类是一个有着属性和getter/setter方法 的简单的Java类。ApartmentDAO.java是数据访问类，用来查询数据库并基于用户的搜索标准来返回信息。ApartmentDAO类的实 现的直接了当的;它直接使用了Java数据库联接调用来得到公寓的总数和符合用户请求的可用公寓的列表。

DWR配置和使用
设 置DWR的使用是简单的：将DWR的jar文件拷入Web应用的WEB-INF/lib目录中，在web.xml中增加一个servlet声明，并创建 DWR的配置文件。DWR的分发中需要使用一个单独的jar文件。你必须将DWR servlet加到应用的WEB-INF/web.xml中布署描述段中去。

    <servlet>
        <servlet-name>dwr-invoker</servlet-name>
        <display-name>DWR Servlet</display-name>
        <description>Direct Web Remoter Servlet</description>
        <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>true</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>dwr-invoker</servlet-name>
        <url-pattern>/dwr/*</url-pattern>
    </servlet-mapping>



一 个可选的步骤是设置DWR为调试模式—象上面的例子那样—在servlet描述段中将debug参数设为true。当DWR在调试模式时，你可以从 HTMl网页中看到所有的可访问的Java对象。包含了可用对象列表的网页会出现在/WEBAPP/dwr这个url上，它显示了对象的公共方法。所列方 法可以从页面中调用，允许你，第一次，运行服务器上的对象的方法。下图显示了调试页的样子:

image
调试页

现 在你必须让DWR知道通过XMLHttpRequest对象，什么对象将会接收请求。这个任务由叫做dwr.xml的配置文件来完成。在配置文件中，定义 了DWR允许你从网页中调用的对象。从设计上讲，DWR允许访问所有公布类的公共方法，但在我们的例子中，我们只允许访问几个方法。下面是我们示例的配置 文件:

<dwr>
    <allow>
        <convert converter="bean" match="dwr.sample.Apartment"/>
        <create creator="new" javascript="ApartmentDAO" class="dwr.sample.ApartmentDAO">
            <include method="findApartments"/>
            <include method="countApartments"/>
        </create>
    </allow>
</dwr>



上 面的文件实现了我们例子中的两个目标。首先，<convert>标记告诉DWR将dwr.sample.Apartment对象的类型转换为 联合数组，因为，出于安全的原因，DWR默认的不会转换普通bean。第二，<create>标记让DWR暴露出 dwr.sample.ApartmentDAO类给JavaScript调用;我们在页面中使用JavaScript文件被javascript属性定 义。我们必须注意<include>标记，它指明了dwr.sample.ApartmentDAO类的哪些方法可用。

HTML/JSP代码
配 置完成后，你就可以启动你的Web应用了，这时DWR会为从你的HTML或Java服务器端页面(JSP)上调用所需方法作好准备，并不需要你创建 JavaScript文件。在search.jsp文件中， 我们必须增加由DWR提供的JavaScript接口，还有DWR引擎，加入以下三行到我们的代码中：

  <script src='dwr/interface/ApartmentDAO.js'></script>
  <script src='dwr/engine.js'></script>
  <script src='dwr/util.js'></script>



我 们注意到当用户改变搜索标准时，这是AJAX在示例程序中的首次应用;正如他所看到的，当标准改变时，可用的公寓数量被更新了。我创建了两个 JavaScript函数：当某一个选择下拉框中的值变化时被调用。ApartmentDAO.countApartments()函数是最重要的部分。 最有趣的是第一个参数, loadTotal()函数，它指明了当接收到服务端的返回时DWR将会调用的JavaScript方法。loadTotal于是被调用来在HTML页面 的<div>中显示结果。下面是在这个交互场景中所使用到的JavaScript函数:

function updateTotal() {
    $("resultTable").style.display = 'none';
    var bedrooms = document.getElementById("bedrooms").value;
    var bathrooms = document.getElementById("bathrooms").value;
    var price = document.getElementById("price").value;
    ApartmentDAO.countApartments(loadTotal, bedrooms, bathrooms, price);
}

function loadTotal(data) {
    document.getElementById("totalRecords").innerHTML = data;
}



很明显，用户想看到符合他的搜索条件的公寓列表。那么，当用户对他的搜索标准感到满意，并且总数也是有效的话，他会按下显示结果的按纽，这将会调用updateResults() JavaScript方法：

function updateResults() {
    
    DWRUtil.removeAllRows("apartmentsbody");
    var bedrooms = document.getElementById("bedrooms").value;
    var bathrooms = document.getElementById("bathrooms").value;
    var price = document.getElementById("price").value;
    ApartmentDAO.findApartments(fillTable, bedrooms, bathrooms, price);
    $("resultTable").style.display = '';
}

function fillTable(apartment) {
    DWRUtil.addRows("apartmentsbody", apartment, [ getId, getAddress, getBedrooms, getBathrooms, getPrice ]);
}


updateResults ()方法清空了存放搜索返回结果的表域，从用户界面上获取所需参数，并且将这些参数传给DWR创建的ApartmentDAO对象。然后数据库查询将被执 行，fillTable()将会被调用，它解析了DWR返回的对象(apartment)，然后将其显示到页面中(apartmentsbody)。

安全因素
为 了保持示例的简要，ApartmentDAO类尽可能的保持简单，但这样的一个类通常有一组设置方法来操作数据，如insert(), update()和delete()。DWR暴露了所有公共方法给所有的HTML页面调用。出于安全的原因，像这样暴露你的数据访问层是不明智的。开发者 可以创建一个门面来集中所有JavaScript函数与底层业务组件之间的通信，这样就限制了过多暴露的功能。

结论
这 篇文章仅仅让你在你的项目中使用由DWR支持的AJAX开了个头。DWR让你集中注意力在如何提高你的应用的交互模型上面，消除了编写和调试 JavaScript代码的负担。使用AJAX最有趣的挑战是定义在哪里和如何提高可用性。DWR负责了操作Web页面与你的Java对象之间的通信，这 样就帮助你完全集中注意力在如何让你的应用的用户界面更加友好，
我想感谢Mircea Oancea和Marcos Pereira,他们阅读了这篇文章并给予了非常有价值的返匮。

资源
·javaworld.com:javaworld.com
·Matrix-Java开发者社区:http://www.matrix.org.cn/
·onjava.com:onjava.com
·下载示例程序的全部源码:http://www.javaworld.com/javaworld/jw-06-2005/dwr/jw-0620-dwr.war
·DWR: http://www.getahead.ltd.uk/dwr/index.html
·HSQL:http://hsqldb.sourceforge.net/
·AJAX的定义:http://en.wikipedia.org/wiki/AJAX
· “AJAX:通向Web应用的新途径": Jesse James Garrett (Adaptive Path, 2005.2): http://www.adaptivepath.com/publications/essays/archives/000385.php
· “非常动态的Web界面” Drew McLellan (xml.com, 2005.2): http://www.xml.com/pub/a/2005/02/09/xml-http-request.html
·XMLHttpRequest & AJAX 工作范例: http://www.fiftyfoureleven.com/resources/programming/xmlhttprequest/examples
· “可用的XMLHttpRequest实践” Thomas Baekdal (Baekdal.com, 2005.3): http://www.baekdal.com/articles/Usability/usable-XMLHttpRequest/
·"XMLHttpRequest 使用导引" Thomas Baekdal (Baekdal.com,  2005.2):http://www.baekdal.com/articles/Usability/XMLHttpRequest-guidelines/
·AJAX实质:http://www.ajaxmatters.com/
posted @ 2006-08-16 17:06 阿成 阅读(280) | 评论 (0) | 编辑 收藏
CSS中的“滑动门”技术

在CSS中，一个很少被提及的优点就是能够层叠背景图片，允许它们之间通过"滑动"和层叠来创造出特定的效果。CSS2目前的状况要求每个背景图片都分别有与之相对应的HTML元素。在通常情况下，组成通用界面的典型标记已经提供了一些我们可以使用的元素。

其 中的一个例子就是标签导航栏（tabbed navigation）。随着[标签导航]的使用率不断上升，它已逐渐成为了站点导航的主流方式，现在是时候来讨论一下对标签导航栏的控制了。既然CSS 被广泛地支持，我们就可以用它来优化站点标签的质地和外观。你很可能会想到，CSS可以驯服平坦的无序列表。可能你已经见到过一些样式化为标签的列表，比如下面这个：

如果我们采用与上面完全相同的标记，但却把它们变成了下面的样子，该如何去做呢：

在这里，仅仅用非常简单的样式就可以实现。

创新之道

我所见过的许多基于CSS的标签都受到了一些共同特性的限制：单色的矩形块，可能在当前标签上加了轮廓，或者边框；在鼠标掠过时改变矩形的颜色等等。这就是CSS能为我们提供的全部吗？仅仅是成堆的单色方块？

早 在CSS被广泛采用之前，我们就能够看到许多在导航设计上的创新。创新的外形，可控的色彩混合，以及对现实世界中物力表面的模仿。但是这些设计通常都依赖 于将文字内嵌于图片的复杂结构或多层的表格嵌套。编辑标签上的文字或者改变它们的顺序都会引起繁重的工作。文字的缩放更是不可能，不然就会引起严重的页面 布局错误。

单纯的文字导航要比嵌入文字的图片式导航更加易于管理并且加载更迅速。而且，虽然我们可以给每个图片都加上alt属性， 但是单纯的文字导航更具有可读性，因为对于视力不好读者，这些文字都是可缩放的。也正因为如此，由CSS样式化的文字的导航栏再次成为网页设计者们的选 择，并不足为奇。但是到目前为止，大多数基于CSS的标签设计，只是后退了一步，回到了我们曾经的做法--当然这些是无法被优秀的设计作品采用的。采用一 项新技术（比如CSS）应该能够让我们创作出一些更好的东西，而不至于失去先前的表格或者图片式标签所能表现的质地。

“滑动门”技术

只 要我们用两片分离的背景图片，就能够创造出精美的手工界面，并且具有高度的灵活性，可随文字的缩放而自动适应。试想一下，左右两幅图片，就像左右两扇滑动 门一样，构成了一扇完整的门。将这两扇门推近，重叠的部分多一些，就可以适应一个比较狭窄的空间，而如果将它们拉开，重叠的部分减少，就可以满足较宽的空 间，正如下图所示：

在 这个例子中，一幅图片盖住了另一幅的某些部分。假设每幅图片的边缘都有些独特的形状，例如标签的圆角，我们不希望这些边缘被它前方图片盖住。为了防止这种 情况发生，我们将放置在前方（以左边为例）的图片制作得尽可能地窄，但是保证它能够完整地显示出边缘上的独特形状。以圆角标签为例，我们将前方的图片制作 到仅与圆角的部分同宽即可：

如 果目标物由于不同文字或文字类型而变得比上图所示的宽度更大,那么这两幅图就会被拉开,出现一个非常不美观的缺口。 这时就需要我们对可能的扩展性进行预测。 在用户缩放字体的时候，目标物会增大多少？实际上，我们至少应该为文字的缩放而作出300%的可伸缩性准备。 我们需要将背景图扩大到足够弥补缺口。 对于这些例子，我们将把后面的图像 ( 右边) 制作为 400 x150 图素, 前面的图像制作为 9 x150 图素。

要记住，背景图片只能在它所应用的元素的“门前”出现 [内容区域+补丁区域(padding)]。 这两幅图被分别安放到他们所应用的元素外侧。 而这些背景的可见部分交叠在一起构成了一个完整的标签样式:

如果标签被扩大的话，这两幅图就分别向两侧滑动，每一幅都更多地被显示出来，以满足更宽的“门”的需求。

就 比如我用Photoshop制作了两幅平滑的，略带3D效果的个性化标签图片，正如文章开头的图片所示。在另一个色彩明亮一点的版本中，这两幅图片的填充 色变的更亮，边缘的阴影更暗，这是为“当前”标签准备的。为了给上面所述的技术作示范，我们需要扩展标签背景的覆盖区域，并把它切成了两片:

那个明亮一些的版本也需要这样做，一旦这些图片都作好了（1, 2, 3, 4），我们就可以进入CSS标记部分了。

创建标签

当发现了如何利用CSS创建横向列表后，你可能会注意到，至少有两种方法能够将一组列表排列成一行。一种是用内嵌方框，另一种是利用浮动属性。它们各有利弊。而且每一种方法都会遇到CSS中非常奇怪的方面，很容易让人迷惑。

第一种方法，也是最常用的方法，就是将列表的项目属性设置为“内嵌”，这种方法由于非常简便而具有相当的吸引力。然而，对于我们将要讨论的“滑动门”技术来说，这种内嵌的方法在某些特定的浏览器上会出现渲染问题。第二种方法，也是我们所要关注的，是利用“浮动”属性将列表项排成一横行。而浮动属性也会同样令人无所适从。它们那些看来不协调的行为并不遵从自然逻辑。尽管如此，处理多个浮动元素的基本认识以及将它们确实可靠地处理为可用元素的方法依然会取得另人惊奇的效果。

我 们会在一个浮动的容器中创建多个浮动的元素。这样做是为了使外部容器紧密围绕在内容元素的周围。利用这种方法，我们可以给标签后的空白加上背景。要切记， 在标签之后布局的元素，一定要在CSS中用clear属性重新定位它的位置。这样是为了防止浮动标签影响布局中的其他页面元素的位置。

那么，现在就让我们看看这些标记语言：

<div id="header">
<ul>
<li><a href="#">Home</a></li>
<li id="current"><a href="#">News</a></li>
<li><a href="#">Products</a></li>
<li><a href="#">About</a></li>
<li><a href="#">Contact</a></li>
</ul>
</div>

事实上，头部(#header)的层可能同时会包含网站的LOGO以及一个搜索框。在这个的例子中，我们会精简每个锚点（anchor）中的href值。显然，正常情况下这些值应该为锚点地址或者文件位置。

我 们最初的样式化就是让头部（#header）的层浮动。这样做是为了让这个作为容器的层能够真正地将它所容纳的那些浮动列表项包在内部。由于这个元素是浮 动的，我们需要给它标记为“100%”的宽度。再给它加上临时的黄色背景来确认这一父容器的伸缩能够正好填满标签的整个背景区域。同时设置默认文字的属 性，以保证容器内的文字看起来一致:

#header {
float:left;
width:100%;
background:yellow;
font-size:93%;
line-height:normal;
}

现在，我们将无序列表默认的内外补丁(padding)都设置为0，并将列表的项目符号去掉，给他们加上向左浮动的属性：

#header ul {
margin:0;
padding:0;
list-style:none;
}
#header li {
float:left;
margin:0;
padding:0;
}

我们将锚点的显示属性设置为“块(display:block;)”，这样在控制它们的时候就不必担心内嵌方框的问题了:

#header a {
display:block;
}

接下来，我们将右侧的图片添加到列表项的背景中（添加的部分用粗体显示）：

#header li {
float:left;
background:url("norm_right.gif")
no-repeat right top;
margin:0;
padding:0;
}

在加入左边的图片之前，我们先停下来看看到目前为止，效果一究竟是怎样的。

- - -

现在，我们就可以将在上方显示的左侧图片加入到锚点（内层元素）的背景中，与此同时，我们也加入了内补丁，将标签扩展，给文字与标签的边缘间添加一些空白：

#header a {
display:block;
background:url("norm_left.gif")
no-repeat left top;
padding:5px 15px;
}

这些变化出现在效果二中。 看，现在标签已经有了大体的形状。对于这一点，IE5/Mac的用户可能会感到奇怪了，“这是怎么了，为什么标签会堆叠着伸展地穿过整个屏幕？”别急，我 们很快就要帮你解决这些问题。那么现在，尽可能地跟着我们继续下去，如果手头有其他浏览器的话，暂时先换一个来继续往下看。IE5/Mac的问题一定会得 到很好的解决。

- - -

这时，普通的标签背景已经做好了，接下来，需要为“当前”标签加上背景。我们通过为当前标签内的锚点加上id=“current”来实现对它的定位。由于并不需要改变当前标签的其他设置，只需要更换背景，所以我们仅用以下的代码即可：

				#header #current {
background-image:url("norm_right_on.gif");
}
#header #current a {
background-image:url("norm_left_on.gif");
}

在标签的下方，我们想要有边框出现，但是如果用对父容器#header设置下边框的的方法，那么就无法消除当前标签的下边框。因此，我们用创建一幅新图片的方法来代替，这幅图片的底部包含了我们想要的边框，同时将图片的颜色设置为少许的梯度，就像下面这幅：

我们将这幅图片用于容器#header的背景（代替了我们刚才所用的黄色），并将它设置为底部对齐，给容器设置与之相应的背景色。同时，将body的内补丁移除，给列表ul的上，左，右侧，分别加上10像素的内补丁：

#header {
float:left;
width:100%;
background:#DAE0D2 url("bg.gif")
repeat-x bottom;
font-size:93%;
line-height:normal;
}
#header ul {
margin:0;
padding:10px 10px 0;
list-style:none;
}

要 完成标签导航栏，还需要将当前标签的下边框消除。你可能会想到，给其他标签加上与#header背景色完全相同的下边框，然后给当前标签加上一个白色的下 边框。然而，那些观察非常仔细的人还是会在这样的做法中发现些许破绽。我们用给锚点加上内补丁的方法来替代它，这样就可以创建出完美的方形边角了。在下面 经过放大的示意图中就可以看出区别：

为了实现这样的效果，我们为其他标签设置了4像素的内补丁，而当前标签的设置为5像素：

#header a {
display:block;
background:url("norm_left.gif")
no-repeat left top;
padding:5px 15px 4px;
}
#header #current a {
background-image:url("norm_left_on.gif");
padding-bottom:5px;
}

上面的代码保证了在效果三中下边框只出现在其他标签上，而不出现在当前标签上。

打磨完工

敏 锐的目光可能会发现，在上一效果图中，圆角标签的角落上仍然留有白色的色块。这些前方图片上的不透明的边角挡住了导航栏的背景。从理论上说，我们可以将这 些边角的背景修改为与导航栏背景色一致来达到看似透明的效果。但是我们的导航标签可能会改变高度，超过背景的范围，或者背景色出现更改。因此，不如直接将 前方背景的边角设置为透明，这样更为方便。如果圆角是抗锯齿的话，我们可以让它的边缘以背景色进行柔化。

现在边角透明了，可是右侧图片的一部分出现在左侧透明的边角后。为了抵消它，我们在项目列表的左侧加上与左侧图片相同大小的9像素的内补丁。由于项目列表加上了左内补丁，就需要在锚点的左侧减去一部分内补丁，以保证文字的居中(15px - 9px = 6px)：

#header li {
float:left;
background:url("right.gif")
no-repeat right top;
margin:0;
padding:0 0 0 9px;
}
#header a {
display:block;
background:url("left.gif")
no-repeat left top;
padding:5px 15px 4px 6px;
}

然而，并不能就这样把它放在那儿，因为左侧的图片由于刚才加上的9像素的内补丁而被推开了。既然左右两幅图片的内边缘已经相连了，我们就没必要非将左侧的图片保持在上方。因此，我们交换一下左右两幅图片，让他们应用到对方的元素上。当然，当前标签也需要这样做：

#header li {
float:left;
background:url("left.gif")
no-repeat left top;
margin:0;
padding:0 0 0 9px;
}
#header a, #header strong, #header span {
display:block;
background:url("right.gif")
no-repeat right top;
padding:5px 15px 4px 6px;
}
#header #current {
background-image:url("left_on.gif");
}
#header #current a {
background-image:url("right_on.gif");
padding-bottom:5px;
}

一旦这样做好了，就完成了效果四。 注意，为了使边角透明而做的这一系列调整使得每个标签的左侧都有一小部分不可点击。这一非活动区域是在文字之外的，所以并不是非常引人注目。并不是每个站 点都要求标签背景是透明的，如果不希望有这一小部分非活动区域的话，尽可以用纯色的背景和方角来代替透明和圆角。在我们的例子中，依然保持透明和圆角的效 果。

- - -

剩下的调整就很简单了，我们一并来完成：将标签字体设置为粗体，正常标签的字体颜色设置为棕色，当前标签颜色设置为深灰色，去掉下滑线，将鼠标悬浮时的字体颜色同样设置为深灰色。这些增加的变化在效果五中表现出来。

一致性的特例

在效果二之后，我们认识到，在IE5/Mac中，标签被扩大到与页面同宽，导致了他们垂直堆叠在下一个的上方，这并不是我们想要的效果。

在大多数浏览器中，浮动会引起收缩的效果-它会收缩到仅能容纳其所含元素的最小空间。如果浮动元素中包含的是图片，那么它会收缩到与图片大小相同，如果仅包含文字的话，它会收缩到与最长的不换行文字同宽。

而 在IE5/Mac中，当一个自动调整宽度的块级元素（block-level element）被插入到另一浮动元素中时，就会出现问题。其他浏览器依然会尽可能地收缩浮动元素，并不理会它所容纳的块级元素。但是IE5/Mac在这 种情况下并不收缩浮动元素，反而将浮动和块级元素扩展到最大的可用宽度。在这种情况下，我们需要将锚点也同时浮动，但是仅在IE5/Mac中这样做，以免 影响到其他浏览器。之后，我们就可以用反斜杠注释法（Commented Backslash Hack）来隐藏这些代码，使其仅在IE5/Mac下工作：

#header a {
float:left;
display:block;
background:url("right.gif")
no-repeat right top;
padding:5px 15px 4px 6px;
text-decoration:none;
font-weight:bold;
color:#765;
}
/* Commented Backslash Hack
hides rule from IE5-Mac \*/
#header a {float:none;}
/* End IE5-Mac hack */

这回，IE5/Mac浏览器应该显示我们所希望的效果了，见效果六。 在非IE5/Mac浏览器中，应该没有任何变化。注意，IE5.0/Mac中出现了很多渲染错误，在IE5.1中已得到更正。因此，在IE5.0中出现的 错误已经超出了我所应该作为特例而修改的范畴了。由于现在升级到5.1并不困难，而OS 9 Macs用户中仍然使用IE5.0的已经相当的少了。

适用性

我 们刚刚看过如何运用滑动门技术创建纯文本的导航标签,它们是由一系列锚点组成的无序列表标记而成,并赋予一些个性化的样式。它加载快速,易于维护,并且可 以在不破坏原有设计的同时对其文本进行大比例的缩放。那么这项技术足够灵活吗？可以胜任创建各种类型的精美导航栏的任务吗?

无需怀疑，这项技术的使用只局限于我们的想象力。最终效果只展示出了其中一种可能性。但是我们不应被一种设计局限了自己的想法.

例如,标签没必要非得对称。我很快就制作出这些标签的2.0版， 在这个版本中，并没有使用3D阴影效果,这样更利于展示平面色彩,有角的边缘，以及更宽,更细致的左边框。正如2.0版所示，我们甚至可以交换左右两幅图 片的位置，当然，这些均取决于你的设计。通过细致的计划和巧妙的图片处理,我们尽可以将下边框彻底放弃,这更有利于标签图片与背景的搭配,就如在我充满灵 感的3.0版中所表现的那样。如果你的浏览器支持在样式表间切换的话,你甚至可以看到这个主文件在三个不同的版本的样式间切换（注：Firefox和Opera支持样式切换）。

其 他我们没有讨论到的效果可以基于这项技术使用。在一路举来的这个例子中,我只改变了鼠标悬浮时的文字颜色，但除此之外你还可以将整个背景替换掉，以创造出 更为有趣的翻转效果。只要有两个嵌套的HTML元素标记，就可以利用CSS为他们加上背景，创造出我们甚至想都没想过的的效果。在这个例子中我制作了一个 水平的导航标签,但是滑动门技术在其他许多情况下都是可以使用的。

那么,你会用它做什么呢?

posted @ 2006-08-16 17:01 阿成 阅读(795) | 评论 (0) | 编辑 收藏
javaIO学习笔记

第一篇、http://www.blueidea.com/bbs/newsdetail.asp?id=996916（里面有很多例子）

第二篇、彻底明白Java的IO系统(文摘）---JAVA之精髓IO流
一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型：
1) input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以 字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。如 CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的 是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然 后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中， 再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和 FilterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写
3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
BufferedReader in =
new BufferedReader(
new FileReader("F:\\nepalon\\TestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "\n";
in.close();

//1b. 接收键盘的输入
BufferedReader stdin =
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

//3. 从内存取出格式化输入
try{
DataInputStream in3 =
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte());
}
catch(EOFException e){
System.out.println("End of stream");
}

//4. 输出到文件
try{
BufferedReader in4 =
new BufferedReader(
new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:\\nepalon\\ TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}

//5. 数据的存储和恢复
try{
DataOutputStream out2 =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:\\nepalon\\ Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("\nThas was pi:writeChars\n");
out2.writeBytes("Thas was pi:writeByte\n");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:\\nepalon\\ Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}

//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:\\nepalon\\ rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓存中的信息输出到文件中。
5 区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读 取到缓存中，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入第一个writeDouble()，所以为了正 确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。

第三篇、花1K内存实现高效I/O的RandomAccessFile类（http://www-128.ibm.com/developerworks/cn/java/l-javaio/index.html），解决RandomAccessFile类效率低下的问题，特别是“与JDK1.4新类MappedByteBuffer+RandomAccessFile的对比”部分讲了怎样用jdk自己的功能实现。

posted @ 2006-08-16 16:59 阿成 阅读(285) | 评论 (0) | 编辑 收藏
javascript学习笔记

一
1.网页技术分为三个方面：静态网页、网页美工、动态网页。
2.DHTML(动态HTML)是一种通过各种技术的综合而得以实现的概念，包括三部分：HTML、Script(JavaScrip or VBScript)、CSS(Cascading Style Sheets)。
3.颜色“#rrggbb”六位十六进制数。
4.js删除提示
1)<a  href="#" onclick="return(confirm('删除后无法恢复,您确定删除吗?'))">删除</a>
2)JS
<a  href="#" >删除</a>
<script language="javascript" type="text/javascript">
function delete_confirm(){
 if(event.srcElement.outerText=="删除" || event.srcElement.value=="删除")
  event.returnValue=confirm("删除后将不能恢复，您确认执行删除操作么？");
 }
 document.onclick=delete_confirm;
</script>

5.点击按钮/链接弹出提示
1）<input type=button value="reload" onclick="javascript:reload()">
<script type="text/javascript">
function reload() {
  if (confirm("确认?"))
 {
 var url="#";
 window.location.href=url;
 }
}
2）<a  href="确认后的连接地址" onclick="return(confirm('想要的提示信息?'))">显示信息</a>

6.返回主页/前页
返回前页：使用OnClick="history.go(-1)"
返回主页：使用OnClick='top.location.href="index.jsp"'
<a href="javascript:history.back()">后退</a>
<a href="javascript:history.go()">前进</a>
<a href="javascript:location.reload()">刷新</a>

7.定时关闭网页
在head区加入
<SCRIPT LANGUAGE="javascript">
setTimeout('window.close();',2000);
</SCRIPT>
表示两秒后自动关闭窗口。

8. 背景音乐
显示操作面板：
在相应地方加<embed src="aladdin.mid" width="140" height="35" autostart=true controls="middleconsole">
不显示操作面板：
在页中任意地方加<embed src="aladdin.mid" hidden=true autostart=true loop=true>
或<embed src="aladdin.mid" autostart="true" loop="2" width="80" height="30">

9. 如何让浏览器正确显示word 文件格式?
为了正确处理word 等格式，你需要在HTML文件中设置好该文件类型
<meta http-equiv="Content-Type" content="application/msword">
还有其它经常设置的文件类型：
application/msword Microsoft Word Document
application/pdf PDF Document
application/wordperfect6.0 WordPerfect 6.0 Document
application/zip ZIP archive
audio/x-wav WAV audio format
audio/midi MIDI audio format
audio/x-pn-realaudio RealAudio
image/gif GIF image format
image/jpeg JPEG image format
image/png PNG image format
text/html HTML document
text/plain Plain text
video/mpeg MPEG video format
video/quicktime QuickTime video format
video/x-msvideo AVI video format

10. 链接的不同方式
在帧里显示：在链接处加target="main"语句，其中main为帧名
整页显示：在链接处加target="_top"语句
开新窗口：在链接处加target="resource window"语句，如<A HREF="index.htm" TARGET="resource window"></A>

11. 强制主页每次都不进行缓存，而从服务器上重读
在Head部分加
<MEAT HTTP-EQUIV="Pragma" CONTENT="no-cache">
这样一来，浏览器将不考虑cacke中的内容而强制重新读入您的页面,等于用户使用Reload。

12. 自动刷新
定时刷新：<META HTTP-EQUIV="Refresh" content="10; URL=http://自己的URL">
幻灯片效果：语句类似上面，但在页面1中URL指向页面2，而页面2指向页面3 ...
页面n指回页面1，即可实现循环显示页面的效果

13.提前载入图片
如果您的站点中后面的页有大图形需要显示，您不妨在第一页中提前载入。把语句：
<img src="image.jpg" width=0 height=0> ,其中width,height要设置为0， 放在第一页HTML中的任何地方。
如果您的访问者在第一页停留的时间足够长，当他进入第二页时，图象会立即显示出来

14. 自动连接
在预定时间后自动连入另一个指定的页面。
方法：
在<title>...</title>中加入以下一行：
<meta http-equiv="refresh" content="10"; url="otherpage.htm">
其中10代表10秒后自动连接。

15. 移动文字
这在主页上是常用的，其制作方法很简单。
<marquee>要移动的文字</marquee>
  1.移动 的方向：<direction=!> ！=left, right
  2.移动的方式：<bihavior=!> !=scroll ,side,alternate
  3.循环次数：<loop=!> !=次数。若未指定则循环不止。
  4 循环速度：<scrollamount=!> !=数

16. 浮动背景（背景图像不滚动 ）
当你拉住下拉条时，背景不动。
<body backgroud="#ffff" bgproperties="fixed">
或用CSS样式表定义：
<style type="text/css">
<!--
body { background-image: url(image/bg.gif); background-attachment: fixed}
-->
</style>

17. 让背景图像不平铺的CSS样式表定义：
<style type="text/css">
<!--
body { background-image: url(image/bg.gif); background-repeat: no-repeat}
-->
</style>
（不懂）18. 测试浏览器类别并自动装入不同的网页
目前微软和网景的浏览器并不能完全兼容所有网页,有的在某种浏览器里非常漂亮,而用其它浏览器查看时却一团糟。如果你需要测试浏览器,可以加入以下javascript代码并保存单独一个网页:
<script language="javascript">
function TestBrowser(){
ie = ((navigator.appName ==
"Microsoft Internet Explorer") & &
(parseInt(navigator.appVersion) >= 3 ))
ns = ((navigator.appName == "Netscape") & &
(parseInt(navigator.appVersion) >= 3 ))
if (ns) {
setTimeout(''location.href="nn4.htm"'',10);
} else {
setTimeout(''location.href="ie4.htm"'',10);
}
}
</script>
19. 定义本网页的关键字
在网页中加入关键字，可以供某些搜索站台机器人的使用，它们会利用该关键字为你的网站做索引，这样，当别人用关键字搜索网站时，如果你的网页包含该关键字，那么就可以被列出了，定义本网页关键字，可以加入以下代码：
<meta name="keywords" content="html,dreamweaver,flash,css">
　 content 所包含的就是关键字，你可以自行设置。
　 这里有个技巧，你可以重复某一个单词，这样可以提高自己网站的排行位置，如:
<meta name="keywords" content="dreamweaver,dreamweaver,dreamweaver">
20. 在网页中加入E-mail链接并显示预定的主题
<a href="mailto:renyang@mail.taiji.com.cn?cc=renyangok@yahoo.com.cn&subject=hello&body=hello">
21. 隐藏在状态栏里出现的链接信息
当指向一个链接时，该链接的信息会出现在浏览器状态栏里，如果需要隐藏信息，可以如下设置：
<a href="http://www.yhyhw.com" onMouseOver="window.status='none';return true">test</a>
　　如果想要指向一个链接时，浏览器状态栏里出现特定的信息，把none 改成你需要的文字即可。
22.如何正确使用图片格式?
目前在网络上的图片准标准格式为JPG和GIF。当图片颜色数很多时，就选择JPG，它的压缩比高，而GIF适合颜色数少的图片。
23. 如何在网页上显示访问者系统信息?
把以下代码加入到<Body></Body>:
<script Language="javascript">
document.write(navigator.appVersion)
</script>
24. 如何点击一个链接同时在两个frame 内变化?
对于一个由topFrame、leftFrame、mainFrame 构成的页面，如果想在leftFrame 中点击链接，同时在其他两个frame 内变化，代码如下：
<a href="x1.htm" onclick="parent.topFrame.location.href=''x2.htm''" target="mainframe">
25. 打开一个新的浏览器窗口并设置窗口的属性
如果你需要在载入站点的同时,再打开另一个新窗口,加入以下代码即可:
<script language="javascript">
<!--
var gt = unescape('%3e');
var popup = null;
var over = "Launch Pop-up Navigator";
popup = window.open('', 'popupnav', 'width=160,height=160,resizable=1,
     status=yes,menubar=no,scrollbars=yes');
if (popup != null) {
     if (popup.opener == null) {
          popup.opener = self;
     }
    popup.location.href = 'pop.htm';}
//-->
</script>
期中pop.htm可以设置为你的htm文件,对于设置新窗口的属性,对照以下设置:
popup = window.open('', 'popupnav', 'width=200,height=170,resizable=1,scrollbars=auto');
width:宽,height:高,resizable:是否允许访客缩放新窗口,scrollbars:如果文本超过一屏,是否生成滚动条,status:是否显示状态栏,menubar:是否显示菜单,location:是否显示地址栏.
以上所有属性使用格式为:属性=yes或者no.而width和height两个属性为:width=#pixels,height=#pixels.
26. 打印按钮
<form>
<input name="Print" onClick="window.print();
return false" type="button" value="Print">
</form>
27. 查看源码按钮
<input type=button name="view" value="查看源码" onClick=''window.location="view-source:" +window.location.href'' style="font-size:9pt">
28. 如何去掉页面滚动条?
在body 中加入样式表控制，代码如下：
<body bgcolor="#000000" leftmargin="0" topmargin="0"
style="overflow-x: hidden; overflow-y: hidden; width: 100%">
29. 如何让站点自动跳转到另一页?
加入以下代码到HTML文件中即可：
<meta http-equiv="refresh" content="5;url=http://www.yhyhw.com/">
content中的"5"为停留的秒数，http://www.yhyhw.com/ 是将要跳转的页面。
30. 水平线、垂直线
插入HR很简单：<hr size="1">。如何让它垂直呢，更简单：<hr size="100" width="1">
31. 如何让下拉式菜单中的链接来打开一个新的窗口?
先把下拉式菜单设置好，如：
<form method="POST">
<select name="D1" size="1">
<option value="http://www.163.com/">网易</option>
<option value="http://www.suho.com/"＞搜狐</option></select>
<input type="submit" value="确定" name="B1"><input type="reset" value="重置"name="B2"></p></form>
然后把<select name="D1" size="1">改为
<select onChange="javascript:window.open(this.options[this.selectedIndex].value)">即可。
32. 如何让下拉式菜单中的链接来打开一个新的窗口?
先把下拉式菜单设置好，如：
<form method="POST">
<select name="D1" size="1">
<option value="http://www.163.com/">网易</option>
<option value="http://www.suho.com/"＞搜狐</option></select>
<input type="submit" value="确定" name="B1"><input type="reset" value="重置"name="B2"></p></form>
然后把<select name="D1" size="1">改为
<select onChange="javascript:window.open(this.options[this.selectedIndex].value)">即可。

34. 如何跳到页面的顶部?
当浏览者浏览到页面底部后，你需要提供一个单击，让浏览者方便的跳到页面顶部，加入以下代码：
<a href="#top">返回顶部</a>
35.如何让浏览器正确显示word文件格式?
为了正确处理word等格式，你需要在HTML文件中设置好该文件类型，比如：
<meta http-equiv="Content-Type" content="Application/msword">
还有其它经常设置的文件类型：
Application/msword Microsoft Word Document application/pdf PDF Documentapplication/wordperfect6.0 WordPerfect 6.0 Documentapplication/zip ZIP archiveaudio/x-wav WAV audio formataudio/midi MIDI audio formataudio/x-pn-realaudio RealAudioimage/gif GIF image formatimage/jpeg JPEG image formatimage/png PNG image formattext/html HTML documenttext/plain Plain textvideo/mpeg MPEG video formatvideo/quicktime QuickTime video formatvideo/x-msvideo AVI video format
36.如何在一个站点不同页面间播放同一种声文件?
大家 有这样的经验，当你访问一个站点首页时，会听到该页设置的背景声音文件，比如一段音乐。当你链接到该站点另一页时，音乐就停止了。如何让声音不断呢。其 实，你只需要建立一个上下框架结构的网页，把声音文件建立在下框架里，并把下框架的宽度设置为一个像素，而上框架里是页面内容，当访问者离开站点首页时， 因下框架内容未变，所以，声音不会间断。大家还要注意两点，第一，把框架的边框设置为0；第二，隐藏声音文件的播放界面，然后把上下两个框架的背景设置为 相同。
37.如何让所有页面共享同一个层叠样式表(CSS)?
在每一个页面的<HEAD></HEAD>部分中加入以下代码：
<link rel="stylesheet" Type="text/css" href="cnshell.css">
其中cnshell.css为共享的层叠样式表文件
38.如何为链接定制新窗口?
我们可以打开一个新的窗口来显示链接的内容，但如何定制这个新窗口呢。
只需要在标签<A>中加入onClick事件:
<a href="#" onClick="window.open('cnshell.htm','help','scrollbars=yes,
resizable=yes,width=500,height=40')">问答</a>
"#"表示单击链接"问答"后，当前窗口保持不变，cnshell.htm为单击链接"问答"后所打开新窗口装载的内容，而scrollbars=yes,resizable=yes,width=500,height=40为设置新窗口的大小等属性。
39. 如何在页面利用单击来关闭浏览窗口?
在<BODY></BODY>部分加入以下代码：
<a href="javascript:window.close()">关闭窗口</a>
40. 如何删除图片链接的蓝色边框?
如果我们设置了图片为一个链接，会发现图片四周出现了蓝色边框。要删除边框，需要在图片标签里加上border="0"。如：<img src="dog.jpg" border="0">
41. 如何清除页面中的框架结构?
在链接属性中加入target="_top" 如下设置：
<a href="http://www.yufeng21.com" target="_top">宇风多媒体</a>
当你单击了这个链接，页面所有框架被清除并以该链接内容替代。
42.直接跳转到下一页面
<meta http-equiv="Content-Type" content="text/html; charset=GBK"/>
后加入下面语句，表示跳转到Config.do
<meta http-equiv="refresh" content="0;url=Config.do" />
43. 如何创建一个下拉菜单?
我们在主页中常会用到下拉菜单，一般来说，它需要CGI程序支持。你也可以利用javascript编写一个。
<head>
<script LANGUAGE="javascript">function formHandler(){var URL = document.form.site.options[document.form.site.selectedIndex]
.value;window.location.href = URL;}
</script>
</head>
<body>
<form name="form"><select NAME="site" SIZE="1" onChange="formHandler()"><option value="请选择">请选择</option>＜option value="http://www.yufeng21.com/"＞分栏内容＜/option><option value="http://www.yufeng21.com/">分栏内容</option><option value="http://www.yufeng21.com/">分栏内容</option＞＜option value="mailtocnshell@163.net">给我写信</option></select></form>
</body>
44.如何建立一个站点的搜索引擎系统?
如果你的站点有许多内容，你希望访问者能很快找到他想要的信息。那么你需要建立一个搜索引擎。连接到网站网络特区http://netzone.swatou.com/personal/,单击"申请站点引擎"并填写申请表，再按照要求建立站点页面数据库即可。
45. 什么是目标窗口，它该如何设置?
目 标窗口是页面链接所指内容显示的窗口，也就是当你单击了页面某一个链接后，该链接所指的内容在那个窗口显示。大多数情况下，我们无需关心它，因为一般都是 在同一窗口显示。target是链接标签<a>的属性，它的作用就是指定目标窗口，target有以下几个值：
_self-将链接指向的内容装载到当前页的窗口或框架中
_top-完全取代当前页面的所有框架
_blank-为链接指向的内容打开一个新的窗口
_parent-把链接指向的内容装入当前页<FRAMESET>父窗口中
以上设置多用在框架结构的页面中。
46. 如何为所有链接指定同一目标窗口?
在框架网页结构中，我们需要指定链接所指向的内容显示在那个窗口中。如果你的链接大部分都指定到同一个窗口中，就可以在<HEAD></HEAD>部分中加入：<base target＝"窗口名">，你无需为每个链接再指定窗口了。
47. 尽量用table标签，这样可以避免<td>之间的干扰；<table>尽量设为<table width="100%" border="0" cellpadding="0" ellspacing="0">，一方面是不显示表格线，另一方面占满整个宽度，不会因为内容不够而宽度变窄；包含<table>的 <td>要设为<td valign="top">，不然内部table默认居中。
48.<table>中第一行表格的width控制各列宽度；每列第一个格的height控制各行高度。
49.如何把一行表单或图片都放于middle位置：要把每一个都用<td>隔开，每个<td>都要设valign="middle"。
50.<td></td>之间不要有空格或空行，即应该<td><img src="***"></td>这么写，否则图片上下会产生空白的一细条。
51.&nbsp;表示一个空格，这个空格占一个字符（对于字母）还是两个字符（对于汉字）是根据浏览器的（工具->Internet选项->语言）来决定的，是不确定的，所以中文开头只需要两个&nbsp;而不是四个&nbsp;。
52.在线播放:
下面两个视频，前一个是RM视频（.rm .rmvb），后一个是MP视频（.wmv .asf .avi）,为了不影响大家，都设置为手动播放，并将相关的代码及说明放在了视频的下面：
RM源代码：
<OBJECT classid=clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA class=OBJECT id=RAOCX width=352 height=288>
<PARAM NAME=SRC VALUE="http://www.cqie.cn/pub/iec.rm">
<PARAM NAME=CONSOLE VALUE="http://www.cqie.cn/pub/iec.rm">
<PARAM NAME=CONTROLS VALUE=imagewindow>
<PARAM NAME=AUTOSTART VALUE=0 >
</OBJECT>
<br>
<OBJECT classid=CLSID:CFCDAA03-8BE4-11CF-B84B-0020AFBBCCFA height=32 id="video" width=352>
<PARAM NAME=SRC VALUE="http://www.cqie.cn/pub/iec.rm">
<PARAM NAME=AUTOSTART VALUE=0>
<PARAM NAME=CONTROLS VALUE=controlpanel>
<PARAM NAME=CONSOLE VALUE="http://www.cqie.cn/pub/iec.rm">
</OBJECT>
说明：以后可以直接把以上代码放到网页中使用，需要修改的属性说明如下width=352 height=288　这是控制媒体高度和宽度的VALUE="http://www.cqie.cn/pub/iec.rm" 这是指定媒体文件URL地址的，如果安装了REALSERVER的话，可以用rtsp://www.cqie.cn/pub/iec.rm来进行流式播 放，看起来会更流畅，而且可拖动。AUTOSTART VALUE=0  这是控制是否自动播放的，你只要将value=1就可以自动播放了

MP源代码：
<object align=middle classid=CLSID:22d6f312-b0f6-11d0-94ab-0080c74c7e95 class=OBJECT id=MediaPlayer width=160 height=168 >
<PARAM NAME=AUTOSTART VALUE=0 >
<param name=ShowStatusBar value=-1>
<param name=Filename value=http://xiaoping.cqie.cn/wmv/jler.wmv>
<embed type=application/x-oleobject codebase=http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=5,1,52,701 flename=mp src="http://xiaoping.cqie.cn/wmv/jler.wmv" width=160 height=168>
</embed>
</object>

53.树状显示js代码
（要求：某行文本前面有一个加号的标签，一点击加号变成减号，同时该行展开它之下所属信息，以缩进形式呈现，再点击减号又变回加号、下面展开的文本收回，这应该怎么做？除了js方式有什么其他方式实现么？谢谢！）
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<script language="javascript">
function showLay(divId){
        var objDiv = eval(divId);
        if (objDiv.style.display=="none"){
                eval("sp"+divId+".innerHTML='-'");
                objDiv.style.display="";
        }else{
                eval("sp"+divId+".innerHTML='+'");
                objDiv.style.display="none";
        }}
</script>
</head>
<body>
<a href="#" onclick="showLay('Layer1')"><span id="spLayer1">+</span>a</a><br>
<div id="Layer1" style="display:none;">
|-<a href="insert_unit_info.html" target="body">a1</a><br>
|-<a href="select_unit_info.jsp" target="body">a2</a><br>
</div>
<a href="#" onclick="showLay('Layer2')"><span id="spLayer2">+</span>b</a><BR>
<div id="Layer2" style="display:none;">
|-<a href="insert_item_info.html" target="body">b1</a><br>
|-<a href="select_item_info.jsp" target="body">b2</a><br>
</div>
<a href="#" onclick="showLay('Layer3')"><span id="spLayer3">+</span>c</a><BR>
<div id="Layer3" style="display:none;">
|-<a href="insert_expert_info.html" target="body">c1</a><br>
|-<a href="select_expert_info.jsp" target="body">c2</a><br>
</div>
<a href="#" onclick="showLay('Layer4')"><span id="spLayer4">+</span>d</a><BR>
<div id="Layer4" style="display:none;">
|-d1<br>
|-d2<br>
</div>
</body>
</html>

54.下拉菜单（新建个.html文件，把代码考进去就行）
<html>
<head>
<title>打造下拉菜单</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<script language="javascript">
function MM_reloadPage(init) {  //reloads the window if Nav4 resized
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
    document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
  else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}
MM_reloadPage(true);
function MM_findObj(n, d) { //v4.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && document.getElementById) x=document.getElementById(n); return x;
}
function MM_showHideLayers() { //v3.0
  var i,p,v,obj,args=MM_showHideLayers.arguments;
  for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
    if (obj.style) { obj=obj.style; v=(v=='show')?'visible':(v='hide')?'hidden':v; }
    obj.visibility=v; }
}
</script>
</head>
<body bgcolor="#CCCCCC" text="#000000" leftmargin="0" topmargin="0" marginwidth="0" marginheight="0" scroll=auto>
<div id="title" style="position:absolute; left:8px; top:15px; width:240px; height:15px; z-index:1; background-color: #006699;
layer-background-color: #006699; border: 1px none #000000">
  <table width="480" cellspacing="0" cellpadding="2">
    <tr>
      <td width="120" onMouseOver="MM_showHideLayers('menu1','','show')" onMouseOut="MM_showHideLayers
('menu1','','hide')"><b><font color="#FFFFFF"><a href="#">■
        经典论坛</a></font></b> </td>
    </tr>
  </table>
</div>
<div id="menu1" style="position:absolute; left:8px; top:34px; width:120px; height:80px; z-index:2; background-color: #999966;
layer-background-color: #999966; border: 1px none #000000; visibility: hidden" onMouseOver="MM_showHideLayers
('menu1','','show')" onMouseOut="MM_showHideLayers('menu1','','hide')">
  <table width="100%" cellspacing="0" cellpadding="2" height="80">
    <tr>
      <td>&nbsp;<a href="#">Dreamweaver 专栏</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Fireworks 专栏</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Flash 基本操作</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Flash 5 Action</a></td>
    </tr>
  </table>
</div>
</body>
</html>

55.防止下载网页信息（例如显示受控文件）的简单方法：
a。屏蔽鼠标左右键，<body oncontextmenu=self.event.returnValue=false onselectstart="return false">
b。加密网页源文件，推荐Batch Html Encryptor加密软件。
c.用Adobe Acrobat 6.0 Standard软件加密。
 
55。此方法显示下拉框默认值
<select name="max">
 <option value="1">第一名</option>
 <option value="2">第二名</option>
 <option value="3">第三名</option>
</select>
<script>document.all("max").value="3"</script>

56.用javascript设置输入框焦点
<html>
<head>
<script language="javascript">
function t() {
document.getElementById('aa').focus(); 
}                           <!--设置id为aa的元素得到焦点-->
</script>
</head>
<body onload="javascript:t()">
<input type="text" id="aa"> <!--设置文本输入框的id为aa-->
</body>
</html>

57.select标签下的OPTION标签没有value属性时，把内容当属性传过去，比如<OPTION>所有用户</OPTION>传的值就是所有用户，建议用以下方法。
<select name="account.accountId" >
    <OPTION value="">所有日志</OPTION>
    <OPTION value="renyang">任杨</OPTION>
</select>

58.不保留缓存方法：
<%
response.setHeader("Pragma", "No-cache");
response.setHeader("Cache-Control", "no-cache");
response.setHeader("Cache-Control", "must-revalidate");
response.setDateHeader("Expires",0);
%>

59.全选、全不选js方法 （直接放在.htm文件中即可）
<SCRIPT language="javascript">
function checkAll(e, itemName)
{
  var aa = document.getElementsByName(itemName);
  for (var i=0; i<aa.length; i++)
   aa[i].checked = e.checked;
}
function check(e, allName)
{
  var all = document.getElementsByName(allName)[0];
  if(!e.checked) all.checked = false;
  else
  {
    var aa = document.getElementsByName(e.name);
    for (var i=0; i<aa.length; i++)
     if(!aa[i].checked) return;
    all.checked = true;
  }
}
</SCRIPT>
<input type=checkbox name=allPersons id=allPersons onclick="checkAll(this, 'persons')">&nbsp;<label for="allPersons">全选</label><br>
<input type="checkbox" name="persons" id=persons value="1">&nbsp;<label for="persons">第一名</label><br>
<input type="checkbox" name="persons" id=persons value="2">&nbsp;<label for="persons">第二名</label><br>
<!-- 问题：第一名和第二名这两个字ID不能一样，否则点第二名这三个字时第一名前的框变化 -->
posted @ 2006-08-16 16:42 阿成 阅读(1113) | 评论 (0) | 编辑 收藏
查询字符串是否含有汉字（是否含有gb2312格式的字符）
//对于gb2312来讲, 首字节码位从0×81 至0×FE，尾字节码位分别是0×40 至0×FE
//本例是验证此串是否含有gb2312格式的字符，即是否含有汉字
public class Test{
  public boolean isGB2312( String str )
  {
    char[] chars = str.toCharArray();
    boolean isGB2312 = false;
    for ( int i = 0; i < chars.length; i++ )
    {
      byte[] bytes = ( "" + chars[i] ).getBytes();
      if ( bytes.length == 2 )
      {
        int[] ints = new int[2];
        ints[0] = bytes[0] & 0xff;
        ints[1] = bytes[1] & 0xff;
        if ( ints[0] >= 0x81 && ints[0] <= 0xFE && ints[1] >= 0x40 && ints[1] <= 0xFE )
        {
          isGB2312 = true;
          break;
        }
      }
    }
    return isGB2312;
  }
 
  public static void main(String[] args)
  {
    String s = "ss您好ss";//结果为true
    String s = "ssssss";//结果为false
    Test test = new Test();
    System.out.println(test.isGB2312(s));
  }
}
posted @ 2006-08-16 16:38 阿成 阅读(469) | 评论 (0) | 编辑 收藏
各种排序算法java实现

插入排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;
/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class InsertSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }       
    }

}
冒泡排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class BubbleSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for(int i=0;i<data.length;i++){
            for(int j=data.length-1;j>i;j--){
                if(data[j]<data[j-1]){
                    SortUtil.swap(data,j,j-1);
                }
            }
        }
    }

}

选择排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SelectionSort implements SortUtil.Sort {

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int temp;
        for (int i = 0; i < data.length; i++) {
            int lowIndex = i;
            for (int j = data.length - 1; j > i; j--) {
                if (data[j] < data[lowIndex]) {
                    lowIndex = j;
                }
            }
            SortUtil.swap(data,i,lowIndex);
        }
    }

}

Shell排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ShellSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        for(int i=data.length/2;i>2;i/=2){
            for(int j=0;j<i;j++){
                insertSort(data,j,i);
            }
        }
        insertSort(data,0,1);
    }

    /**
     * @param data
     * @param j
     * @param i
     */
    private void insertSort(int[] data, int start, int inc) {
        int temp;
        for(int i=start+inc;i<data.length;i+=inc){
            for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                SortUtil.swap(data,j,j-inc);
            }
        }
    }

}

快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class QuickSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        quickSort(data,0,data.length-1);       
    }
    private void quickSort(int[] data,int i,int j){
        int pivotIndex=(i+j)/2;
        //swap
        SortUtil.swap(data,pivotIndex,j);
       
        int k=partition(data,i-1,j,data[j]);
        SortUtil.swap(data,k,j);
        if((k-i)>1) quickSort(data,i,k-1);
        if((j-k)>1) quickSort(data,k+1,j);
       
    }
    /**
     * @param data
     * @param i
     * @param j
     * @return
     */
    private int partition(int[] data, int l, int r,int pivot) {
        do{
           while(data[++l]<pivot);
           while((r!=0)&&data[--r]>pivot);
           SortUtil.swap(data,l,r);
        }
        while(l<r);
        SortUtil.swap(data,l,r);       
        return l;
    }

}
改进后的快速排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedQuickSort implements SortUtil.Sort {

    private static int MAX_STACK_SIZE=4096;
    private static int THRESHOLD=10;
    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] stack=new int[MAX_STACK_SIZE];
       
        int top=-1;
        int pivot;
        int pivotIndex,l,r;
       
        stack[++top]=0;
        stack[++top]=data.length-1;
       
        while(top>0){
            int j=stack[top--];
            int i=stack[top--];
           
            pivotIndex=(i+j)/2;
            pivot=data[pivotIndex];
           
            SortUtil.swap(data,pivotIndex,j);
           
            //partition
            l=i-1;
            r=j;
            do{
                while(data[++l]<pivot);
                while((r!=0)&&(data[--r]>pivot));
                SortUtil.swap(data,l,r);
            }
            while(l<r);
            SortUtil.swap(data,l,r);
            SortUtil.swap(data,l,j);
           
            if((l-i)>THRESHOLD){
                stack[++top]=i;
                stack[++top]=l-1;
            }
            if((j-l)>THRESHOLD){
                stack[++top]=l+1;
                stack[++top]=j;
            }
           
        }
        //new InsertSort().sort(data);
        insertSort(data);
    }
    /**
     * @param data
     */
    private void insertSort(int[] data) {
        int temp;
        for(int i=1;i<data.length;i++){
            for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                SortUtil.swap(data,j,j-1);
            }
        }      
    }

}

归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class MergeSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }
   
    private void mergeSort(int[] data,int[] temp,int l,int r){
        int mid=(l+r)/2;
        if(l==r) return ;
        mergeSort(data,temp,l,mid);
        mergeSort(data,temp,mid+1,r);
        for(int i=l;i<=r;i++){
            temp[i]=data[i];
        }
        int i1=l;
        int i2=mid+1;
        for(int cur=l;cur<=r;cur++){
            if(i1==mid+1)
                data[cur]=temp[i2++];
            else if(i2>r)
                data[cur]=temp[i1++];
            else if(temp[i1]<temp[i2])
                data[cur]=temp[i1++];
            else
                data[cur]=temp[i2++];           
        }
    }

}

改进后的归并排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class ImprovedMergeSort implements SortUtil.Sort {

    private static final int THRESHOLD = 10;

    /*
     * (non-Javadoc)
     *
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        int[] temp=new int[data.length];
        mergeSort(data,temp,0,data.length-1);
    }

    private void mergeSort(int[] data, int[] temp, int l, int r) {
        int i, j, k;
        int mid = (l + r) / 2;
        if (l == r)
            return;
        if ((mid - l) >= THRESHOLD)
            mergeSort(data, temp, l, mid);
        else
            insertSort(data, l, mid - l + 1);
        if ((r - mid) > THRESHOLD)
            mergeSort(data, temp, mid + 1, r);
        else
            insertSort(data, mid + 1, r - mid);

        for (i = l; i <= mid; i++) {
            temp[i] = data[i];
        }
        for (j = 1; j <= r - mid; j++) {
            temp[r - j + 1] = data[j + mid];
        }
        int a = temp[l];
        int b = temp[r];
        for (i = l, j = r, k = l; k <= r; k++) {
            if (a < b) {
                data[k] = temp[i++];
                a = temp[i];
            } else {
                data[k] = temp[j--];
                b = temp[j];
            }
        }
    }

    /**
     * @param data
     * @param l
     * @param i
     */
    private void insertSort(int[] data, int start, int len) {
        for(int i=start+1;i<start+len;i++){
            for(int j=i;(j>start) && data[j]<data[j-1];j--){
                SortUtil.swap(data,j,j-1);
            }
        }
    }

}
堆排序:

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class HeapSort implements SortUtil.Sort{

    /* (non-Javadoc)
     * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
     */
    public void sort(int[] data) {
        MaxHeap h=new MaxHeap();
        h.init(data);
        for(int i=0;i<data.length;i++)
            h.remove();
        System.arraycopy(h.queue,1,data,0,data.length);
    }


     private static class MaxHeap{
        
       
        void init(int[] data){
            this.queue=new int[data.length+1];
            for(int i=0;i<data.length;i++){
                queue[++size]=data[i];
                fixUp(size);
            }
        }
        
        private int size=0;

        private int[] queue;
               
        public int get() {
            return queue[1];
        }

        public void remove() {
            SortUtil.swap(queue,1,size--);
            fixDown(1);
        }
        //fixdown
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size) {
                if (j < size && queue[j]<queue[j+1])
                    j++;
                if (queue[k]>queue[j]) //不用交换
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j]>queue[k])
                    break;
                SortUtil.swap(queue,j,k);
                k = j;
            }
        }

    }

}

 

SortUtil:

package org.rut.util.algorithm;

import org.rut.util.algorithm.support.BubbleSort;
import org.rut.util.algorithm.support.HeapSort;
import org.rut.util.algorithm.support.ImprovedMergeSort;
import org.rut.util.algorithm.support.ImprovedQuickSort;
import org.rut.util.algorithm.support.InsertSort;
import org.rut.util.algorithm.support.MergeSort;
import org.rut.util.algorithm.support.QuickSort;
import org.rut.util.algorithm.support.SelectionSort;
import org.rut.util.algorithm.support.ShellSort;

/**
 * @author treeroot
 * @since 2006-2-2
 * @version 1.0
 */
public class SortUtil {
    public final static int INSERT = 1;

    public final static int BUBBLE = 2;

    public final static int SELECTION = 3;

    public final static int SHELL = 4;

    public final static int QUICK = 5;

    public final static int IMPROVED_QUICK = 6;

    public final static int MERGE = 7;

    public final static int IMPROVED_MERGE = 8;

    public final static int HEAP = 9;

    public static void sort(int[] data) {
        sort(data, IMPROVED_QUICK);
    }
    private static String[] name={
            "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
    };
   
    private static Sort[] impl=new Sort[]{
            new InsertSort(),
            new BubbleSort(),
            new SelectionSort(),
            new ShellSort(),
            new QuickSort(),
            new ImprovedQuickSort(),
            new MergeSort(),
            new ImprovedMergeSort(),
            new HeapSort()
    };

    public static String toString(int algorithm){
        return name[algorithm-1];
    }
   
    public static void sort(int[] data, int algorithm) {
        impl[algorithm-1].sort(data);
    }

    public static interface Sort {
        public void sort(int[] data);
    }

    public static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}
posted @ 2006-08-16 16:06 阿成 阅读(297) | 评论 (0) | 编辑 收藏
Hibernate学习笔记
一、一对多映射
1、在映射一对多的双相关联关系时，应该在one方把inverse属性设为true，可以提高应用的性能。
2、建立两个对象的双向关联时，应该同时修改关联两端的对象的应用属性，这样使程序更加健壮，提高业务逻辑层的独立性，使业务逻辑层的程序代码不受hibernate实现的影响；同理，当解除双相关联关系时，也应该修改关联两端的对象的相应属性。
eg://添加
customer.getOrders().add(order);
order.setCustomer(customer);
//删除
customer.getOrders().remove(order);
order.setCustomer(null);
3、在定义一对多映射中“一”的POJO类时，注意要private Set orders = new HashSet();//通常把它初始化为集合实现类的一个实例，这样避免访问取值为null，引发NullPointerException异常，提高健壮性。
二、Session三种检索方法：
1.load():根据给定OID从数据库中加载一个持久化对象，如数据库中没有则抛出net.sf.hibernate.ObjectNotFoundException异常。
2.get():根据给定OID从数据库中加载一个持久化对象，如数据库中没有则返回null。
3.find():按照参数指定的HQL语句加载一个或多个持久化对象，实际是HQL检索方式的一种简写形式。
三、hql查询：
在数组和Collection中的查询：
String hql = "select  u from User u where u in (:users)";
query.setParameterList("users", users);
//括号千万别忘写，否则出现如下错误：
2006-07-07 11:07:35 WARN [org.hibernate.util.JDBCExceptionReporter] - SQL Error: 907, SQLState: 42000
2006-07-07 11:07:35 ERROR [org.hibernate.util.JDBCExceptionReporter] - ORA-00907: 缺失右括号
posted @ 2006-08-16 15:37 阿成 阅读(416) | 评论 (0) | 编辑 收藏
JAVA&J2EE FAQ

Java FAQ
 
目录：
Q1.1 什么是Java、Java2、JDK？JDK后面的1.3、1.4版本号又是怎么回事？
Q1.2 什么是JRE/J2RE？
Q1.3 学习Java用什么工具比较好？
Q1.4  学习Java有哪些好的参考书？
Q1.5  Java和C++哪个更好？
Q1.6  什么是J2SE/J2EE/J2ME？
Q2.1  我写了第一个Java程序，应该如何编译/运行？
Q2.2  我照你说的做了，但是出现什么“'javac' 不是内部或外部命令，也不是可运行的
程序或批处理文件。”。
Q2.3  环境变量怎么设置？
Q2.4  我在javac xxx.java的时候显示什么“unreported exception java.io.IOExcepti
on;”。
Q2.5  javac xxx.java顺利通过了，但是java xxx的时候显示什么“NoClassDefFoundErr
or”。
Q2.6  我在java xxx的时候显示“Exception in thread "main" java.lang.NoSuchMetho
dError: main”。
Q2.7  在java xxx的时候显示“Exception in thread "main" java.lang.NullPointerEx
ception”。
Q2.8 package是什么意思？怎么用？
Q2.9 我没有声明任何package会怎么样？
Q2.10 在一个类中怎么使用其他类？
Q2.11 我用了package的时候显示"NoClassDefFoundError"，但是我把所有package去掉的
时候能正常运行。
Q2.12 我想把java编译成exe文件，该怎么做？
Q2.13 我在编译的时候遇到什么"deprecated API"，是什么意思？
Q3.1 我怎么给java程序加启动参数，就像dir /p/w那样？
Q3.2 我怎么从键盘输入一个int/double/字符串？
Q3.3 我怎么输出一个int/double/字符串？
Q3.4 我发现有些书上直接用System.in输入，比你要简单得多。
Q3.5 我怎么从文件输入一个int/double/字符串？
Q3.6 我想读写文件的指定位置，该怎么办？
Q3.7 怎么判断要读的文件已经到了尽头？
Q4.1  java里面怎么定义宏？
Q4.2  java里面没法用const。
Q4.3  java里面也不能用goto。
Q4.4  java里面能不能重载操作符？
Q4.5  我new了一个对象，但是没法delete掉它。
Q4.6  我想知道为什么main方法必须被声明为public static？为什么在main方法中不能调
用非static成员？
Q4.7  throw和throws有什么不同？
Q4.8  什么是异常？
Q4.9  final和finally有什么不同？
Q5.1  extends和implements有什么不同？
Q5.2  java怎么实现多继承？
Q5.3 abstract是什么？
Q5.4 public,protected,private有什么不同？
Q5.5 Override和Overload有什么不同？
Q5.6 我继承了一个方法，但现在我想调用在父类中定义的方法。
Q5.7 我想在子类的构造方法中调用父类的构造方法，该怎么办？
Q5.8 我在同一个类中定义了好几个构造方法并且想在一个构造方法中调用另一个。
Q5.9 我没有定义构造方法会怎么样？
Q5.10 我调用无参数的构造方法失败了。
Q5.11 我该怎么定义类似于C++中的析构方法（destructor）？
Q5.12 我想将一个父类对象转换成一个子类对象该怎么做？
Q5.13 其实我不确定a是不是B的实例，能不能分情况处理？
Q5.14 我在方法里修改了一个对象的值，但是退出方法后我发现这个对象的值没变！
Q6.1 java能动态分配数组吗？
Q6.2 我怎么知道数组的长度？
Q6.3 我还想让数组的长度能自动改变，能够增加/删除元素。
Q     什么是链表？为什么要有ArrayList和LinkedList两种List？
Q6.5 我想用队列/栈。
Q6.6 我希望不要有重复的元素。
Q6.7 我想遍历集合/Map。
Q6.8 我还要能够排序。
Q6.9 但是我想给数组排序。
Q6.10 我想按不同方式排序。
Q6.11 Map有什么用？
Q6.12 set方法没问题，但是get方法返回的是Object。
Q6.13 ArrayList和Vector有什么不同？HashMap和Hashtable有什么不同？
Q6.14 我要获得一个随机数。
Q6.15 我比较两个String总是false，但是它们明明都是"abc" ！
Q6.16 我想修改一个String但是在String类中没找到编辑方法。
Q6.17 我想处理日期/时间。

一、准备篇

Q1.1 什么是Java、Java2、JDK？JDK后面的1.3、1.4版本号又是怎么回事？
答：Java是一种通用的，并发的，强类型的，面向对象的编程语言（摘自Java规范第二版
）。
JDK是Sun公司分发的免费Java开发工具包，正式名称为J2SDK(Java2 Software Develop K
it)。
包括基本的java工具包和标准类库。
到目前(2003年7月)为止，Java有3个主要版本，即1.0，1.1，2.0；
JDK有1.0，1.1，1.2，1.3，1.4五个版本。
从JDK1.2起，Sun公司觉得Java改变足够大而将java语言版本号提升为2.0。
不同的JDK主要在于提供的类库不同。作为学习你可以下载最新的JDK1.4.2。
真正开发时则应考虑向前兼容，比如1.3。下载请去http://java.sun.com。
JDK1.5预计将在2004年推出，届时其中将包含若干崭新的特性。

Q1.2 什么是JRE/J2RE？
答：J2RE是Java2 Runtime Environment，即Java运行环境，有时简称JRE。
如果你只需要运行Java程序或Applet，下载并安装它即可。
如果你要自行开发Java软件，请下载JDK。在JDK中附带有JRE。
注意由于Microsoft对Java的支持不完全，请不要使用IE自带的虚拟机来运行Applet，务必
安装一个JRE或JDK。

Q1.3 学习Java用什么工具比较好？
答：作者建议首先使用JDK+文本编辑器，这有助你理解下列几个基础概念：path，classp
ath，package
并熟悉基本命令：javac和java。并且下载和你的JDK版本一致的API帮助。
如果你不确定类或函数的用法，请先查阅API而不是发贴求助。
当你熟悉Java之后，你可以考虑开始使用一个IDE。
作者推荐eclipse，下载网址http://www.eclipse.org。因为eclispe是免费的，插件化的
。
eclispe的主要缺点是缺乏一个可视化的桌面程序开发工具，
幸运的是IBM在2003年11月已经将部分代码捐给eclipse组织，可以预计这个缺点很快就会
得到弥补。
无论如何，请不要使用Microsoft的VJ++！众所周知Microsoft从来就没有认真支持过Java
。
最后但并非最不重要，要有一本好的参考书，并且英文要过关。

Q1.4  学习Java有哪些好的参考书？
答：作者首先推荐Thinking in Java，中文名《Java编程思想》，有中文版。
目前的最新版本是第三版。
在http://64.78.49.204可以免费下载英文版。
该书第一章介绍了很多面向对象的编程思想，作为新手应当认真阅读。
除此以外，O'relly出版社和Wrox出版社的书也不错。作者本人不喜欢大陆作者的书。
也许你觉得英文太难，但是网上大多数资料都是英文的。另外，你需要经常查阅API，而那
也是英文的。

Q1.5  Java和C++哪个更好？
答：这个问题是一个很不恰当的问题。你应该问：Java和C++哪个更适用于我的项目？
Java的优点和缺点一样明显。
跨平台是Java的主要优点，但代价是运行速度的下降。
VC和Windows平台有良好的集成和足够快的速度，但是也只能局限在Windows平台上。
和C++相比，Java学起来更快，开发人员不会碰到很多容易出错的特性。
但是VB程序员甚至只需要拼装模块就可以了。

Q1.6  什么是J2SE/J2EE/J2ME？
答：J2SE就是一般的Java。
J2ME是针对嵌入式设备的，比如支持Java的手机，它有自己的JRE和SDK。
J2EE是一组用于企业级程序开发的规范和类库，它使用J2SE的JRE。

二、命令篇

Q2.1  我写了第一个Java程序，应该如何编译/运行？
答：首先请将程序保存为xxx.java文件，注意你可能需要修改文件后缀名。
然后在dos窗口下使用javac xxx.java命令，你会发现该目录下多了一个xxx.class文件，

再使用java xxx命令，你的java程序就开始运行了。

Q2.2  我照你说的做了，但是出现什么“'javac' 不是内部或外部命令，也不是可运行的
程序或批处理文件。”。
答：你遇到了path问题。操作系统在一定的范围(path)内搜索javac.exe，但是没能找到。

请编辑你的操作系统环境变量，新增一个JAVA_HOME变量，设为你JDK的安装目录，
再编辑Path变量，加上一项 %JAVA_HOME%\bin。
然后保存并新开一个dos窗口，你就可以使用javac和java命令了。

Q2.3  环境变量怎么设置？
答：请向身边会设的人咨询。

Q2.4  我在javac xxx.java的时候显示什么“unreported exception java.io.IOExcepti
on;”。
答：参见Q4.8以了解java中的异常机制。

Q2.5  javac xxx.java顺利通过了，但是java xxx的时候显示什么“NoClassDefFoundErr
or”。
答：1. 你遇到了classpath问题。java命令在一定的范围(classpath)内搜索你直接或间接
使用的class文件，但是未能找到。
首先请确认你没有错敲成java xxx.class，
其次，检查你的CLASSPATH环境变量，其实你并不需要设置该变量，
但如果你设置了该变量又没有包含.（代表当前目录）的项，
你就会遇到这个问题。请在你的CLASSPATH环境变量中加入一项. 或干脆删掉这个变量。

2. 如果你使用了并非JDK自带的标准包，比如javax.servlet.*包，也会遇到这个问题，请
将相应的jar文件加入classpath。
3. 如果你在java源文件中定义了package，请参见Q2.11。


Q2.6  我在java xxx的时候显示“Exception in thread "main" java.lang.NoSuchMetho
dError: main”。
答：首先，在你的程序中每个java文件有且只能有一个public类，
这个类的类名必须和文件名的大小写完全一样。
其次，在你要运行的类中有且只能有一个public static void main(String[] args)方法
，
这个方法就是你的主程序。


Q2.7  在java xxx的时候显示“Exception in thread "main" java.lang.NullPointerEx
ception”。
答：在程序中你试图在值为null的对象变量上调用方法，请检查你的程序确保你的对象被恰当的初始化。
参见Q4.8以了解java中的异常机制。


Q2.8 package是什么意思？怎么用？
答：为了唯一标识每个类并分组，java使用了package的概念。
每个类都有一个全名，例如String的全名是java.lang.String，其中java.lang是包名，S
tring是短名。按照java命名惯例，包名是全部小写的，而类名的第一个字母是大写的。
这样，如果你自行定义了同样名字的类String，你可以把它放在mypackage中，
通过使用全名mypackage.String和java.lang.String来区分这两个类。
同时，将逻辑上相关的类放在同一个包中，可以使程序结构更为清楚。
为了定义包，你要做的就是在java文件开头加一行“package mypackage;”。
注意包没有嵌套或包含关系，mypackage包和mypackage.mysubpackage包对JRE来说是并列的两个包（虽然开发者可
能暗示包含关系）。

Q2.9 我没有声明任何package会怎么样？
答：你的类被认为放在默认包中。这时全名和短名是一致的。

Q2.10 在一个类中怎么使用其他类？
答：如果你使用java.lang包或者默认包中的类，不用做任何事。
如果你的类位于mypackage包中，并且要调用同一包中的其他类，也不用做任何事。
如果你使用其他包中的类，在package声明之后，类声明之前使用import otherpackage1.Class
1; 或 import otherpackage2.*; 
这里.*表示引入这个包中的所有类。然后在程序中你可以使用其他类的短名。
如果短名间有重名冲突，必须使用全名来区分。
注意在使用其他包中的类时，你只能使用public的类和接口，参见Q5.4。

Q2.11 我用了package的时候显示"NoClassDefFoundError"，但是我把所有package去掉的
时候能正常运行。
答：将你的java文件按包名组织存放。
比如你的工作目录是/work，你的类是package1.Class1，那么将它存放为/work/package1
/Class1.java。
如果没有声明包，那么直接放在/work下。
在/work下执行javac package1/class1.java，再执行java package1.class1，你会发现一
切正常。
另外，如果你的类的个数已经多到了你需要使用包来组织的话，你可以考虑开始使用IDE。

Q2.12 我想把java编译成exe文件，该怎么做？
答：JDK只能将java源文件编译为class文件。
class文件是一种跨平台的字节码，必须依赖平台相关的JRE来运行。Java以此来实现跨平
台性。
有些开发工具可以将java文件编译为exe文件。作者反对这种做法，因为这样就取消了跨平
台性。
如果你确信你的软件只在Windows平台上运行，你可以考虑使用C++/C#来编程。

Q2.13 我在编译的时候遇到什么"deprecated API"，是什么意思？
答：所谓deprecated是指已经过时，但是为了向前兼容起见仍然保留的方法。
这些方法可能会在以后取消支持。你应当改用较新的方法。
在API里面会说明你应当用什么方法来代替之。

三、I/O篇

Q3.1 我怎么给java程序加启动参数，就像dir /p/w那样？
答：还记得public static void main(String[] args)吗？这里的args就是你的启动参数
。
在运行时你输入java package1.class1 arg1 arg2，args中就会有两个String，第一个是
arg1，第二个是arg2。

Q3.2 我怎么从键盘输入一个int/double/字符串？
答：java的I/O操作比C++要复杂一点。如果要从键盘输入，样例代码如下：
BufferedReader cin = new BufferedReader( new InputStreamReader( System.in ) );

String s = cin.readLine();
这样你就获得了一个字符串，如果你需要数字的话再使用：
int n = Integer.parseInt( s ); 或者 double d = Double.parseDouble( s );
来将字符串"534"转换成int或double。

Q3.3 我怎么输出一个int/double/字符串？
答：使用System.out.println(n)或者System.out.println("Hello")等等。

Q3.4 我发现有些书上直接用System.in输入，比你要简单得多。
答：java使用unicode，是双字节。而System.in是单字节的stream。
如果你要输入双字节文字比如中文，请使用作者的做法。

Q3.5 我怎么从文件输入/输出一个int/double/字符串？
答：类似于从键盘输入，只不过换成
BufferedReader fin = new BufferedReader( new FileReader(" myFileName " ) );
PrintWriter fout = new PrintWriter( new FileWriter(" myFileName " ) );
另外如果你还没下载API，请开始下载并阅读java.io包中的内容。

Q3.6 我想读写文件的指定位置，该怎么办？
答：java.io.RandomAccessFile可以满足你的需要。

Q3.7 怎么判断要读的文件已经到了尽头？
答：在Reader的read方法中明确说明返回-1表示流的结尾。

四、 关键字篇

Q4.1  java里面怎么定义宏？
答：java不支持宏，因为宏代换不能保证类型安全。
如果你需要定义常量，可以将它定义为某个类的static final成员。参见Q4.2和Q4.6。


Q4.2  java里面没法用const。
答：你可以用final关键字。例如 final int m = 9。被声明为final的变量不能被再次赋
值。唯一的例外是所谓blank final，如下例所示：
public class MyClass1 {
    private final int a = 3;
    private final int b; // blank final

    public MyClass1() {
        a = 5; // 不合法，final变量不能被再次赋值。
        b = 4; // 合法，这是b第一次被赋值。
        b = 6; // 不合法，b不能被再次赋值。
    }
}
final也可以用于声明方法或类，被声明为final的方法或类不能被继承。
注意const是java的保留字以备扩充。

Q4.3  java里面也不能用goto。
答：甚至在面向过程的语言中你也可以完全不用goto。请检查你的程序流程是否合理。

如果你需要从多层循环中迅速跳出，java增强了（和C++相比）break和continue的功能，
支持label。
例如：
outer :
while( ... )
{
inner :
for( ... )
{
           ...   break inner; ...
           ... continue outer; ...
}
}
和const一样，goto也是java的保留字以备扩充。

Q4.4  java里面能不能重载操作符？
答：不能。String的+号是唯一一个内置的重载操作符。你可以通过定义接口和方法来实现
类似功能。

Q4.5  我new了一个对象，但是没法delete掉它。
答：java有自动内存回收机制，即所谓Garbarge Collection。你不需要删除对象。你再也
不用担心指针错误，内存溢出了。

Q4.6  我想知道为什么main方法必须被声明为public static？为什么在main方法中不能调
用非static成员？
答：声明为public是为了这个方法可以被外部调用，详情见Q5.4。
static是为了将某个成员变量/方法关联到类（class）而非实例（instance）。
你不需要创建一个对象就可以直接使用这个类的static成员，因而在static成员中不能调
用非static成员，因为后者是关联到对象实例（instance）的。
在A类中调用B类的static成员可以使用B.staticMember的写法。
注意一个类的static成员变量是唯一的，被所有该类对象所共享的，在多线程程序设计中尤其要谨慎小心。
类的static成员是在类第一次被JRE装载的时候初始化的。
你可以使用如下方法来使用非static成员：
public class A
{
    private void someMethod() //非static成员
    {}
    public static void main(String args)
    {
         A a = new A();  //创建一个对象实例
         a.someMethod();  //现在你可以使用非static方法了
    }
}


Q4.7  throw和throws有什么不同？
答：throws用于方法声明中，声明一个方法会抛出哪些异常。而throw是在方法体中实际执行抛出异常的
动作。
如果你在方法中throw一个异常，却没有在方法声明中声明之，编译器会报错。
注意Error和RuntimeException的子类是例外，无需特别声明。

Q4.8  什么是异常？
答：异常最早在Ada语言中引入，用于在程序中动态处理错误并恢复。
你可以在方法中拦截底层异常并处理之，也可以抛给更高层的模块去处理。
你也可以抛出自己的异常指示发生了某些不正常情况。常见的拦截处理代码如下：
try
{
......//以下是可能发生异常的代码
        ...... //异常被你或低层API抛出，执行流程中断并转向拦截代码。
        ......
}
catch(Exception1 e) //如果Exception1是Exception2的子类并要做特别处理，应排在前
面
{
  //发生Exception1时被该段拦截
}
catch(Exception2 e)
{
  //发生Exception2时被该段拦截
}
finally //这是可选的
{
   //无论异常是否发生，均执行此段代码
   //即使在catch段中又向外抛出了新的exception，finally段也会得到执行。
}

Q4.9  final和finally有什么不同？
答：final请见Q4.2。finally用于异常机制，参见Q4.8。

五、 面向对象篇

Q5.1  extends和implements有什么不同？
答：对于class而言，extends用于（单）继承一个类（class），而implements用于实现一个接口（interf
ace）。
interface的引入是为了部分地提供多继承的功能。
在interface中只需声明方法头，而将方法体留给实现的class来做。
这些实现的class的实例完全可以当作interface的实例来对待。
在interface之间也可以声明为extends（多继承）的关系。
注意一个interface可以extends多个其他interface。

Q5.2  java怎么实现多继承？
答：java不支持显式的多继承。
因为在显式多继承的语言例如c++中，会出现子类被迫声明祖先虚基类构造函数的问题，

而这是违反面向对象的封装性原则的。
java提供了interface和implements关键字来部分地实现多继承。参见Q5.1。

Q5.3 abstract是什么？
答：被声明为abstract的方法无需给出方法体，留给子类来实现。
而如果一个类中有abstract方法，那么这个类也必须声明为abstract。
被声明为abstract的类无法实例化，尽管它可以定义构造方法供子类使用。

Q5.4 public,protected,private有什么不同？
答：这些关键字用于声明类和成员的可见性。
public成员可以被任何类访问，
protected成员限于自己和子类访问，
private成员限于自己访问。
Java还提供了第四种的默认可见性，一般称为package private，当没有任何public,protected,private修饰符时，成员
是同一包内可见。
类可以用public或默认来修饰。

Q5.5 Override和Overload有什么不同？
答：Override是指父类和子类之间方法的继承关系，这些方法有着相同的名称和参数类型
。
Overload是指同一个类中不同方法（可以在子类也可以在父类中定义）间的关系，
这些方法有着相同的名称和不同的参数类型。


Q5.6 我继承了一个方法，但现在我想调用在父类中定义的方法。
答：用super.xxx()可以在子类中调用父类方法。

Q5.7 我想在子类的构造方法中调用父类的构造方法，该怎么办？
答：在子类构造方法的第一行调用super(...)即可。

Q5.8 我在同一个类中定义了好几个构造方法并且想在一个构造方法中调用另一个。
答：在构造方法第一行调用this(...)。

Q5.9 我没有定义构造方法会怎么样？
答：自动获得一个无参数的构造方法。

Q5.10 我调用无参数的构造方法失败了。
答：如果你至少定义了一个构造方法，就不再有自动提供的无参数的构造方法了。
你需要另外显式定义一个无参数的构造方法。
另外一种可能是你的构造方法或者类不是public的，参见Q5.4了解java中的可见性。

Q5.11 我该怎么定义类似于C++中的析构方法（destructor）？
答：提供一个void finalize()方法。在Garbarge Collector回收该对象时会调用该方法。

注意实际上你很难判断一个对象会在什么时候被回收。作者从未感到需要用到该方法。


Q5.12 我想将一个父类对象转换成一个子类对象该怎么做？
答：强制类型转换。如
public void meth(A a)
{
B b = (B)a;
}
如果a实际上并不是B的实例，会抛出ClassCastException。所以请确保a确实是B的实例。


Q5.13 其实我不确定a是不是B的实例，能不能分情况处理？
答：可以使用instanceof操作符。例如
if( a instanceof B )
{
B b = (B)a;
}
else
{
...
}

Q5.14 我在方法里修改了一个对象的值，但是退出方法后我发现这个对象的值没变！
答：很可能你把传入参数重赋了一个新对象，例如下列代码就会造成这种错误：
public void fun1(A a) //a是局部参数，指向了一个外在对象。
{
a = new A(); //a指向了一个新对象，和外在对象脱钩了。如果你要让a作为传出变量，
不要写这一句。
        a.setAttr(attr);//修改了新对象的值，外在对象没有被修改。
}
基本类型也会出现这种情况。例如：
public void fun2(int a)
{
a = 10;//只作用于本方法，外面的变量不会变化。
}

六、java.util篇

Q6.1 java能动态分配数组吗？
答：可以。例如int n = 3; Language[] myLanguages = new Language[n];

Q6.2 我怎么知道数组的长度？
答：用length属性。如上例中的  myLanguages.length 就为 3。

Q6.3 我还想让数组的长度能自动改变，能够增加/删除元素。
答：用顺序表--java.util.List接口。
你可以选择用ArrayList或是LinkedList，前者是数组实现，后者是链表实现。
例如：  List list = new ArrayList(); 或是 List list = new LinkedList();  。

Q    什么是链表？为什么要有ArrayList和LinkedList两种List？
答：请补习数据结构。

Q6.5 我想用队列/栈。
答：用java.util.LinkedList。

Q6.6 我希望不要有重复的元素。
答：用集合--java.util.Set接口。例如：Set set = new HashSet()。

Q6.7 我想遍历集合/Map。
答：用java.util.Iterator。参见API。

Q6.8 我还要能够排序。
答：用java.util.TreeSet。例如：Set set = new TreeSet()。放进去的元素会自动排序
。
你需要为元素实现Comparable接口，还可能需要提供equals()方法，compareTo()方法，h
ashCode()方法。

Q6.9 但是我想给数组排序。
答：java.util.Arrays类包含了sort等实用方法。

Q6.10 我想按不同方式排序。
答：为每种方式定义一个实现了接口Comparator的排序类并和Arrays或TreeSet综合运用。


Q6.11 Map有什么用？
答：存储key-value的关键字-值对，你可以通过关键字来快速存取相应的值。

Q6.12 set方法没问题，但是get方法返回的是Object。
答：强制类型转换成你需要的类型。参见Q5.12。

Q6.13 ArrayList和Vector有什么不同？HashMap和Hashtable有什么不同？
答：ArrayList和HashMap是多线程不安全的，在多个线程中访问同一个ArrayList对象可能
会引起冲突并导致错误。
而Vector和Hashtable是多线程安全的，即使在多个线程中同时访问同一个Vector对象也不
会引起差错。
看起来我们更应该使用Vector和Hashtable，但是实际上Vector和Hashtable的性能太差，
所以如果你不在多线程中使用的话，还是应该用ArrayList和HashMap。

Q6.14 我要获得一个随机数。
答：使用java.util.Random类。

Q6.15 我比较两个String总是false，但是它们明明都是"abc" ！
答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用 == ！
==比较的是两个引用（变量）是否指向了同一个对象，而不是比较其内容。

Q6.16 我想修改一个String但是在String类中没找到编辑方法。
答：使用StringBuffer类。
String str = "......."; //待处理的字符串
StringBuffer buffer = new StringBuffer(str); //使用该字符串初始化一个StringBuf
fer
buffer.append("..."); //调用StringBuffer的相关API来编辑字符串
String str2 = buffer.toString(); //获得编辑后的字符串。
另外，如果你需要将多个字符串连接起来，请尽量避免使用+号直接连接，而是使用Strin
gBuffer.append()方法。

Q6.17 我想处理日期/时间。
答：使用java.util.Date类。你可以使用java.text.SimpleDateFormat类来在String和Da
te间互相转换。
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //规
定日期格式
Date date = formatter.parse("2003-07-26 18:30:35"); //将符合格式的String转换为
Date
String s = formatter.format(date); //将Date转换为符合格式的String
关于定义日期格式的详细信息请参见API。
 

J2EE FAQ
 
目录：

一、准备篇
Q1.1   什么是J2EE？它和普通的Java有什么不同？
Q1.2   J2EE好学吗？
Q1.3   J2EE有什么用？
Q1.4   学J2EE有前途吗？
Q1.5   据说J2EE的性能不如.NET好，是真的吗？
Q1.6   听你说了这么多，我想学着玩玩。
Q1.7   学习J2EE该怎么开始？
Q1.8   我下了一个J2EE服务器但是不会配置。
Q1.9   我发现你没有提到Tomcat。

二、 Servlet/JSP篇
Q2.1   什么是Servlet？
Q2.2   我怎么获得Http请求里的参数？
Q2.3   我怎么返回结果？
Q2.4   sendRedirect()和forward()有什么不同？
Q2.5   我写了一个Servlet程序，怎么运行它？
Q2.6   EAR和WAR有什么不同？
Q2.7   EAR格式是怎样的？
Q2.8   WAR格式是怎样的？
Q2.9   我的普通HTML文件/JSP文件应当放在哪里？
Q2.10  我访问不到servlet，甚至连HTML文件都访问不到！
Q2.11  我能访问HTML但是访问不到servlet。
Q2.12  什么是JSP？它和Servlet有什么区别？
Q2.13  我的JSP显示的汉字是乱码。
Q2.14  为什么使用gb18030而不是gb2312？
Q2.15  在JSP里面怎么引用Java Bean。
Q2.16  我想在servlet间传递数据。
Q2.17  怎么调用cookie？
Q2.18  怎么在JSP里面实现文件下载？
Q2.19  怎么实现文件上传？
Q2.20  我想让页面自动刷新，比如聊天室。
Q2.21  我想让用户登录以后才能访问页面。
Q2.22  我想要能注册用户。
Q2.23  怎么在JSP中访问数据库？
Q2.24  什么是JSTL？

一、准备篇

Q1.1  什么是J2EE？它和普通的Java有什么不同？
答：J2EE全称为Java2 Platform, Enterprise Edition。
“J2EE平台本质上是一个分布式的服务器应用程序设计环境——一个Java环境，它提供了
：
·宿主应用的一个运行基础框架环境。
·一套用来创建应用的Java扩展API。”

Q1.2  J2EE好学吗？
答：J2EE是很多技术的集合体，并且还在成长中。
你会遇到很多专有名词：比如(X)HTML，Servlet/JSP，JDBC，JMS，JNDI，EJB，XML，Web
Service……。
尤其是XML和Web Service正在快速成长。幸运的是，你不需要等到学会所有技术后再开始
编程。
大体上J2EE可以分成3个主要应用方式：Servlet/JSP，EJB，Web Service 和一些支撑技术
例如JDBC和JNDI。
你可以一个一个的学。

Q1.3 J2EE有什么用？
答：用来建设大型的分布式企业级应用程序。或者用更时髦的名词说就是“电子商务”应
用程序。
这些企业可能大到拥有中心数据库服务器，Web服务器集群和遍布全国的办公终端，也可能
小到只不过想做一个网站。但是你肯定听过“杀鸡焉用牛刀”的古训。

Q1.4 学J2EE有前途吗？
答：在这一市场目前只有一种技术可以和J2EE竞争，那就是Microsoft的.NET。
相对来说.NET要“新”一些而J2EE要“老”一些。这也意味着.NET更易用一点而J2EE更成
熟一点。
但是.NET只能用于Windows平台（Microsoft声称要开发C#在Linux上的虚拟机但是尚未兑现
该诺言）。
在过去几年，.NET的市场份额并不理想。不过Microsoft还有Longhorn这一杀手锏，鹿死谁
手还很难说。

Q1.5 据说J2EE的性能不如.NET好，是真的吗？
答：在Sun公司提供的样例程序Pet Store上，Microsoft声称不如相同的.NET程序好。
而Sun公司反驳说这一程序不能真正体现J2EE的性能，并且指责Microsoft在数据库上做了
优化。
作者没有学习过.NET因而不能妄下断言。
无论如何，大型分布式程序中的性能瓶颈通常首先来自于错误的设计。

Q1.6 听你说了这么多，我想学着玩玩。
答：除非你想靠它当饭吃或者作为技术储备，否则请不要浪费你的时间。
Flash要好玩得多。计算机游戏就更加好玩了。

Q1.7 学习J2EE该怎么开始？
答：首先，下载一个免费的J2EE服务器。其次，去java.sun.com下载J2EE的API。第三，找
一本好的参考书。最后，找一个顺手的IDE。
J2EE服务器。你可以用Sun的J2EE SDK（免费），或者Weblogic（性能最好，但是太大，而
且作者不推荐盗版行为），
或者JBoss（免费，就是文档太少），或者JRun（开发版免费，作者用这个）。
参考书作者感觉Wrox的《J2EE服务器端高级编程》不错，但是太老（作者手头的是2001年
中文版）。
（似乎很多人不喜欢这本书......所以你得自己判断它是否适合你。）
你还需要去下载一些最新的技术资料（当然肯定是英文的）。
IDE如果你的机器配置够好（内存至少512M以上，256M或以下请勿考虑），可以用IBM的WS
AD，不然就继续用Eclipse或者其他。
你也可以经常去水木清华的Java版逛逛，但是在发贴前先看看精华区里有没有你要的答案
。

Q1.8 我下了一个J2EE服务器但是不会配置。
答：请认真阅读随机指导文档，不同的服务器的配置都不一样，作者爱莫能助。

Q1.9 我发现你没有提到Tomcat。
答：Tomcat只是一个Web服务器，更准确地说主要只是一个Web Container。
如果你想要学习EJB的话，Tomcat无法满足你的需要。

二、 Servlet/JSP篇

Q2.1 什么是Servlet？
答：一个Servlet是一个Java类。它处理Http(s)请求并作出响应，包括返回一个HTML页面
或转交给其他URL处理。
Servlet必须运行在一个Web Container例如Tomcat中。
Servlet必须是javax.servlet.http.HttpServlet的子类，
你可以继承doGet()或者doPost()方法，两者分别对应于Http(s)中的Get请求和Post请求。


Q2.2 我怎么获得Http请求里的参数？
答：HttpRequest的getParameter()方法。例如：String paramValue = request.getPara
meter("paramName");

Q2.3 我怎么返回结果？
答：你可以利用相关API打开一个输出流，并向流中直接写入一个HTML页面。
但是作者完全不赞成这样做。一方面这样做会很罗嗦。
另一方面从Model-View-Controller模式（在《J2EE核心模式》中被归为Front Controlle
r模式）的观点来看，
你应当提供一些HTML或者JSP作为视图（view），而Servlet则根据请求参数决定转到哪一
个视图。
你可以利用response.sendRedirect(...)方法或request.getDispatcher(...).forward()
方法来实现。

Q2.4 sendRedirect()和forward()有什么不同？
答：sendRedirect()是向浏览器发送一个redirect通知，浏览器向新的URL发送一个新的请
求。
而forward是在服务器端直接将请求转到新的URL，对于浏览器是透明的。
换而言之，sendRedirect()应当将共享数据放在session中，forward应当将共享数据放在
request中（当然你也可以放在session中，但放在request中可以有效减小session中的数
据量，从而改善性能）。
前者浏览器的地址栏显示的是新的URL，后者浏览器的地址栏显示的是Servlet的URL。
因而当刷新目标URL时，两者会造成一些差别。

Q2.5 我写了一个Servlet程序，怎么运行它？
答：开发J2EE程序有一个部署（deploy）的概念，实际上是开发——部署——运行的三部
曲。
大多数服务器支持Hot deploy。你只需要在相应的Application目录（具体路径依赖于服务
器）下面
建立一个符合WAR或EAR格式（参见Q2.7，Q2.8）的目录，启动服务器，就可以通过浏览器
访问了。
特别的，你的Servlet的class文件应当放在/WEB-INF/classes目录中。
注意J2EE SDK不支持Hot deploy，你需要通过它的deploy tool来部署。
Tomcat只支持WAR格式。

Q2.6 EAR和WAR有什么不同？
答：EAR是一个完整的J2EE应用程序，包括Web部分和EJB部分。
WAR只是其中的Web部分。

Q2.7 EAR格式是怎样的？
答：一个EAR可以包含任意多个WAR或EJB JAR，并且包含一个META-INF的目录。
在/META-INF中包含了一个application.xml，其中描述了这个EAR包含哪些模块，以及安全
性配置。
细节请看参考书。

Q2.8 WAR格式是怎样的？
答：一个WAR包含一个WEB-INF的目录，这个目录下包含classes目录，lib目录和web.xml。

/WEB-INF/classes存放按package组织的class文件，/WEB-INF/lib目录存放jar文件，
web.xml描述了很多东西，请读参考书。

Q2.9 我的普通HTML文件/JSP文件应当放在哪里？
答：放在除了/WEB-INF以外的其他地方。

感谢antegg网友对于安全性的提醒：
如果你想直接用http://url/***.jsp的方式来访问，就要像上面说得那样放。
但是这样的做法是不安全的，安全的做法是把所有的JSP页面放在/WEB-INF目录下面，并且

通过WEB-CONTAINER来访问。

作者意见:
我更喜欢用filter来做安全性检查。
在MVC模式中，JSP只是一个视图而已，一般无需特别担忧安全性。和普通的html放在一起
也利于维护。

Q2.10 我访问不到servlet，甚至连HTML文件都访问不到！
答：
第一你没启动服务器。
第二你敲错了端口。
第三你没有正确配置context-path。
第四你的服务器不支持auto reload或者你关闭了这一选项，你得重启服务器或重新部署W
AR。
第五确认你没有把HTML放在/WEB-INF目录下，那是访问不到的。

Q2.11 我能访问HTML但是访问不到servlet。
答：请检查你的web.xml文件。确保你正确定义了<servlet>和<servlet-mapping>元素。

前者标识了一个servlet，后者将一个相对于context-path的URL映射到一个servlet。
在Tomcat中你可以通过/context-path/servlet/package/servletname的形式访问servlet
，
但是这只是Tomcat的便捷访问方式，并不是正式规范。
细节请看参考书。

Q2.12  什么是JSP？它和Servlet有什么区别？
答：你可以将JSP当做一个可扩充的HTML来对待。
虽然在本质上JSP文件会被服务器自动翻译为相应的Servlet来执行。
可以说Servlet是面向Java程序员而JSP是面向HTML程序员的，除此之外两者功能完全等价
。

Q2.13  我的JSP显示的汉字是乱码。
答：在你的JSP开头加上一行 <%@ page contentType="text/html; charset=gb18030"%>

如果你已经声明了page我想你知道该怎么修改。

Q2.14  为什么使用gb18030而不是gb2312？
答：gb18030是继gb2312之后的下一代汉字编码标准，最终将过渡到Unicode。

Q2.15  在JSP里面怎么引用Java Bean。
答：首先，确认你要引用的类在/WEB-INF/classes下或在/WEB-INF/lib的某个jar内。
其次，在JSP里加一行 <jsp:useBean id="..." scope="..." class="..."/>
具体解释请看参考书。

Q2.16  我想在servlet间传递数据。
答：利用session。在Servlet/JSP中，你可以在4个地方保存数据。
1) page，本页面。
2) session，用来存放客户相关的信息，比如购物车，对应接口为javax.servlet.http.H
ttpSession。
session机制实际上是cookie和URL Rewriting的抽象，服务器会自动使用cookie或URL Re
writing来实现。
3) request，可以在forward()时传递信息，对应接口为javax.servlet.http.HttpReques
t。
4) application，或称context，存放全局信息，对应接口为javax.servlet.ServletCont
ext。

Q2.17  怎么调用cookie？
答：作者建议使用session，你总是会遇到某些禁用cookie的用户。这时session会自动使
用URL重写来实现。

Q2.18  怎么在JSP里面实现文件下载？
答：实际上这是一个HTML的问题。答案是一个超链接<a>。

Q2.19  怎么实现文件上传？
答：客户端是HTML问题，在form中设置method为post，enctype为multi-part/form-data，
加一个<input type="file">。
而在接收的servlet中只是一个I/O问题，你可以使用jakarta的file-upload库。

Q2.20  我想让页面自动刷新，比如聊天室。
答：这是一个HTML问题，在<head>部分中加一条<meta http-equiv="refresh" content="
5" url="...">。
这是所谓的Client-pull，客户端刷新技术。
相对的还有Server-push，服务器端刷新技术，但是这一技术由于要占用服务器端资源而会
在大量访问时出现瓶颈现象，参见http://216.239.33.104/search?q=cache:autUfoakirY
J:www.kfunigraz.ac.at/edvndwww/books/books/javaenterprise/servlet/ch06_03.htm+
server-push+servlet&hl=zh-CN&ie=UTF-8

Q2.21  我想让用户登录以后才能访问页面。
答：使用声明式安全措施。
你只需要在web.xml中定义安全角色（Role），并定义受保护的URL集合只能由特定Role访
问。
大多数服务器支持基于数据库的用户映射，你只要在相应数据库中建立两张表并配置服务
器就可以了。
注意J2EE SDK不支持基于数据库的用户映射。
细节请看参考书和服务器文档。
不过在商业环境中，J2EE所提供的声明式安全措施仍然偏弱。一般商业程序会使用数据库
存储user-role-privilege模型来达到安全性要求，细节请询问你的构架设计师。

Q2.22  我想要能注册用户。
答：参看Q2.21。在接受注册请求的Servlet中执行写入数据库操作即可。

Q2.23  怎么在JSP中访问数据库？
答：标准做法是使用DAO模式，定义一个Java bean来访问数据库并在JSP中使用。
然而，当你的数据库模式很简单时，你可以使用JSTL中的<sql:query>标签来快速访问。

在一般的J2EE项目中，JSP处于表示层（展现层），需要先后通过业务层和集成层才会访问
到数据库，所以这个问题确实只会在很小的程序中才会遇到。

Q2.24  什么是JSTL？
答：JSTL是Jsp Standard Tag Library的缩写。这是一组通用标签并将成为JSP 2.0的一部
分。
其中包含赋值<c:set>，分支<c:if>，循环<c:forEach>，查询数据库<sql:query>，更新数
据库<sql:update>
等。目前你需要像添加自定义标签库一样来添加JSTL，但是可以预计JSP 2.0会将JSTL作为
组成部分。
标签库可以在http://jakarta.apache.org下载。注意JSTL需要在支持JSP 1.2或更高版本
的容器下运行。
帮助文件可以阅读sun的JSTL正式规范
posted @ 2006-08-16 14:43 阿成 阅读(260) | 评论 (0) | 编辑 收藏
Hsql尝试
（转自：转自：http://cutelife.bokee.com/blog/3474380.html）
前言：该文章只是简单介绍一下hsql的入门内容，如果想仔细了解的话，参考官方帮助文档最为有用。

一、简介：
hsql数据库是一款纯Java编写的免费数据库，许可是BSD-style的协议，如果你是使用Java编程的话，不凡考虑一 下使用它，相对其他数据库来说，其体积小，才563kb。仅一个hsqldb.jar文件就包括了数据库引擎，数据库驱动，还有其他用户界面操作等内容。 在Java开源世界里，hsql是极为受欢迎的（就Java本身来说），JBoss应用程序服务器默认也提供了这个数据库引擎。由于其体积小的原因，又是 纯Java设计，又支持SQL99，SQL2003大部分的标准，所以也是作为商业应用程序展示的一种选择。请到以下地址下载hsql： http://prdownloads.sourceforge.net/hsqldb/hsqldb_1_7_3_3.zip?download

二、使用hsql数据库：
1、hsql数据库引擎有几种服务器模式：常用的Server模式、WebServer模式、Servlet模式、Standlone模式、Memory-Only数据库。
2、最为常用的Server模式：
1)首先却换到lib文件夹下，运行java -cp hsqldb.jar org.hsqldb.Server -database.0 db/mydb -dbname.0 xdb
执行命令后，将会在db文件夹下创建一个数据库mydb，别名（用于访问数据库）是xdb，如果存在mydb数据库，将会打开它。
2)运行数据库界面操作工具：java -cp hsqldb.jar org.hsqldb.util.DatabaseManager
在Type 选项里选上相应的服务器模式，这里选择HSQL Database Engine Server模式；Driver不用修改；URL修改为jdbc:hsqldb:hsql://localhost/xdb （主要这里xdb就是上面我们设置的别名）;user里设置用户名，第一次登录时，设置的是管理员的用户名，password设置密码。然后点击Ok。
3)第一次运行数据库引擎，创建数据库完毕。好了，你可以打开db文件夹，会发现里面多了几个文件。
mydb.properties文件：是关于数据库的属性文件。
mydb.script：hsql主要保存的表（这里按hsql的说法是Memory表，就是最为常用的），里面的格式都是文本格式，可以用文本查看，里面的语句都是sql语句，熟悉sql语句的话，你也可以手动修改它。每次运行数据库引擎的话都是从这里加载进内存的。
mydb.lck表示数据库处于打开状态。
其他的请参看hsqldb包里的手册。

3、WebServer模式和Server运行模式基本一样，只是支持了Http等协议，主要用于防火墙，默认端口是9001。启动Server，java -cp hsqldb.jar org.hsqldb.WebServer ...剩余的和上面的一致。

4、Servlet模式可以允许你通过Servlet容器来访问数据库，请查看hsqlServlet.java的源代码，和WebServer类似。

5、 另一个值得思考的模式是Standalone模式：不能通过网络来访问数据库，主要是在一个JVM中使用，那样的话，访问的速度会更加快。虽然文档里面提 到主要是用于开发时使用，但是我们可以假设一下，该方法不需要一个引擎类的东西，而类似于打开文件的方式，返回一个Connection对象：
Connection c = DriverManager.getConnection("jdbc:hsqldb:file:mydb", "sa", "");
将 会在当前目录找到mydb数据库相关文件，打开并返回一个Connection对象。该方式有点好处就是可以不使用引擎，在需要的时候操作数据。所以那些 对数据库不是特别有要求的，但又需要一个操作数据库的方式的话，可以使用这种方法。对于那些不想额外在数据库引擎花费金钱的话，可以使用这种方法。但是不 推荐使用该方法。记得Hibernate里SessionFactory可以使用openSession(Connecttion c)来获得一个Session对象的，因此，在测试或者实际应用的话都可以这样使用。

6、Memory-Only 数据库：顾名思义，主要是内存中使用，不用于保存数据。可以用于在内存中交换数据。

三、具体的链接与操作的话，和一般的JDBC操作一样。而相应的Server模式的话，连接地址主要你运行数据库界面操作工具时，在URL一栏时默认已经设好了，自己实习一下，对比其中参数。

这篇文章介绍大致内容很详细，不过也大都是从Hsql的帮助上翻译的，我有必要加入点新鲜的血液。
这篇文章美中不足的是缺少实战性，往往初学者第一步都走不出来，比如我。
我在实践中遇到的问题是打开数据库管理器怎么也连接不上数据库，总是说
java.sql.sqlException Socket create error
搞了一个晚上，到第二天早上清醒一下，想起来这个数据库应该在创建库之后，保持那个cmd窗口，在此过程中连接。
果然好用，也迈出了开拓Hsql的第一步。

另外不用在互联网上搜索别的介绍，Hsql自带的guide就已经很详细了。

posted @ 2006-08-16 14:24 阿成 阅读(313) | 评论 (0) | 编辑 收藏
Oracle Jdeveloper学习笔记

1.如何调试.jsp文件
  现在.jsp文件的前一个.java文件设端点，再在.jsp文件设端点，debug下先停在.java文件的断点处，执行到下一断点，即.jsp文件中。

尽管这样，有时用jdeveloper在jsp里设置断点还是不太管用。

2.如何显示原文件的改变
对 于模板元素的改变（html和javascript）只需要保存，刷新页面即可；对于脚本元素、jsp标签的改变要先make再刷新页面；如果不行的话就 重新run项目；再不行就设断点，一步一步走过改变的代码;再不行就把class文件夹全部删掉，让他重新编译；再不行就重启机器。对于html中引用的 图片或是script函数，修改后很可能还显示原来的，这是可能是在某个临时文件夹存有原来的文件，以上方法无效，这时要把定义函数的名字和引用函数的名 字都改变，使电脑不得不找临时文件以外的文件，这样才会显示改变，对于图片则是改变文件名称。

3.如何run和debug
run或debug之前都要把之前的run或debug先terminate，这样才能避免错误。

4.本机调试时用户名如果为"acheng"会变成"jazn/acheng",所以取用户名一定要先过滤掉 "jazn/",这样在本机调试和服务器调试时都不会龃?
username = remoteUserName.substring(remoteUserName.indexOf("/") + 1, remoteUserName.length());

5.确定网站入口：打开图形化的struts_config.xml，右键单击想作为入口的.do或.jsp文件，选择“set as default run target”选项，即可。struts_config.xml中的welcome标签就没用了。

6. 建立自定义库：右键单击某项目，选择project properties -> properties -> libaries -> new... 则打开creat libary对话框，单击add entry把该库向关的所有jar包选中，再添上此库名称以后即可用了。

7.引入已有的项目
对于.war或.ear文件可以File -> Import -> 选择相关的加入方式。
对于已经解压的文件夹（以Struts书上的addressbook为例）
  a.先建立空工作区addressbook，建立空项目addressbook，新建struts。
  b.把源文件根目录的图片和.jsp文件拷贝到新文件public_html下。
  c.用源文件WEB-INF替换新文件public_html下WEB-INF。
  d.用源文件src替换新文件src。
  e.把新文件WEB-INF下classes中的.properties文件拷贝到src相应位置，后删除classes文件夹。

8.制作oracle portlet只能在jdeveloper10.12上进行，并且portlet上的链接根目录必须如下表示：（不可以）
<%
    String server=null;
    StringBuffer buff = new StringBuffer();
    buff.append(request.getScheme()).append("://");
    buff.append(request.getServerName()).append(":");
    buff.append(request.getServerPort());
    buff.append(request.getContextPath());
    server = buff.toString();
%>
<a href="<%=server%>/login/login.jsp">login.jsp</a>
<!--a href="login/login.jsp">login.jsp</a--><!--这样写不行，可能portlet找不到这样的位置-->

posted @ 2006-08-16 14:14 阿成 阅读(605) | 评论 (0) | 编辑 收藏
MyEclipse学习笔记

1。插件安装有三种方法：

    a、是将文件靠到eclipse的根目录，如文件夹取名为chajian，下层文件夹为eclipse，下层文件夹为     features和plugins，再在eclipse的根目录建links文件夹，内部建chajian.link，编辑为path＝    chajian （或者c:/eclipse/chajian,即绝对和相对路径皆可），就ok了（多个插件可以定义一个        pluge.link，一个path=***一行；或者定义多个.link文件，每个包含一个path）。

    b、是把插件包内的plugins和features内的文件拷贝到本目录下plugins和 features中。

    c、通过Help－>Software Update->Find and Instal直接安装

2.打包成jar文件时，需要根据自定义的文件生成MANIFEST.MF，其中每行的冒号后面都有一个空格，否则出错。例：Manifest-Version: 1.0(1.0前有空格，其他行也是如此)

3.由数据库中的表自动建立.java和.hbm.xml文件

    a.建立项目：打开带HibernateTools插件的eclipse，建立一个名为“test”的java project,内部新   建一个名字为src的source folder。

    b. 建立hibernate配置文件：新建“hibernate configuration file”，输出路径选择“test项目的src目录”，然后的对话框填写配置文件（包括database dialect,driver class,connection url,username,password,creat a console configuration），下一个对话框先填写name（即console configuration name），再点“add external jars”，选择数据库驱动的jar文件，看到src中有“hibernate.cfg.xml”就是配置文件建立成功。

    c. 建立目标文件：点工具栏hibernate图标，选择“hibernate code generation...”,在弹出的对话框中点击左侧“新建”，把名字改为“test”，console configuration选刚才建立的console configuration name，package填想生成的包结构，点reveng.xml的“setup”，接下来对话框选择test的src目录，然后导入需要的数据库表（有关联的就要导入，即外键的表也要导入），然后点“finish”；选择main右边的exporters，选中generate domain code,generate mappings三项，run，刷新项目，看到包中生成的.java和.hbm.xml文件，成功，把它们拷入myeclipse的相应项目里。

hbm文件的主键有一条<generator class="assigned"/>表示用程序来设置主键，一般改为"increment"表示递增生成主键。 

  d.删除Console Configuration：打开Hibernate Console的透视图（perspective），在左侧Hibernate Configuration的视图（view）中右键单击，就可以删除。
删除Hivernate Code Generation：点击工具栏Hibernate图标，左侧即可删除。


4.eclipse 中程序代码做了改变但服务器上的代码没有同步改变，先看其他项目是否也如此（我上次遇到这问题其他项目可以同步改变，故不是eclipse的问题，应该是这个项目的问题）；我用尽各种方法都不行，最后把项目从workspace中考出，运行eclpse关闭，再考进去项目，运行，就好了（为什么我也不清楚，可能保存了默认的一些错误设置吧）；后来又遇到这种问题，action中的代码改了不起作用，上面方法也不行，删除workspace中代码，再 checkout，就ok了。看来遇到不能同步的问题应该在workspace中删除程序，再checkout就好了。

5.CVS的bug

    在用MyEclipse的CVS时发现，如果项目里其他人新建了文件夹，自己同步代码时就会出错。就算自己也新建了那个文件夹也不行，难道是个bug？还是使用方法的不当。

6.显示列号方法：eclipse的preferences
    a)General -> Editors -> Text Editors -> Show Line Number（java代码行号）
    b)MyEclipse -> Editors => Common Editor Preferences -> Show Line Number（jsp加行号）
都选中

7、按ctrl+t会列出接口的实现类列表

8、页面和java文件的缩进宽度
MyEclipse -> Editors => Common Editor Preferences 的 Displayed tab width可以调整jsp页面的缩进宽度
windows->java->Code Style->Formatter->Edit

9、查看某个具体文件或类，变量等
F3或按住crtl点名字

posted @ 2006-08-16 14:10 阿成 阅读(1293) | 评论 (0) | 编辑 收藏
结合struts和hibernate谈J2EE架构的数据表示（vo,po,formbean）
  关于VO、PO的理解


O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。
　　VO，值对象(Value Object)，PO，持久对象(Persisent Object)，它们是由一组属性和属性的get和set方法组成。从结构上看，它们并没有什么不同的地方。但从其意义和本质上来看是完全不同的。

１．VO是用new关键字创建，由GC回收的。
　　PO则是向数据库中添加新数据时创建，删除数据库中数据时削除的。并且它只能存活在一个数据库连接中，断开连接即被销毁。

２．VO是值对象，精确点讲它是业务对象，是存活在业务层的，是业务逻辑使用的，它存活的目的就是为数据提供一个生存的地方。
　　PO则是有状态的，每个属性代表其当前的状态。它是物理数据的对象表示。使用它，可以使我们的程序与物理数据解耦，并且可以简化对象数据与物理数据之间的转换。

３．VO的属性是根据当前业务的不同而不同的，也就是说，它的每一个属性都一一对应当前业务逻辑所需要的数据的名称。
　　PO的属性是跟数据库表的字段一一对应的。

PO对象需要实现序列化接口。

（转载：http://www.matrix.org.cn/resource/article/43/43869.html）
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
在 struts+ hibernate 这种结构中，是不应该把Hibernate产生的PO直接传递给JSP的，不管他是

Iterator，还是List，这是一个设计错误。

我来谈谈在J2EE架构中各层的数据表示方法：

Web层的数据表示是FormBean，数据来源于HTML Form POST
业务层的数据表示是VO
持久层的数据表示是PO，其数据来源于数据库，持久层的数据表示例如CMP

在一个规范的J2EE架构中，不同层的数据表示应该被限制在层内，而不应该扩散到其它层，这样可以降

低层间的耦合性，提高J2EE架构整体的可维护性和可扩展性。比如说Web层的逻辑进行了修改，那么只需

要修改FormBean的结构，而不需要触动业务层和持久层的代码修改。同样滴，当数据库表进行了小的调

整，那么也只需要修改持久层数据表示，而不需要触动业务层代码和Web层代码。

不过由于Hibernate的强大功能，例如动态生成PO，PO的状态管理可以脱离Session，使得在应用了

Hibernate的J2EE框架中，PO完全可以充当VO，因此我们下面把PO和VO合并，统称为PO。

先来谈谈ActionFormBean和持久层的PO之间的重大区别。

在简单的应用中，ActionFormBean和PO几乎是没有区别，所以很多人干脆就是用ActionFormBean来充当

PO，于是ActionFormBean从JSP页面到Servlet控制层再到业务层，然后穿过持久层，最后一直映射到数

据库表。真是一竿子捅到了底！

但是在复杂的应用中，ActionFormBean和PO是分离的，他们也不可能一样。ActionFormBean是和网页里

面的Form表单一一对应的，Form里面有什么元素，Bean里面就有什么属性。而PO和数据库表对应，因此

如果数据库表不修改，那么PO也不会修改，如果页面的流程和数据库表字段对应关系不一致，那么你又

如何能够使用ActionFormBean来取代PO呢？

比如说吧，用户注册页面要求注册用户的基本信息，因此HTML Form里面包含了基本信息属性，于是你需

要一个ActionFormBean来一一对应(注意：是一一对应)，每个Bean属性对应一个文本框或者选择框什么

的。

而用户这个持久对象呢？他的属性和ActionFormBean有什么明显不同呢？他会有一些ActionFormBean所

没有的集合属性，比如说用户的权限属性，用户的组属性，用户的帖子等等。另外还有可能的是在

ActionFormBean里面有3个属性，分别是用户的First Name, Middle Name, Last Name，而在我的User这

个持久对象中就是一个 Name 对象属性。

假设我的注册页面原来只要你提供First Name，那么ActionFormBean就这一个属性，后来我要你提供全

名，你要改ActionFormBean，加两个属性。但是这个时候PO是不应该修改滴，因为数据库没有改。

那么在一个完整的J2EE系统中应该如何进行合理的设计呢？

JSP(View) ---> ActionFormBean(Module) ---> Action(Control)

ActionFormBean是Web层的数据表示，它和HTML页面Form对应，只要Web页面的操作流程发生改变，它就

要相应的进行修改，它不应该也不能被传递到业务层和持久层，否则一旦页面修改，会一直牵连到业务

层和持久层的大面积的代码进行修改，对于软件的可维护性和可扩展性而言，是一个灾难，Actiont就是

他的边界，到此为止！

Action(Web Control) ---> Business Bean ---> DAO ---> ORM --->DB

而PO则是业务层和持久层的数据表示，它在业务层和持久层之间进行流动，他不应该也不能被传递到Web

层的View中去，而ActionServlet就是他的边界，到此为止！

然后来看一看整个架构的流程：

当用户通过浏览器访问网页，提交了一个页面。于是Action拿到了这个FormBean，他会把FormBean属性

读出来，然后构造一个PO对象，再调用业务层的Bean类，完成了注册操作，重定向到成功页面。而业务

层Bean收到这个PO对象之后，调用DAO接口方法，进行持久对象的持久化操作。

当用户查询某个会员的信息的时候，他用全名进行查询，于是Action得到一个UserNameFormBean包括了3

个属性，分别是first name, middle name, last name，然后Action把UserNameFormBean的3个属性读出

来，构造Name对象，再调用业务Bean，把Name对象传递给业务Bean，进行查询。

业务Bean取得Name(注意: Name对象只是User的一个属性)对象之后调用DAO接口，返回一个User的PO对象

，注意这个User不同于在Web层使用的UserFormBean，他有很多集合属性滴。然后业务Bean把User对象返

回给Action。

Action拿到User之后，把User的基本属性取出(集合属性如果不需要就免了)，构造UserFormBean，然后

把UserFormBean request.setAttribute(...)，然后重定向到查询结果页面。

查询页面拿到request对象里面的ActionFormBean，自动调用tag显示之。

总结：

FormBean是Web层的数据表示，他不能被传递到业务层；PO是持久层的数据表示，在特定情况下，例如

Hibernate中，他可以取代VO出现在业务层，但是不管PO还是VO都必须限制在业务层内使用，最多到达

Web层的Control，绝不能被扩散到View去。

FormBean和PO之间的数据转化是在Action中进行滴。

BTW:

JDO1.x还不能像Hibernate功能这样强大，PO不能脱离持久层，所以必须在业务层使用VO，因此必须在业

务层进行大量的VO和PO的转化操作，相对于Hibernate来说，编程比较烦琐。

当然咯，理论是一回事，实际操作也不一定非要这样干，你可以自行取舍，在实际项目中灵活一点，增

加一点bad smell，提高开发效率。只不过在大型项目中最好还是严丝合缝，不然的话，改版的时候会痛

苦的很滴。
（转载：http://forum.hibernate.org.cn/viewtopic.php?t=627）

posted @ 2006-08-16 13:51 阿成 阅读(523) | 评论 (0) | 编辑 收藏
JfreeChart学习总结
     摘要: 自己最近学习了JfreeChart的使用，觉得这个冬冬的功能非常强大，总结一下。一、简单介绍一下    WW 的发展使得基于因特网的应用程序不再局限于静态或者简单的动态内容提供。传统的一些以软件包形式发布应用程序例如报表系统等都在逐渐搬到因特网上。但是这两者之间有着天壤之别，虽然对于数据获取、业务处理等方面基本类似，但是最大的差别在于用户界面。为了能在web浏览器上显示要求用户界面使用 ...  阅读全文
posted @ 2006-08-16 10:44 阿成 阅读(964) | 评论 (0) | 编辑 收藏
使用POI向Excel中插入图片实例
前面已经讲过利用POI读写Excel，下面是一个用POI向Excel中插入图片的例子。

官方文档：
Images are part of the drawing support. To add an image just call createPicture() on the drawing patriarch. At the time of writing the following types are supported:
PNG
JPG
DIB
It is not currently possible to read existing images and it should be noted that any existing drawings may be erased once you add a image to a sheet.

// Create the drawing patriarch. This is the top level container for
// all shapes. This will clear out any existing shapes for that sheet.

通过HSSFPatriarch类createPicture方法的在指定的wb中的sheet创建图片,它接受二个参数，第一个是HSSFClientAnchor，设定图片的大小。

package com.poi.hssf.test;

import java.io.FileOutputStream;
import java.io.File;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import java.awt.image.BufferedImage;
import javax.imageio.*;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;;

public class TestPOI {

    public static void main(String[] args) {
            FileOutputStream fileOut = null;
            BufferedImage bufferImg =null;
            BufferedImage bufferImg1 = null;
            try{
                
          //先把读进来的图片放到一个ByteArrayOutputStream中，以便产生ByteArray
          ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
          ByteArrayOutputStream byteArrayOut1 = new ByteArrayOutputStream();
          bufferImg = ImageIO.read(new File("d:/PieChart.jpg"));
          bufferImg1 = ImageIO.read(new File("d:/fruitBarChart.jpg"));
          ImageIO.write(bufferImg,"jpg",byteArrayOut);
          ImageIO.write(bufferImg1,"jpg",byteArrayOut1);
          
        //创建一个工作薄
        HSSFWorkbook wb = new HSSFWorkbook();
        HSSFSheet sheet1 = wb.createSheet("new sheet");
        //HSSFRow row = sheet1.createRow(2);
        HSSFPatriarch patriarch = sheet1.createDrawingPatriarch();
        HSSFClientAnchor anchor = new HSSFClientAnchor(0,0,512,255,(short) 1,1,(short)10,20);
        HSSFClientAnchor anchor1 = new HSSFClientAnchor(0,0,512,255,(short) 2,30,(short)10,60);
        anchor1.setAnchorType(2);
        //插入图片
        patriarch.createPicture(anchor , wb.addPicture(byteArrayOut.toByteArray(),HSSFWorkbook.PICTURE_TYPE_JPEG));
        patriarch.createPicture(anchor1 , wb.addPicture(byteArrayOut1.toByteArray(),HSSFWorkbook.PICTURE_TYPE_JPEG));
        
            fileOut = new FileOutputStream("d:/workbook.xls");
            //写入excel文件
            wb.write(fileOut);
            fileOut.close();
        
            }catch(IOException io){
                    io.printStackTrace();
                    System.out.println("io erorr :  "+ io.getMessage());
            } finally
            {
                if (fileOut != null)
                {
                           
                    try {
                              fileOut.close();
                         }
                    catch (IOException e)
                    {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                     }
                }
            }
    }
}

posted @ 2006-08-16 09:09 阿成 阅读(2971) | 评论 (4) | 编辑 收藏
使用POI HSSF操作Excel总结

利用Java 操作Excel文档(POI方法)

一．POI简介

Jakarta POI 是apache的子项目，目标是处理ole2对象。它提供了一组操纵Windows文档的Java API

目前比较成熟的是HSSF接口，处理MS Excel（97-2002）对象。它不象我们仅仅是用csv生成的没有格式的可以由Excel转换的东西，而是真正的Excel对象，你可以控制一些属性如sheet,cell等等。

二．HSSF概况

HSSF 是Horrible SpreadSheet Format的缩写，也即“讨厌的电子表格格式”。 也许HSSF的名字有点滑稽，就本质而言它是一个非常严肃、正规的API。通过HSSF，你可以用纯Java代码来读取、写入、修改Excel文件。

HSSF 为读取操作提供了两类API：usermodel和eventusermodel，即“用户模型”和“事件-用户模型”。前者很好理解，后者比较抽象，但操作效率要高得多。

三．开始编码

1 ． 准备工作

要求:JDK 1.4+POI开发包

可以到 http://www.apache.org/dyn/closer.cgi/jakarta/poi/ 最新的POI工具包

2 ． EXCEL 结构

HSSFWorkbook excell 文档对象介绍
HSSFSheet excell的表单
HSSFRow excell的行
HSSFCell excell的格子单元
HSSFFont excell字体
HSSFName 名称
HSSFDataFormat 日期格式
在poi1.7中才有以下2项：
HSSFHeader sheet头
HSSFFooter sheet尾
和这个样式
HSSFCellStyle cell样式
辅助操作包括
HSSFDateUtil 日期
HSSFPrintSetup 打印
HSSFErrorConstants 错误信息表

3 ．具体用法实例 （采用 usermodel ）

如何读Excel

读取Excel文件时，首先生成一个POIFSFileSystem对象，由POIFSFileSystem对象构造一个HSSFWorkbook，该HSSFWorkbook对象就代表了Excel文档。下面代码读取上面生成的Excel文件写入的消息字串：
POIFSFileSystemfs=newPOIFSFileSystem(new FileInputStream("d:\test.xls"));
HSSFWorkbook 　wb = new HSSFWorkbook(fs);
　　} catch (IOException e) {
　　e.printStackTrace();
　　}
　　HSSFSheet sheet = wb.getSheetAt(0);
　　HSSFRow row = sheet.getRow(0);
　　HSSFCell cell = row.getCell((short) 0);
　　String msg = cell.getStringCellValue();

如何写excel，

将excel的第一个表单第一行的第一个单元格的值写成“a test”。

POIFSFileSystem fs =new POIFSFileSystem(new FileInputStream("workbook.xls"));

    HSSFWorkbook wb = new HSSFWorkbook(fs);

    HSSFSheet sheet = wb.getSheetAt(0);

    HSSFRow row = sheet.getRow(0);

    HSSFCell cell = row.getCell((short)0);

    cell.setCellValue("a test");

    // Write the output to a file

    FileOutputStream fileOut = new FileOutputStream("workbook.xls");

    wb.write(fileOut);

fileOut.close();

4 ． 可参考文档

POI 主页：http://jakarta.apache.org/poi/，

初学者如何快速上手使用POI HSSF

http://jakarta.apache.org/poi/hssf/quick-guide.html 。

代码例子 http://blog.java-cn.com/user1/6749/archives/2005/18347.html

里面有很多例子代码，可以很方便上手。

四．使用心得

POI HSSF 的usermodel包把Excel文件映射成我们熟悉的结构，诸如Workbook、Sheet、Row、Cell等，它把整个结构以一组对象的形式保存在内存之中，便于理解，操作方便，基本上能够满足我们的要求，所以说这个一个不错的选择。

 

posted @ 2006-08-16 09:00 阿成 阅读(5398) | 评论 (0) | 编辑 收藏
秦皇岛之游
8月6号、7号到秦皇岛旅游，玩的挺爽的。

去了鸽子窝和野生动物原，还不错。还有就是到海边游泳，第一次看海。海水很咸。

螃蟹、龙虾吃的也非常过瘾，个大得很，呵呵。

不知明年还有没机会去。
posted @ 2006-08-15 20:10 阿成 阅读(236) | 评论 (0) | 编辑 收藏
J2EE WEB程序员应该掌握的技术
html ，css ，js ，jsp， jdbc， sql ，会java，懂web框架， 数据库 ,会用google
posted @ 2006-06-20 17:25 阿成 阅读(230) | 评论 (0) | 编辑 收藏
javascript编程起步（一至七课）－－ZT（http://bbs.javascript.com.cn/index.php）

javascript编程起步（第一课）
不管你以前学没有学过javascript，本教程都能带您进入javascript的殿堂，领悟javascript的魅力。
  大家来到这里，都是javascript的爱好者，对javascript都多多少少有一定的理解。关于javascript
的历史等就不做介绍了，我们直接来学习它，用它。
  也许大部分人都认为javascript是在客户端运行的，其实不然。javascript有两种不同的运行环境，
一个是在服务器端的javascript，另一个就是客户端的javascript了。还有就是javascript也是面向对象
的语言。
  作为第一课，只是给大家一个简单的认识，东西不是太多。主要有以下三个方面：
  1、在页面添加javascript
  2、javascript的数据类型
  3、javascript最基本的三个对话框

  关于怎么添加javascript，我想大家都知道，就是
  <script language="javascript">   //这行是javascript脚本标记，斜杠后面的就是注释了
  document.write("在页面显示的javascript") //在页面显示一句话
  </script>
  /*这也是注释，
    不过是多行的。
  */
  我想这个今天就不细讲了，留到下一课讲，就当是这课的作业吧，就是关于适应各种环境的javascript
的添加。如不支持javascript的浏览器，我们该加入些什么才能不让浏览器显示javascript的源代码等等。

  第二个也就是今天讲的最重要的一个，就是javascript的数据类型，主要有以下几个基本的类型。
  字符串（string）
  数字（number）
  布尔值（boolean）
 
  字符串就是由一连串的字符组成的序列。包括字母、数字以及标点符号。当然还可以是汉字等。简单一点
就是表示文本信息。

  数字又分为两类：整型数字和浮点型数字。
  整数包括正整数，零和负整数。

  javascript中的数字可以使用十进制、八进制和十六进制来书写。方法如下：
  十进制：15（直接写数字即可）
  八进制：017（要以零做为引导数字）
  十六进制：0xf（要以0x做为引导数字）

  浮点型数字也叫实数，为了方便，也可以使用科学记数法来表示：
  1.13e1、1.5e3（等价于1.5乘10的3次方）
  javascript的数字范围大约为10的负308次方到10的308次方之间。
  javascript中还有一个特殊的数字值NaN（not a number），javascript 用nan表示这个无意义的结果。

  布尔值：true和false，在计算机中一般用1表示true，用0表示false。

  空值就是null，即不表示任何东西。
  未定义值undefined，有时等于null，有时可能是出了问题。
  特殊字符：也叫转义字符。是一些以反斜杠开头的不可显示的特殊控制字符。
  \b:表示退格
  \n:表示换行
  等等。

  alert()方法的使用：
  <script language="javascript">
  alert("在页面上显示警告对话框");
  </script>
  alert()是javascript产生一个带确认按钮的对话框，上面显示括号内的信息。

  confirm()方法的使用：
  <script language="javascript">
  confirm("在页面上显示确认对话框");
  </script>
  confirm()和alert()差不多，不同的就是多了个取消按钮。按确定返回true，按取消返回false。
  <script language="javascript">
  var con;
  con=confirm("你们喜欢这样的教程吗？");
  if (con==true) alert("喜欢");
  else alert("不喜欢");
  </script>

  prompt()方法的使用：
  <script language="javascript">
  var name,age;
  name=prompt("请问您的名字？");
  alert(name);
  age=prompt("多大？");
  alert(age);
  </script>
  它不但可以显示信息，而且可以输入信息。
----------------------------------------------------------------------------------------
javascript编程起步（第二课）

关于上课的作业，大家都知道，代码如下：
  <script language="javascript">
  <!--
  代码
  //-->
  </script>
  这儿补充一点内容，还可以告诉读者这儿是javascript代码，该浏览器不支持。
  <noscript>
  在浏览器不支持的时候显示这句话
  </noscript>
  今天我们主要学习的内容有以下几块：
  1、javascript变量
  2、javascript表达式和运算符

  可以用var加上为变量指定的名称来声明变量，变量类型可以通过给变量赋值来确定。由于javascript采用的是弱类型的样式，对数据类型要

求不太严格，在程序执行的过程中，会根据需要自动转换。
  对于字符串变量，可以通过“变量名.length”来获得该变量中字符串的长度，如
  var name;
  name="javascript";
  那么name.length的值就是10。

  若在一行中创建多个变量时，记住用逗号来隔开变量名。各语句用分号隔开。(使用分号是个好习惯, 大家在学习的时候尽量养成加分号的习

惯)
 
  类型转换：javascript允许在程序中改变变量的类型，最常见的两个类型转换符Number和String。
  Number(x)是字符型值——〉数字值型。String与之相反。相对于javascript的自动类型转换，可以将这种转换成为强制类型转换。（强制类

型转换需要在javascript1.2及以上版本才可以使用）

  变量的命名：

  1.必须以字母或下划线开头，中间可以有字母数字和或下划线。不能使用空格、+、-等其他符号。
    作为连字符外，变量名称不能有空格、（＋）、（－）、（，）或其它符号。
  2.不能使用JavaScript中的关键字作为变量。
  （javascript变量名是区分大小写的，name和Name是不一样的。）

  对于变量还有一个重要性──那就是变量的作用域。在JavaScript中同样有全局变量和局部变量。全局变量是定义在所有函数体之外，其作

用范围是整个函数；而局部变量是定义在函数体之内，只对其该函数是可见的，而对其它函数则是不可见的。

  例子：
<script>
var myStr = "我是全局变量";
function getStr1(){
     var myStr = "我是局部变量";
     alert (myStr);
}
function getStr2(){
     alert (myStr);
}
getStr1();
getStr2();
// 测试会弹出两个提示框，第一个提示“我是局部变量”，第二个提示“我是全局变量”
</script>


  表达式：在定义完变量后，就可以对它们进行赋值、改变、计算等一系列操作，这一过程通常由表达式来完成，可以说它是变量、常量、布

尔及运算符的集合，因此表达式可以分为算术表述式、字串表达式、赋值表达式以及布尔表达式等。
 

  运算符：

  1.算术运算符：+（加） 、-（减）、 *（乘）、 /（除）、 %（取模） -（取反）、
            ++（递加1）、--（递减1）。
            例：11%2=1 ； 如果x=2   ++x+4=7     x+++4=6
          （++x是先执行加1，x++是执行完语句之后x在自加1
例子：

<script>
var i=0, j=0;
alert(i++ + " " + ++j + " " + i);
// 输出 “0 1 1”，可见i++是先输出了i，然后进行运算，而++j是先对j进行了自加运算，然后输出j的值
</script>
）
  2.比较运算符：<(小于)、>(大于)、<=(小于等于)、>=(大于等于)、==(等于)、!=(不等于)
          （基本操作过程是，首先对它的操作数进行比较，然后再返回一个true或False值。）
  3.逻辑运算符：!（取反)、&=（与之后赋值）、 &（逻辑与）、 |=（或之后赋值）、 |（逻辑或）、
            ^=（异或之后赋值）、 ^（逻辑异或）、 ?:（三目操作符）、||（或）、&& （与）
            ==(等于)、|=(不等于)。
  4.字符串运算符：只有+   （”my“+”javascript“结果等于”my javascript“）
  5.赋值运算符：即=，将右边的值赋给左边的变量。
  6.条件运算符：（？：）
            例：status=(age>=18)?"adult":"child";如果大于18，则表达式的值为adult。
  7.typeof()运算符：用来返回变量或数据的类型。

 

作业：试试能不能做个最最最最简单的计算器？
    （就是我可以输入两个数和一个运算符号，就得出计算结果。结合上一课的prompt()）
答案：
<script language="javascript">
function yunshuan(a,op,c)
{
try{
  eval("result=a"+op+"c");
  return result;
}
catch(e){
  alert("Some error occur");
}
}
function main(){
var a,b,c;
a=parseInt(prompt("请输入第一个数"));
op=prompt("请输入运算符");
c=parseInt(prompt("请输入第二个数"));
alert("the result is :" + yunshuan(a,op,c));
}

</script>
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
javascript编程起步（第三课）

第三课终于和大家见面了, 大家要感谢 Actions 的辛勤劳动啊, 好好利用论坛给大家提供的资源和教程, 希望大家一起学习提高 :D
大家有什么意见, 建议或者想法, 可以到本版的教程问答区 或 站务管理版的 建议或意见 去发表, 我们会及时给您反馈 :)

下面是今天的学习重点：
A.补充上课的变量内容
B.if语句的基本语法
C.window.com()基本用法

A.变量
1.变量的类型规则
javascript是无类型的，他的变量可以放任何数据类型的值。
2.变量的声明
在javascript程序中，在使用变量之前，必须先声明它。变量是使用关键字var声明的。而实际上，不一定要先声明变量，在某些情况下，变量

声明是可选的。
var i；
var sum；
也可以使用一个var关键字声明多个变量；
var i，sum；
而且还可以将变量声明和变量初始化绑定在一起：
var message = 'hello'；
var i = 0，j=0，k=0；
由var声明的变量是永久的，因为各浏览器对是否可以删除全局性的变量的态度是不同的，（都可以删除局部变量）为了安全，最好假设全局变

量不可删除。
可以使用var多次声明同一个变量
当你给一个没有声明的变量赋值时，js会自动用哪个变量为你创建一个全局变量。
如果你想在函数内部创建一个局部变量。那就必须用var在函数内部声明。
3.变量的作用域
如果局部变量和全局变量重名，则局部变量优先。js没有块级作用域。函数中声明的所有的变量，作用域是相同的。
var x；//声明一个未赋值的变量，他的值是undefined。
alert（u）; //使用未声明的变量将引发错误。
u=3；//给一个未声明的变量赋值将会创建该变量。
4.原始类型和引用类型
var a=3.14；//原始类型
var b=a；//引用类型

B.if语句

if (条件)
语句段１
else
语句段２

　功能：若表达式为true，则执行语句段１；否则执行语句段２。

　说明：
if -else 语句是JavaScript中最基本的控制语句，通过它可以改变语句的执行顺序。
表达式中必须使用关系语句，来实现判断，它是作为一个布尔值来估算的。
它将零和非零的数分别转化成false和true。
若if后的语句有多行，则必须使用花括号将其括起来。

例子
if (age < 16 )
     alert("小朋友");
else
     alert("成年人");
end if

if语句的嵌套
if (布尔值) 语句１；
else if (布尔值) 语句２；
else if (布尔值) 语句３；
else 语句４；
在这种情况下，每一级的布尔表述式都会被计算，若为真，则执行其相应的语句，否则执行else后的语句。

C.window.com()的用法
  1、基本语法
  window.open(pageURL,name,parameters)
  其中：
    pageURL 为子窗口路径
    name 为子窗口句柄
    parameters 为窗口参数(各参数用逗号分隔)
  例：
      <SCRIPT LANGUAGE="javascript">
      <!--
      window.open ('url') //url为一网址，如：http://www.numb1.com（绝对） 或 index.htm相对）
      -->
      </SCRIPT>
  2. 窗口参数
  其中yes/no也可使用1/0；value为具体的数值，单位象素。
  toolbar=yes,no 是否显示工具条
  location=yes,no 是否显示网址栏
  directories=yes,no 是否显示导航条
  status=yes,no 是否显示状态条
  menubar=yes,no 是否显示菜单
  scrollbars=yes,no 是否显示滚动条
  resizable=yes,no 是否可以改变公告窗口大小
  copyhistory=yes,no 是否显示历史按钮
  width=value 公告窗口的宽
  height=value 公告窗口的高
  left=value 公告窗口的左上顶点距屏幕左边100像素
  top=value 公告窗口的左上顶点距屏幕顶端100像素
  例：
<script language="javascript">
<!--
window.open("http://www.sina.com.cn","newwindow",

"toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=no,resizable=no,copyhistory=no,width=500,height=500,le

ft=100,top=100")
//-->
</script>
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
javascript编程起步（第四课）

前一段有人给我说，第二课就看不明白了，我不知道是不是写的太笼统了，不够细致，还是其他的，有什么问题，大家给提出来，当然我也不

是什么js高手，只不过想把爱好者领进门而已。希望大家多多参与。
今天的主要任务就是for循环。另外就是数据类型。既for in（现在还没有讲数组和对象，先了解一下）。

数据类型的转换：
如果运算的数据类型不是一样的话，js脚本会尽力执行内部转换来解决，但js不了解你的心思。所以得到的结果可能和你想要的不一样。
em：
  3+3   // result=6
  3+"3"   // result="33"

将字符串转换为数值：
javascript语言提供两个内置函数将表示数值的字符串转换为真实的数值：parseInt()和parseFloat()。
为了使用这些函数，需要将进行转换的字符串作为参数传入函数，例：
parseInt("42")     //result=42
parseInt("42.33")   //result=42
不过是浮点数还是整数，函数返回的值都是整数。不存在四舍五入，小数点和它后面的数字将被舍弃。
而parseFloat()则返回浮点数（如果是整数就返回整数），例：
parseFloat("42")   //result=42
parseFloat("42.33") //result=42.33
如果在某处需要进行字符串的转换，只需将函数插入该初即可。如：
3+3+parseInt("3")   //result=9

将数值转换为字符串：
虽然当遇到表达式中含有混合数据类型时，js会倾向于字符串。但为了防止潜在的问题发生，最好先转换以下。在数值中加入空字符串就可以

把数值转换为字符串了：
(""+2500)         //result="2500"
(""+2500).length   //result=4


for:
javascript中最常用的循环结构称之为for循环，关键词放在循环结构的开始位置。正式语法结构如下：
for ([initial expression];[condition];[update expression]){
  statement[s] inside loop
}
例：
for(var i=0;i<9;i++)
{
n+=i
myfunc(n)
}
for...in:
这个语句完全依照变量var所设定的值决定运行次数。你可以用for...in语句在一个对象或一个数组上建立循环
for(var in [obj | array])
{
statements
}
例：
<script language="javascript">
document.writeln("The properties of the document object")
for(var element in document){
document.writein(element+"="+document[element])
}
</script>

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
javascript编程起步（第五课）


鼠标事件（上）

  随着课程的进行，能跟着下来的人是越来越少了，不知道是不是因为没有太多的表现，只是死记的东西，大家都没有兴趣啊。其实网页上

的很多特效，动作大都是用javascript来实现的，没有javascript的网页，就象一个人没有了肌肉一样。但是所有的动作都是有函数来控制的

，而控制语句是基础中的基础。希望大家能耐心的学下去。今天的课程就轻松一下，学习点能见到效果的。
主要内容就是基于鼠标的事件,有如下几种：
1.mouseover（鼠标移至）
2.mouseout（鼠标移出）
3.mousemove（鼠标移动）
4.mousedown（鼠标按下）
5.mouseup（鼠标弹起）
6.click（单击）
7.dblclick（双击）

  通常1和2组合起来使用，当用户把鼠标移动到一个超链接或者其他元素时，mouseover事件就会发生，mouseout总会伴随着它，因为当鼠标

离开时，mouseout事件就会发生。
  例子：
<html>
<head>
<title>test</title>
<script language="javascript">
function text_onmouseover(){
mytext.style.fontSize="30pt";
mytext.style.color="red";
mytext.style.fontStyle="italic";
}
function text_onmouseout(){
mytext.style.fontSize="20pt";
mytext.style.color="blue";
mytext.style.fontStyle="normal";
}
</script>
</head>
<body>
<p id=mytext onmouseover="text_onmouseover()" onmouseout="text_onmouseout()">http://www.javascript.com.cn</p>
<p>看看字体样式有什么变化</p>
</body>
</html>

  这里定义了两个函数，来使字体改变样式。关于函数我们以后会详细的讲解。
（注意：ie对页面上的所有元素都支持mouseover和mouseout事件，但对于netscape navigator来说，只有超链接和层支持这两个事件。）

下面看鼠标移动的例子：
<html>
<body onMousemove="micro$oftMouseMove()">
<SCRIPT LANGUAGE="JavaScript">
if (navigator.appName == 'Netscape')
{
document.captureEvents(Event.MOUSEMOVE);
document.onmousemove = netscapeMouseMove;
}

function netscapeMouseMove(e) {
if (e.screenX != document.test.x.value || e.screenY != document.test.y.value)
{
document.test.x.value = e.screenX;
document.test.y.value = e.screenY;
}
}

function micro$oftMouseMove() {
if (window.event.x != document.test.x.value || window.event.y != document.test.y.value)
{
document.test.x.value = window.event.x;
document.test.y.value = window.event.y;
}
}
</SCRIPT>
<FORM NAME="test">
X: <INPUT TYPE="TEXT" NAME="x" SIZE="4"> Y: <INPUT
TYPUE="TEXT" NAME="y" SIZE="4">
</FORM>
</body>
</html>
鼠标移动的事件在鼠标跟随效果的使用上比较多，大家可以看看鼠标跟随特效。网上n多。
（需要注意的是：启动这个事件处理过程存在一个问题，就是它有可能会屏蔽其他事件。另外还增加了页面的处理时间，应尽量少用。）

先说到这儿吧，下节讲鼠标的另外4个事件。


今天的作业是：
1.图片链接的转换（当鼠标放上去时是一个图片，当鼠标离开时是另外一个图片）
2.图片跟随鼠标（当鼠标移动时，会有个图片跟随着鼠标一起移动）
1题答案：
<html>
<body>
<script language="javascript">
   function change()
   {
       //document.test.tupian.src="1.bmp";用test和form[0]都可以
    document.form[0].tupian.src="1.bmp";
   }
   function changeback()
   {
       //document.test.tupian.src="2.bmp";
    document.form[0].tupian.src="1.bmp";
   }
</script>
<form name="test">
<a name="aa" href="http://www.xxx.com" onmouseover="change();" onmouseout="changeback();"><img name="tupian"

src="3.jpg"/></a>
</form>
</body>
</html>
---------------------------------------------------------------------------------------------------
javascript编程起步（第六课）

mouseDown事件和mouseUp事件
 

大家知道，mouseDown事件和mouseUp事件的组合就是click事件，但是如果在链接上按下鼠标，并移到链接之外在放开鼠标，那么就只有mouseD

own事件了。这两个事件可以增加图标按钮的图像效果，
  至于mouseDown和mouseUp的属性，它们是伴随着Click事件发生的，这和keyPress事件是keyDown事件和keyUp事件组合而成的机制是一样的

，这3个鼠标事件也有modifier属性。
  （注意：如果在onClick事件处理中使用return语句，它可以接收任何数值。只要这个值不是False，浏览器就可以完成提交。但如果浏览

器得到的是False值，表单提交操作就会被取消。）

Click事件和dbClick事件
  onClick是单击事件，onDblClick是双击事件，而实际上很难分清连续的单击和双击。它们会互相干扰。而且在ie和其他浏览器的情况还有

不同。有的浏览器是双击事件的每一次单击都会触发单击事件，而在ie中，只有双击事件的第一次单击会触发单击事件。不管怎么样，单击事

件都不会自动的取消或被忽略。因此，如果想使用单击和双击一个链接时触发两个完全不同的过程，则必须通过编程来延迟单击的动作知道双

击。

例：
<script>
var timer=null;
document.onclick=new Function("timer=setTimeout(click,500)")
document.ondblclick=new Function("clearTimeout(timer);dblclick()")
function click(){
alert("click")
}
function dblclick(){
alert("dblclick")
}
</script>

解释：
new Function("timer=setTimeout(click,500)")
新建一个函数，内容为
timer=setTimeout(click,500)
setTimeout(函数或语句，时间以毫秒为单位)
用于设置某函数或语句在某时间后执行，……
clearTimeout(timer);
清除设置，

  在高版本的浏览器中，链接的这两种事件处理程序都监视那些使得脚本阻止链接的特殊行为。
  例如：在想要的导航到另一个页面之前进行某些数据项的确认，如果某些域填得不正确，可以提醒并终止链接。要实现这种确认，必须在

事件处理程序得最后一条语句或者事件处理程序自身返回True或False。如果返回False就终止链接。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
javascript编程起步（第七课）

过年到现在一直都比较忙,辜负大家了.
今天就学习函数吧,虽然语句还没有说完.

函数是javascript语言的一个很重要的内容,但也很复杂.
下面来看看javascript函数.
函数是有function加函数名和一对带有参数括号,以及大括号组成的，其中大括号里是
主体javascript语句.
例:
function hanshuname(js) //hanshuname是函数名.
{
document.write(js,"<br>"); //是函数的主体语句.
}
函数可以嵌套,如下:
function qiantao(a,b){
function lqiantao(x){return x*x;}
return Math.sqrt(lqiantao(a)+lqiantao(b));
}
函数还可以作为数据来应用,因此可以象处理其他数据那样来处理函数,如:赋值,存储,传递等.
例:
function zhi(x){return x*x;}
实际上,函数名没有什么意义,不过是保存函数的变量名而已.
a=zhi(6);//a存放的是数字36;
b=zhi;//现在b和zhi引用同一个函数.
c=b(5);//c存放的是数字25.
在一个函数体内,标识符arguments总是具有特殊含义,它是调用对象的一个特殊属性,用来引用实际参数对象.这个实际参数对象具有大量有用的

属性.除此之外,它还兼有数组的角色.
尽管定义javascript函数时都有固定的参数，但调用这个函数时,传递给它的参数数目却可以是任意的，数组arguments[]允许完全存取那些实

际参数值.另外,arguments有一个length属性,看如下例子:
function zhi(x,y,z)
{
if(arguments.length !=3){
alert("function zhi called with"+arguments.length+"arguments,but it expects 3 arguments.");
return null;
}
}
数组arguments[]还为javascript函数开发了一项重要的可能性,既可以将函数编写为能够接受任意数目的实际参数.
function zhi()
{
var m=Number.NEGATIVE_INFINITY;
//遍历所有参数
//检索并记忆最大的一个.
for(var i=0;i<arguments.length;i++)
if(arguments>m)m=arguments;
//返回最大的参数值.
return m;
}
var lazgest=zhi(1,10,100,2,3,1000,4,5,10000,6);
也可以使用arguments[]数组来编写一个函数.


调用js函数
<a href=”#” onClick=”functionName()”>Link text</a>
<a href=”javascript:functionName()”>Link text</a>
今天先说到这儿吧,下节继续说函数.

posted @ 2006-06-13 17:30 阿成 阅读(521) | 评论 (0) | 编辑 收藏
读取配置文件的几种方法 －ZT（zhaijianhui的blog）
在读spring in aciton 时，他用的BeanFactory factory = new XmlBeanFactory(new FileInputStream("hello.xml"));
可是现在的用的1.2.6版本的构造器(XmlBeanFactory)只能接收Resource接口了，所以调不出来是正常的事情，假设现在有一个文件hello.xml
读取方法

1:ApplicationContext cx=new FileSystemXmlApplicationContext("hello.xml");//指定的路径去找文件
2:ApplicationContext factory = new ClassPathXmlApplicationContext("hello.xml");//还会在classpath去找
3:Resource fa = new FileSystemResource("hello.xml");
   BeanFactory factory=new XmlBeanFactory(fa);
4:这个要设制classpath了，麻烦
　 Resource res = new ClassPathResource("com/springinaction/chapter01/hello/hello.xml");
　 BeanFactory factory=new XmlBeanFactory(res);
好了，用了上面那种方法都可以调用getBean("your bean name")了，
eg: BeanFactory factory=new XmlBeanFactory(fa);
      hello he=(hello)factory.getBean("hello");
              he.getHello();
posted @ 2006-06-08 09:12 阿成 阅读(256) | 评论 (0) | 编辑 收藏
运动会
5月中旬公司开运动会了，报了四百米，铅球，接力。

那天天气很好，很热闹。投铅球的现场很多人，都是懒得报别的项目，到那混的。

我挤了半天，居然都没扔上，没人只扔两次，只能继续别的项目。

下午跑四百时还挺热闹的，不过刚上班不到一年，身体大不如以前，都跑不动了。

四个人跑第三。

后来，接力我们组的人没找全，所以没跑。不过，看到还是有很多很有实力的人。

赛后还给了奖品。有的同事那个好几个奖，好几个项目都有名次。

看来以后得经常坚持锻炼。
posted @ 2006-06-07 11:09 阿成 阅读(262) | 评论 (1) | 编辑 收藏
低调低调！
记住，一定要低调，刚会点东西就浮躁怎么行，要经常提醒自己低调，低调。

明言：枪打出头鸟，人怕出名猪怕壮。
posted @ 2006-06-07 10:58 阿成 阅读(208) | 评论 (0) | 编辑 收藏
最全的世界汽车标志欣赏和LOGO释义
     摘要: 美洲豹 美洲豹汽车公司原是利兰汽车公司的分部，素以生产豪华的美洲豹 ( 又称捷豹 ...  阅读全文
posted @ 2006-05-23 08:47 阿成 阅读(250) | 评论 (0) | 编辑 收藏
用Validator检查你的表单

用Validator（验证器）提供的丰富的内置验证方法简化Struts的开发过程。

Struts框架的一个主要好处是它提供了对接收到的表单数据进行验证的内置界面。如果有任何验证失败，则应用程序都会重新显示HTML表单，这样就可以改正无效的数据了。如果验证成功，则处理过程会继续进行。Struts框架的简单验证界面会减少与处理数据验证有关的令人头疼的事情，这样你就可以把精力集中到验证代码上，而不是放到捕获数据、重新显示不完整或无效数据的技巧上。

但是，Struts内置的验证界面也有缺点。例如，在整个应用程序中验证代码常常会大量重复，因为许多域需要相同的验证逻辑。对一些相似字段的验证逻辑进行任何修改都要求在几个地方修改代码，还要重新编译受影响的代码。为了解决这个问题并增强Struts验证界面的功能，作为Struts的第三方附加件创建了Validator框架。后来，Validator被集成到核心Struts代码库中，并从Struts中分离出来，现在它是一个独立的Jakarta Commons项目。虽然Validator是一个独立的框架，但它仍能与其他程序封装在一起后提供，并与Struts无缝集成。

Validator概述

没有Validator，你就不得不编写验证表单数据所需的全部代码，并把它放入Form Bean对象的validate( )方法中。对于想在其上进行数据验证的每个Form Bean域来说，都需要编写逻辑代码来实现验证。此外，你还必须编写代码来存储验证失败时的出错消息。

有了Validator，你就不必在Form Bean中编写用于验证或存储错误消息的任何代码。相反，Form Bean提供了Validator的一个ActionForm子类，它提供验证或存储错误消息的功能。

可把Validator框架作为一个可用于Form Bean验证的可插入的验证例行程序系统来进行安装。每个验证例行程序都只是一个Java方法，负责执行特定类型的验证任务，验证可能通过，也可能失败。 默认情况下，Validator与几个有用的验证例行程序封装在一起来提供，这些例行程序能满足大多数情况下的验证要求。但是，如果Validator框架没有提供你需要的验证例行程序，那么你可以自己创建定制的验证例行程序，并将它插入到该框架中。此外，Validator还支持服务器端和客户端（JavaScript）的验证，而Form Bean只提供服务器端验证界面。

Validator使用两个XML配置文件来分别确定安装哪个验证例行程序和如何将它们应用于给定的应用程序。第一个配置文件validator-rules.xml说明应该被插入到框架中的验证例行程序，并提供每个验证的逻辑的名称。validator-rules.xml文件还定义了每个验证例行程序的客户端JavaScript代码。可以配置Validator让它把这个JavaScript代码发送到浏览器上，这样验证就可以在客户端和服务器端进行了。

第二个配置文件validation.xml确定哪个验证例行程序应用到哪个Form Bean。文件中的定义使用struts-config.xml文件给出的Form Bean的逻辑名称以及validator-rules.xml文件给出的验证例行程序的逻辑名称，以便把二者关联起来。

使用Validator框架包括启用Validator插件、配置Validator的两个配置文件，以及创建提供Validator的ActionForm子类的Form Beans。下面详细解释如何配置和使用Validator。

启用Validator插件

虽然Validator框架是与Struts封装在一起提供的，但在默认状况下Validator并不被启用。为了启用Validator，要向你的应用程序的struts-config.xml文件中添加下面的插件定义。 

<!-- Validator Configuration -->
<plug-in className="org.apache.struts
.validator.ValidatorPlugIn">
  <set-property property="pathnames"
               value="/WEB-INF/
  validator-rules.xml, /WEB-INF/

  validation.xml"/>
</plug-in>

该定义告诉Struts为你的应用程序加载并初始化Validator插件。在初始化时，该插件装入由路径名属性指定的、用逗号分隔的Validator配置文件清单。每个配置文件的路径应该用与Web应用程序的相关的路径来指定，如前面的例子所示。

请注意，你的应用程序的struts-config.xml文件必须与Struts Configuration Document Type Definition（Struts配置文档类型定义，DTD）一致，后者规定文件中元素出现的顺序。所以，你必须把Validator插件定义放到该文件的适当位置。确保文件中元素适当排列的最简便方法就是使用诸如Struts Console的工具，它自动格式化你的配置文件，以便与DTD保持一致。

配置validator-rules.xml

Validator框架可以设置为可插入系统，其验证例行程序仅仅是插入到该系统中执行具体验证的Java方法。validator-rules.xml文件说明性地插入Validator用于执行验证的验证例行程序中。Struts示例应用程序带有这个文件的预配置拷贝。在大多数情况下，你不必修改这个预配置拷贝，除非你要向该框架中添加自己定制的验证。

清单1 是一个示例validator-rules.xml文件，说明如何将验证例行程序插入到Validator中。validator-rules.xml文件中的每个验证例行程序都有自己的定义，它用validator标记声明，利用name属性为该验证例行程序指定逻辑名，并指定该例行程序的类和方法。该例行程序的逻辑名称供该文件中的其他例行程序以及validation.xml文件中的验证定义用于引用该例行程序。

请注意，validator标记放在javascript的标记中，javascript标记用于定义客户端JavaScript代码，以便在客户端执行与服务器端相同的验证。

提供的验证程序

默认情况下，Validator中包括几个基本验证例行程序，你可以用它们来处理大多数验证问题。这些例行程序具有逻辑名称，如required（用于输入要求的值）、CreditCard（用于输入信用卡号码值）、email（用于输入电子邮件地址值），等等。

创建Form Bean

为了使用Validator，你的应用程序的Form Bean必须归到Validator的ActionForm的某一子类，而不是ActionForm本身。Validator的ActionForm子类提供了ActionForm的validate( )方法（它嵌入到Validator框架中）的实施过程。你不必从头编写验证代码并把它投入validate( )方法中，相反，可以完全忽略该方法，因为Validator为你提供了验证代码。

与Struts提供的核心功能相类似，Validator提供给你两种可供选择的方法来创建Form Bean。 你可以选择的第一种方法就是像下面这样创建一个特定的Form Bean对象：

package com.jamesholmes.minihr;

import org.apache.struts.validator
.ValidatorForm;


public class LogonForm extends ValidatorForm {
  private String username;
  private String password;
  
  public String getUsername() {
    return username;
  }
  
  public void setUsername(String 
username) {
    this.username = username;
  }


  public String getPassword() {
    return password;
  }
public void setPassword(String 
password) {
    this.password = password;
  }
}

这个类与你不是用Validator所创建的类相似，但它提供ValidatorForm而不是ActionForm。这个类也不提供ActionForm的空reset( )和validate( )方法的实施过程，因为ValidatorForm提供了相应过程。

在struts-config.xml文件中配置这个特定Form Bean的方法与配置正则Form Bean的方法相同：

<form-beans>
  <form-bean name="logonForm"
            type="com.jamesholmes
  .minihr.LogonForm"/>
</form-beans>

用表单标记的name属性给特定Form Bean指定的逻辑名是在定义validation.xml文件中的验证时所使用的名称，如下所示： 

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">


<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username" 
            depends="required">
        <arg0 key="prompt.username"/>
      </field>
    </form>
  </formset>
</form-validation>

Validator使用该表单标记的name属性的值将验证定义与要应用这些定义的Form Bean的名称相匹配。

创建Form Bean时可以选择的第二种方法是在struts-config.xml文件中定义一个动态Form Bean，如下所示：

<form-beans>
  <form-bean name="logonForm"
            type="org.apache
.struts.validator.DynaValidatorForm">
    <form-property name="username"
            type="java.lang.String"/>
    <form-property name="password"
            type="java.lang.String"/>
  </form-bean>
</form-beans>

动态Form Bean不要求创建特定的Form Bean对象；相反，要定义Form Bean应该具有的属性和类型，而Struts为你动态创建Form Bean。 Validator允许你使用这个概念，就像在核心Struts中使用这个概念一样。与使用Validator的惟一区别就是要指定Form Bean是org.apache.struts.validator.DynaValidatorForm类型，而不是org.apache.struts.action.DynaActionForm类型。

分配给动态Form Bean的逻辑名是在定义validation.xml文件中的验证时使用的名称。Validator使用与之相匹配的名称将这些验证与Form Bean联系在一起。

除了创建Form Bean的这两种标准方法之外，Validator还提供了一个高级特性，用于将多个验证定义与一个Form Bean定义联系起来。当你使用基于validatorForm或基于DynaValidatorForm的Form Bean时，Validator使用struts-config.xml文件中的Form Bean的逻辑名称，将Form Bean映射到validation.xml文件中的验证定义。这种机制在大多数情况下非常有用，但在某些时候，Form Bean要在多个操作中共享。 一个操作可能使用Form Bean的所有域（fields），而另一个操作可能只使用这些域的一个子集。因为验证定义被连接到Form Bean，所以只使用域的一个子集的操作就无法绕过对未使用域的验证。当验证Form Bean时，就会对未使用的域生成错误消息，因为Validator无从知道不去验证未使用的域，它只是简单地把它们看作缺失或无效。

为了解决这个问题，Validator提供了两个附加的ActionForm子类，它使你能够将验证与操作相关联，而不是与Form Bean相关联。这样你就可以根据哪个操作正在使用Form Bean来指定把哪些验证用于该Form Bean了。对于特定的Form Bean，你要像下面这样声明org.apache.struts.validator.ValidatorActionForm子类：

public class AddressForm extends ValidatorActionForm {
  ...
}

对于动态Form Bean，在struts-config.xml文件中为Form Bean定义指定org.apache.struts.validator.DynaValidatorActionForm的类型，如下所示： 

<form-bean name="addressForm"
          type="org.apache.struts
.validator.DynaValidatorActionForm">
  ...
</form-bean>

在validation.xml文件中，把一组验证映射到一个操作路径，而不是映射到Form Bean名，因为如果你定义了Create Address和Edit Address两个操作（它们使用同一个Form Bean），那么每个操作都会有一个惟一的操作名，如下所示： 

<action-mappings>
  <action path="/createAddress"
         type="com.jamesholmes
  .minihr.CreateAddressAction"
         name="addressForm"/>
  <action path="/editAddress"
         type="com.jamesholmes
  .minihr.EditAddressAction"
         name="addressForm"/>

</action-mappings>

下面的validation.xml文件片断显示了两组验证，它们用于同一个Form Bean，但却有不同的操作路径：

<formset>
  <form name="/createAddress">
    <field property="city"
          depends="required">
      <arg0 key="prompt.city"/>
    </field>
  </form>
  <form name="/editAddress">
    <field property="state"
          depends="required">
      <arg0 key="prompt.state"/>
    </field>
  </form>
</formset>

因为Form Bean要么属于ValidatorActionForm子类，要么属于DynaValidatorActionForm子类，所以Validator知道用一个操作路径代替Form Bean的逻辑名称来找出用于Form Bean的验证。

配置validation.xml文件

validation.xml文件用于声明将应用到Form Beans的一组验证。要验证的每个Form Bean在这个文件中都有自己的定义。在这个定义中，指定要应用到该Form Bean的各域的验证。下面是一个validation.xml文件的例子，说明如何定义验证：

<!DOCTYPE form-validation 
PUBLIC "-//Apache Software Foundation//
       DTD Commons Validator Rules
       Configuration 1.0//EN"
       "http://jakarta.apache.org/
      commons/dtds/validator_1_0.dtd">

<form-validation>
  <formset>
    <form name="logonForm">
      <field property="username"
            depends="required">
        <arg0 key="prompt.username"/>

      </field>
      <field property="password"
            depends="required">
        <arg0 key="prompt.password"/>
      </field>
    </form>
  </formset>
</form-validation>

validation.xml文件的第一个元素是form-validation。这个元素是该文件的主元素，而且只定义一次。在form-validation元素内定义form-set元素，它包括多个表单元素。一般来说，在文件中只定义一个form-set元素，但是如果要将验证国际化，那就要在每个地方单独使用一个form-set元素。

每个表单元素使用name属性将名称与其所包含的域验证集关联起来。Validator使用这个逻辑名称将这些验证映射到在struts-config.xml文件中定义的一个Form Bean。根据要验证的Form Bean的类型，Validator力求将该名称与Form Bean的逻辑名称或操作路径相匹配。在表单元素内，field元素定义要应用到Form Bean的特定域的验证。field元素的property属性对应于特定Form Bean中的域名。depends属性利用validator-rules.xml文件指定验证例行程序的逻辑名称，这些例行程序将应用到域验证中。

配置ApplicationResources.properties

Validator使用Struts的资源绑定（Resource Bundle）机制将错误消息具体化。不用在框架中对错误消息进行硬编码，Validator使你能在ApplicationResources.properties文件中为一个消息指定一个键值，如果验证失败则将返回该键值。validator-rules.xml文件中的每个验证例行程序都用validator标记的msg属性指定错误消息的键值，如下所示： 

<validator name="required"
          classname="org.apache

.struts.validator.FieldChecks"
          method="validateRequired"
          methodParams="java.lang
.Object, org.apache.commons.validator
.ValidatorAction, org.apache.commons
.validator.Field, org.apache.struts
.action.ActionErrors, javax.servlet
.http.HttpServletRequest"
          msg="errors.required">

如果在验证例行程序运行时验证失败，则返回与msg属性指定的键值对应的消息。

下面的片段显示来自ApplicationResources.properties文件的验证出错时的默认消息集，它们由Struts示例应用程序提供。每个消息的键值对应于每个由validator-rules.xml文件中的验证例行程序所指定的消息，它们由Struts示例应用程序提供。 

# Error messages for Validator framework validations
errors.required={0} is required.
errors.minlength={0} cannot be less than {1} characters.
errors.maxlength={0} cannot be greater than {2} characters.
errors.invalid={0} is invalid.
errors.byte={0} must be a byte.
errors.short={0} must be a short.
errors.integer={0} must be an integer.
errors.long={0} must be a long.0.   errors.float={0} must be a float.

errors.double={0} must be a double.
errors.date={0} is not a date.
errors.range={0} is not in the range {1} through {2}.
errors.creditcard={0} is not a valid credit card number.
errors.email={0} is an invalid e-mail address.

请注意，每条消息都有占位符，形式为{0}、{1}或{2}。在运行期间，占位符被另一个值代替，如所验证的域的名称。这一特性特别有用，它使你能够创建可被几个不同的域重复使用的通用验证错误消息。

例如，下面给出required验证的错误消息errors.required： 

errors.required={0} is required.

当你使用validation.xml文件中的该required验证时，必须定义用于替换该错误消息中的{0}的值，如下所示：

<form name="auctionForm">
  <field property="bid" depends="required">
    <arg0 key="prompt.bid"/>
  </field>
</form>

错误消息最多可以有4个占位符：{0}和{3}。这些占位符分别称为arg0到arg3，你可以通过使用arg0~arg3标记来指定它们。在上面的例子中，arg0标记指定了用于替换{0}占位符的值。该标记的key属性指定来自ApplicationResources.properties文件的一个消息键值，它的值用于替换占位符，如下所示：

下一步

阅读
关于Validator的更多文章
jakarta.apache.org/commons/validator

关于Struts Console的更多文章
www.jamesholmes.com/struts 

prompt.bid=Auction Bid

使用消息键值代替占位符的值，这一方法使你不必在validation.xml文件中对替换值反复硬编码。但是，如果你不想使用Resource Bundle的键值/值机制来指定占位符的值，则可以使用arg0标记的如下语法显式地指定占位符的值：

<arg0 key="Auction Bid" resource="false"/>

在这个例子中，resource属性的值设为false，以便通知Validator要把该key属性指定的值作为占位符的值，而不要作为ApplicationResources.properties文件中消息的一个键值。

启用客户端验证

Validator除了提供了简化服务器端表单数据验证过程的框架外，它还提供了执行客户端验证时易于使用的方法。在validator-rules.xml文件中定义的每一个验证例行程序都可以随意指定JavaScript代码，这些代码可以在浏览器（客户端上的）中运行，从而执行与服务器端进行的验证相同的验证过程。在客户端进行验证时，除非所有表单都通过验证，否则这些表单不允许被提交。

为了启用客户端验证，必须在每个需要验证的JSP中放上Struts HTML Tag Library（标记库）的javascript标记，如下所示： 

<html:javascript formName="logonForm"/>

javascript标记要求使用formName属性来为想要对其执行验证的表单指定validation.xml文件中给出的表单定义名，如下所示： 

<form name="logonForm">
  <field property="username"
        depends="required">
    <arg0 key="prompt.username"/>
  </field>
  <field property="password"
        depends="required">
    <arg0 key="prompt.password"/>
  </field>
</form>

为表单定义指定的服务器端的所有验证都将在客户端运行。由于客户端验证用JavaScript执行，所以可以有多种方法不去执行它。要确保验证过程总是能运行，不论你是否选择启用了客户端验证，Validator都在服务器端执行这些验证。

结论

Validator框架针对表单数据的验证提供了可配置的系统，从而为核心Struts框架添加了很多有价值的功能。通过把Validator框架用于你的应用程序，你可以节约时间并简化Struts应用程序的开发过程。

posted @ 2006-05-11 14:52 阿成 阅读(289) | 评论 (0) | 编辑 收藏
Java设计模式 → 工厂模式

工厂模式定义:提供创建对象的接口.
为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，
我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来
创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，
虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少
的修改量。

我们以类Sample为例， 如果我们要创建Sample的实例对象:
 Sample sample=new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如
赋值 查询数据库等。首先，我们想到的是，可以使用Sample的构造函数，这样
生成实例就写成:  Sample sample=new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能
是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。
为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果
是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡
蛋放在一个篮子里，是很危险的，这也是有背于Java面向对象的原则，面向对象的
封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成
每段，将每段再“封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，
以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。
在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，
让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。
这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。
还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个
接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个
实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传
统程序中是无法避免的.
但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法
你会建立一个专门生产Sample实例的工厂:
public class Factory{
　　public static Sample creator(int which){
　　//getClass 产生Sample 一般可使用动态类装载装入类。
　　if (which==1)
　　　　return new SampleA();
　　else if (which==2)
　　　　return new SampleB();
　　}
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA=Factory.creator(1);
这样,在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,
这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做
过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性
就越少.好象我们从编程序中也能悟出人生道理?呵呵.
使用工厂方法要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口
下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample。
进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类
concreteFactory了。
抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory).
这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,
如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类
Sample2A和SampleB2，那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽
象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
　　public abstract Sample creator();
　　public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
　　public Sample creator(){
　　　　.........
　　　　return new SampleA
　　}
　　public Sample2 creator(String name){
　　　　.........
　　　　return new Sample2A
　　}
}
public class BombFactory extends Factory{
　　public Sample creator(){
　　　　......
　　　　return new SampleB
　　}
　　public Sample2 creator(String name){
　　　　......
　　　　return new Sample2B
　　}
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我
不可以使用两个工厂方法来分别生产Sample和Sample2?
抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产
Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂
类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称
叫SimpleFactory。
在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用，
举例
我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，
现在再讨论其工厂模式:
public abstract class ForumFactory {
　　private static Object initLock = new Object();
　　private static String className = "com.jivesoftware.forum.database.DbForumFactory";
　　private static ForumFactory factory = null;
　　public static ForumFactory getInstance(Authorization authorization) {
　　　　//If no valid authorization passed in, return null.
　　　　if (authorization == null) {
　　　　　　return null;
　　　　}
　　　　//以下使用了Singleton 单态模式
　　　　if (factory == null) {
　　　　　　synchronized(initLock) {
　　　　　　　　if (factory == null) {
　　　　　　　　　　　　......
　　　　　　　　　　try {
　　　　　　　　　　　　　　//动态转载类
　　　　　　　　　　　　　　Class c = Class.forName(className);
　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();
　　　　　　　　　　}
　　　　　　　　　　catch (Exception e) {
　　　　　　　　　　　　　　return null;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　}

　　　　//Now, 返回 proxy.用来限制授权对forum的访问
　　　　return new ForumFactoryProxy(authorization, factory,
　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));
　　}

　　//真正创建forum的方法由继承forumfactory的子类去完成.
　　public abstract Forum createForum(String name, String description)
　　throws UnauthorizedException, ForumAlreadyExistsException;

　　....

}
因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口:

private static String className = "com.jivesoftware.forum.database.DbForumFactory";

你可以使用自己开发的创建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.

在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果. 

看看Java宠物店中的CatalogDAOFactory:

public class CatalogDAOFactory {

　　/**

　　* 本方法制定一个特别的子类来实现DAO模式。
　　* 具体子类定义是在J2EE的部署描述器中。
　　*/

　　public static CatalogDAO getDAO() throws CatalogDAOSysException {

　　　　CatalogDAO catDao = null;

　　　　try {

　　　　　　InitialContext ic = new InitialContext();
　　　　　　//动态装入CATALOG_DAO_CLASS
　　　　　　//可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码
　　　　　　//的前提下，完成系统的巨大变更。

　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);

　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();

　　　　} catch (NamingException ne) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: NamingException while
　　　　　　　　　　getting DAO type : \n" + ne.getMessage());

　　　　} catch (Exception se) {

　　　　　　throw new CatalogDAOSysException("
　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting
　　　　　　　　　　DAO type : \n" + se.getMessage());

　　　　}

　　　　return catDao;

　　}

}

CatalogDAOFactory是典型的工厂方法，catDao是通过动态类装入器className获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。

设计模式如何在具体项目中应用见《Java实用系统开发指南》

posted @ 2006-05-08 09:12 阿成 阅读(341) | 评论 (0) | 编辑 收藏
快到51了

最近还算轻松，快到51了嘛，同事们回家的回家，不回家的想着去哪玩儿。

过两天我也回家了，这回可以好好玩儿和歇几天了。

posted @ 2006-04-29 08:34 阿成 阅读(194) | 评论 (0) | 编辑 收藏
Eclipse插件下载
EMF,GEF - Graphical Editor Framework,UML2,VE - Visual Editor都在这里下载
http://www.eclipse.org/downloads/index.php
 
lomboz J2EE插件,开发JSP,EJB
http://forge.objectweb.org/projects/lomboz


1.MyEclipse J2EE开发插件，支持SERVLET/JSP/EJB/数据库操纵等
http://www.myeclipseide.com
 
2.Properties Editor  编辑java的属性文件，并可以自动存盘为Unicode格式
http://propedit.sourceforge.jp/index_en.html
 
3.Colorer Take  为上百种类型的文件按语法着色
http://colorer.sourceforge.net/
 
4.XMLBuddy 编辑xml文件
http://www.xmlbuddy.com
 
5.Code Folding  加入多种代码折叠功能（比eclipse自带的更多）
http://www.coffee-bytes.com/servlet/PlatformSupport
 
6.Easy Explorer  从eclipse中访问选定文件、目录所在的文件夹
http://easystruts.sourceforge.net/
 
7.Fat Jar 打包插件，可以方便的完成各种打包任务，可以包含外部的包等
http://fjep.sourceforge.net/
 
8.RegEx Test 测试正则表达式
http://brosinski.com/stephan/archives/000028.php
 
9.JasperAssistant 报表插件（强，要钱的）
http://www.jasperassistant.com/
 
10.Jigloo GUI Builder ＪＡＶＡ的ＧＵＩ编辑插件
http://cloudgarden.com/jigloo/
 
11.Profiler 性能跟踪、测量工具，能跟踪、测量ＢＳ程序
http://sourceforge.net/projects/eclipsecolorer/
 
12.AdvanQas 提供对if/else等条件语句的提示和快捷帮助（自动更改结构等）
http://eclipsecolorer.sourceforge.net/advanqas/index.html
 
13.Log4E Log4j插件，提供各种和Log4j相关的任务，如为方法、类添加一个logger等
http://log4e.jayefem.de/index.php/Main_Page
 
14.VSSPlugin VSS插件
http://sourceforge.net/projects/vssplugin
 
15.Implementors 提供跳转到一个方法的实现类，而不是接中的功能（实用!）
http://eclipse-tools.sourceforge.net/implementors/
 
16.Call Hierarchy 显示一个方法的调用层次（被哪些方法调，调了哪些方法）
http://eclipse-tools.sourceforge.net/call-hierarchy/index.html
 
17.EclipseTidy 检查和格式化HTML/XML文件
http://eclipsetidy.sourceforge.net/
 
18.Checkclipse 检查代码的风格、写法是否符合规范
http://www.mvmsoft.de/content/plugins/checkclipse/checkclipse.htm
 
19.Hibernate Synchronizer Hibernate插件，自动映射等
http://www.binamics.com/hibernatesync/
 
20.VeloEclipse  Velocity插件
http://propsorter.sourceforge.net/
 
21.EditorList 方便的列出所有打开的Editor
http://editorlist.sourceforge.net/
 
22.MemoryManager 内存占用率的监视
http://cloudgarden.com/memorymanager/
 
23.swt-designer java的GUI插件
http://www.swt-designer.com/
 
24.TomcatPlugin 支持Tomcat插件
http://www.sysdeo.com/eclipse/tomcatPlugin.html
 
25.XML Viewer
http://tabaquismo.freehosting.net/ignacio/eclipse/xmlview/index.html
 
26.quantum 数据库插件
http://quantum.sourceforge.net/
 
27.Dbedit 数据库插件
http://sourceforge.net/projects/dbedit
 
28.clay.core 可视化的数据库插件
http://www.azzurri.jp/en/software/index.jsp
http://www.azzurri.jp/eclipse/plugins
 
29.hiberclipse hibernate插件
http://hiberclipse.sourceforge.net
http://www.binamics.com/hibernatesync
 
30.struts-console Struts插件
http://www.jamesholmes.com/struts/console/
 
31.easystruts Struts插件
http://easystruts.sourceforge.net
 
32.veloedit Velocity插件
http://veloedit.sourceforge.net/
 
33.jalopy 代码整理插件
http://jalopy.sourceforge.net/
 
34.JDepend 包关系分析
http://andrei.gmxhome.de/jdepend4eclipse/links.html
 
35.Spring IDE Spring插件
http://springide-eclip.sourceforge.net/updatesite/
 
36.doclipse 可以产生xdoclet 的代码提示
http://beust.com/doclipse/

posted @ 2006-04-27 16:57 阿成 阅读(473) | 评论 (0) | 编辑 收藏
下拉菜单－－javaScript

<html>
<head>
<title>打造下拉菜单</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<style>
body,td { font-size:12px; font-family:宋体}
a:link {  color: #ffffff; text-decoration: none}
a:visited {  color: #ffffff; text-decoration: none}
a:hover {  color: #ff9933; text-decoration: none}
table {  border: #000000; border-style: solid; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px}
</style>
<script language="JavaScript">
<!--
<!--
function MM_reloadPage(init) {  //reloads the window if Nav4 resized
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {
    document.MM_pgW=innerWidth; document.MM_pgH=innerHeight; onresize=MM_reloadPage; }}
  else if (innerWidth!=document.MM_pgW || innerHeight!=document.MM_pgH) location.reload();
}
MM_reloadPage(true);
// -->

function MM_findObj(n, d) { //v4.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && document.getElementById) x=document.getElementById(n); return x;
}

function MM_showHideLayers() { //v3.0
  var i,p,v,obj,args=MM_showHideLayers.arguments;
  for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
    if (obj.style) { obj=obj.style; v=(v=='show')?'visible':(v='hide')?'hidden':v; }
    obj.visibility=v; }
}
//-->
</script>
</head>

<body bgcolor="#CCCCCC" text="#000000" leftmargin="0" topmargin="0" marginwidth="0" marginheight="0" scroll=auto>
<div id="title" style="position:absolute; left:8px; top:15px; width:240px; height:15px; z-index:1; background-color: #006699; layer-background-color: #006699; border: 1px none #000000">
  <table width="480" cellspacing="0" cellpadding="2">
    <tr>
      <td width="120" onMouseOver="MM_showHideLayers('menu1','','show')" onMouseOut="MM_showHideLayers('menu1','','hide')"><b><font color="#FFFFFF"><a href="#">■
        经典论坛</a></font></b> </td>
      <td width="120" onMouseOver="MM_showHideLayers('menu2','','show')" onMouseOut="MM_showHideLayers('menu2','','hide')"><b><font color="#FFFFFF"><a href="#">■
        天极网</a></font></b> </td>
      <td width="120" onMouseOver="MM_showHideLayers('menu2','','show')" onMouseOut="MM_showHideLayers('menu2','','hide')">&nbsp;</td>
      <td width="120" onMouseOver="MM_showHideLayers('menu2','','show')" onMouseOut="MM_showHideLayers('menu2','','hide')">&nbsp;</td>
    </tr>
  </table>
</div>
<div id="menu1" style="position:absolute; left:8px; top:34px; width:120px; height:80px; z-index:2; background-color: #999966; layer-background-color: #999966; border: 1px none #000000; visibility: hidden" onMouseOver="MM_showHideLayers('menu1','','show')" onMouseOut="MM_showHideLayers('menu1','','hide')">
  <table width="100%" cellspacing="0" cellpadding="2" height="80">
    <tr>
      <td>&nbsp;<a href="#">Dreamweaver 专栏</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Fireworks 专栏</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Flash 基本操作</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">Flash 5 Action</a></td>
    </tr>
  </table>
</div>
<div id="menu2" style="position:absolute; left:127px; top:34px; width:120px; height:80px; z-index:2; background-color: #999966; layer-background-color: #999966; border: 1px none #000000; visibility: hidden" onMouseOver="MM_showHideLayers('menu2','','show')" onMouseOut="MM_showHideLayers('menu2','','hide')">
  <table width="100%" cellspacing="0" cellpadding="2" height="80">
    <tr>
      <td>&nbsp;<a href="#">新闻</a>&nbsp;</td>
    </tr>
    <tr>
      <td height="20">&nbsp;<a href="#">软件</a></td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">硬件</a>&nbsp;</td>
    </tr>
    <tr>
      <td>&nbsp;<a href="#">商城</a></td>
    </tr>
  </table>
</div>

</body>
</html>


http://www.blueidea.com/tech/web/2003/301.asp

posted @ 2006-04-25 14:43 阿成 阅读(626) | 评论 (0) | 编辑 收藏
时间真快，要到5 1 了
前些日子编了一阵子程序，有点累。

最近工作稍微轻松了一些。现在每天晚上打篮球锻炼身体和技术

到5 ·1就可以回家好好玩会儿，休息休息了
posted @ 2006-04-19 10:03 阿成 阅读(204) | 评论 (0) | 编辑 收藏
Spring 入门实例

Spring是一个非常优秀的轻量级框架，通过Spring的IoC容器，我们的关注点便放到了需要实现的业务逻辑上。对AOP的支持则能让我们动态增强业务方法。编写普通的业务逻辑Bean是非常容易而且易于测试的，因为它能脱离J2EE容器（如Servlet，JSP环境）单独进行单元测试。最后的一步便是在Spring框架中将这些业务Bean以XML配置文件的方式组织起来，它们就按照我们预定的目标正常工作了！非常容易！

本文将给出一个基本的Spring入门示例，并演示如何使用Spring的AOP将复杂的业务逻辑分离到每个方面中。

1．开发环境配置
2．编写Bean接口及其实现
3．在Spring中配置Bean并获得Bean的实例
4．编写Advisor以增强ServiceBean
5．总结

1．开发环境配置

首先，需要正确配置Java环境。推荐安装JDK1.4.2，并正确配置环境变量：

JAVA_HOME=<JDK安装目录>
CLASSPATH=.
Path=%JAVA_HOME%\bin;……

我们将使用免费的Eclipse 3.1作为IDE。新建一个Java Project，将Spring的发布包spring.jar以及commons-logging-1.0.4.jar复制到Project目录下，并在Project > Properties中配置好Java Build Path：

2．编写Bean接口及其实现

我们实现一个管理用户的业务Bean。首先定义一个ServiceBean接口，声明一些业务方法：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				/**
 * Interface of service facade.
 * 
 * @author Xuefeng
 */
public interface ServiceBean {
    void addUser(String username, String password);
    void deleteUser(String username);
    boolean findUser(String username);
    String getPassword(String username);
}

然后在MyServiceBean中实现接口：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * 
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				import java.util.*;
		
				public class MyServiceBean implements ServiceBean {
		
				    private String dir;
    private Map map = new HashMap();
		
				    public void setUserDir(String dir) {
        this.dir = dir;
        System.out.println("Set user dir to: " + dir);
    }
		
				    public void addUser(String username, String password) {
        if(!map.containsKey(username))
            map.put(username, password);
        else
            throw new RuntimeException("User already exist.");
    }
		
				    public void deleteUser(String username) {
        if(map.remove(username)==null)
            throw new RuntimeException("User not exist.");
    }
		
				    public boolean findUser(String username) {
        return map.containsKey(username);
    }
		
				    public String getPassword(String username) {
        return (String)map.get(username);
    }
}

为了简化逻辑，我们使用一个Map保存用户名和口令。

现在，我们已经有了一个业务Bean。要测试它非常容易，因为到目前为止，我们还没有涉及到Spring容器，也没有涉及到任何Web容器（假定这是一个Web应用程序关于用户管理的业务Bean）。完全可以直接进行Unit测试，或者，简单地写个main方法测试：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				public class Main {
		
				    public static void main(String[] args) throws Exception {
        ServiceBean service = new MyServiceBean();
        service.addUser("bill", "hello");
        service.addUser("tom", "goodbye");
        service.addUser("tracy", "morning");
        System.out.println("tom's password is: " + service.getPassword("tom"));
        if(service.findUser("tom")) {
            service.deleteUser("tom");
        }
    }
}

执行结果：

3．在Spring中配置Bean并获得Bean的实例

我们已经在一个main方法中实现了业务，不过，将对象的生命周期交给容器管理是更好的办法，我们就不必为初始化对象和销毁对象进行硬编码，从而获得更大的灵活性和可测试性。

想要把ServiceBean交给Spring来管理，我们需要一个XML配置文件。新建一个beans.xml，放到src目录下，确保在classpath中能找到此配置文件，输入以下内容：

				<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
"
				
						http://www.springframework.org/dtd/spring-beans.dtd
				
				">
<beans>
    <bean id="service" class="com.crackj2ee.example.spring.MyServiceBean" />
</beans>

以上XML声明了一个id为service的Bean，默认地，Spring为每个声明的Bean仅创建一个实例，并通过id来引用这个Bean。下面，我们修改main方法，让Spring来管理业务Bean：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
		
				public class Main {
		
				    public static void main(String[] args) throws Exception {
        // init factory:
        XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
        // use service bean:
        ServiceBean service = (ServiceBean)factory.getBean("service");
        service.addUser("bill", "hello");
        service.addUser("tom", "goodbye");
        service.addUser("tracy", "morning");
        System.out.println("tom's password is \"" + service.getPassword("tom") + "\"");
        if(service.findUser("tom")) {
            service.deleteUser("tom");
        }
        // close factory:
        factory.destroySingletons();
    }
}

执行结果：
 

由于我们要通过main方法启动Spring环境，因此，首先需要初始化一个BeanFactory。红色部分是初始化Spring的BeanFactory的典型代码，只需要保证beans.xml文件位于classpath中。

然后，在BeanFactory中通过id查找，即可获得相应的Bean的实例，并将其适当转型为合适的接口。

接着，实现一系列业务操作，在应用程序结束前，让Spring销毁所有的Bean实例。

对比上一个版本的Main，可以看出，最大的变化是不需要自己管理Bean的生命周期。另一个好处是在不更改实现类的前提下，动态地为应用程序增加功能。

4．编写Advisor以增强ServiceBean

所谓AOP即是将分散在各个方法处的公共代码提取到一处，并通过类似拦截器的机制实现代码的动态织入。可以简单地想象成，在某个方法的调用前、返回前、调用后和抛出异常时，动态插入自己的代码。在弄清楚Pointcut、Advice之类的术语前，不如编写一个最简单的AOP应用来体验一下。

考虑一下通常的Web应用程序都会有日志记录，我们来编写一个LogAdvisor，对每个业务方法调用前都作一个记录：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
		
				public class LogAdvisor implements MethodBeforeAdvice {
    public void before(Method m, Object[] args, Object target) throws Throwable {
        System.out.println("[Log] " + target.getClass().getName() + "." + m.getName() + "()");
    }
}

然后，修改beans.xml：

				<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
"
				
						http://www.springframework.org/dtd/spring-beans.dtd
				
				">
		
				<beans>
    <bean id="serviceTarget" class="com.crackj2ee.example.spring.MyServiceBean" />
		
				    <bean id="logAdvisor" class="com.crackj2ee.example.spring.LogAdvisor" />
		
				    <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces"><value>com.crackj2ee.example.spring.ServiceBean</value></property>
        <property name="target"><ref local="serviceTarget"/></property>
        <property name="interceptorNames">
            <list>
                <value>logAdvisor</value>
            </list>
        </property>
    </bean>
</beans>

注意观察修改后的配置文件，我们使用了一个ProxyFactoryBean作为service来与客户端打交道，而真正的业务Bean即MyServiceBean被声明为serviceTarget并作为参数对象传递给ProxyFactoryBean，proxyInterfaces指定了返回的接口类型。对于客户端而言，将感觉不出任何变化，但却动态加入了LogAdvisor，关系如下：
 

运行结果如下，可以很容易看到调用了哪些方法：
 

要截获指定的某些方法也是可以的。下面的例子将修改getPassword()方法的返回值：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
		
				public class PasswordAdvisor implements MethodInterceptor {
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object ret = invocation.proceed();
        if(ret==null)
            return null;
        String password = (String)ret;
        StringBuffer encrypt = new StringBuffer(password.length());
        for(int i=0; i<password.length(); i++)
            encrypt.append('*');
        return encrypt.toString();
    }
}

这个PasswordAdvisor将截获ServiceBean的getPassword()方法的返回值，并将其改为"***"。继续修改beans.xml：

				<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
"
				
						http://www.springframework.org/dtd/spring-beans.dtd
				
				">
<beans>
    <bean id="serviceTarget" class="com.crackj2ee.example.spring.MyServiceBean" />
		
				    <bean id="logAdvisor" class="com.crackj2ee.example.spring.LogAdvisor" />
		
				    <bean id="passwordAdvisorTarget" class="com.crackj2ee.example.spring.PasswordAdvisor" />
		
				    <bean id="passwordAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice">
            <ref local="passwordAdvisorTarget"/>
        </property>
        <property name="patterns">
            <list>
                <value>.*getPassword</value>
            </list>
        </property>
    </bean>
		
				    <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces"><value>com.crackj2ee.example.spring.ServiceBean</value></property>
        <property name="target"><ref local="serviceTarget"/></property>
        <property name="interceptorNames">
            <list>
                <value>logAdvisor</value>
                <value>passwordAdvisor</value>
            </list>
        </property>
    </bean>
</beans>

利用Spring提供的一个RegexMethodPointcutAdvisor可以非常容易地指定要截获的方法。运行结果如下，可以看到返回结果变为"******"：
 

还需要继续增强ServiceBean？我们编写一个ExceptionAdvisor，在业务方法抛出异常时能做一些处理：

				/**
 * Copyright_2006, Liao Xuefeng
 * Created on 2006-3-9
 * For more information, please visit: 
				
						http://www.crackj2ee.com
				
				

				 */
package com.crackj2ee.example.spring;
		
				import org.springframework.aop.ThrowsAdvice;
		
				public class ExceptionAdvisor implements ThrowsAdvice {
    public void afterThrowing(RuntimeException re) throws Throwable {
        System.out.println("[Exception] " + re.getMessage());
    }
}

将此Advice添加到beans.xml中，然后在业务Bean中删除一个不存在的用户，故意抛出异常：

				service.deleteUser("not-exist");

再次运行，注意到ExceptionAdvisor记录下了异常：
 

5．总结

利用Spring非常强大的IoC容器和AOP功能，我们能实现非常灵活的应用，让Spring容器管理业务对象的生命周期，利用AOP增强功能，却不影响业务接口，从而避免更改客户端代码。

为了实现这一目标，必须始终牢记：面向接口编程。而Spring默认的AOP代理也是通过Java的代理接口实现的。虽然Spring也可以用CGLIB实现对普通类的代理，但是，业务对象只要没有接口，就会变得难以扩展、维护和测试。

可以从此处下载完整的Eclipse工程：
http://www.crackj2ee.com/Article/UploadFiles/200604/SpringBasic.rar

posted @ 2006-04-18 17:28 阿成 阅读(2038) | 评论 (1) | 编辑 收藏
javascript技巧总结

1.删除提示

1)<a  href="#" onclick="return(confirm('删除后无法恢复,您确定删除吗?'))">删除</a>

2)JS
<a  href="#" >删除</a>

<script language="JavaScript" type="text/javascript">
function delete_confirm(){
 if(event.srcElement.outerText=="删除" || event.srcElement.value=="删除")
  event.returnValue=confirm("删除后将不能恢复，您确认执行删除操作么？");
 }
 document.onclick=delete_confirm;
</script>

2.点击按钮探出提示
 <input type=button value="reload" onclick="javascript:reload()">

<script type="text/javascript">
function reload() {
 
 if (confirm("确认?"))
 {
 var url="#";
 window.location.href=url;
 }
}
3.点击链接弹出提示

<a  href="确认后的连接地址" onclick="return(confirm('想要的提示信息?'))">显示信息</a>

4.onchange（）用法
<select name="year" onchange="javascript:changeYear()">
 <OPTION OPTION>
</SELECT>

<SCRIPT language="javascript">
function changeYear(){
  var url = ....;
 window.location.href = url;
}
</SCRIPT>

4.根据选择的radio转向不同的URL
<input type="Radio" name="id" value="1" checked></td>
<input type="Radio" name="id" value="2" checked></td>
<input type="Radio" name="id" value="3" checked></td>

<SCRIPT language="javascript">
function WhichOneisChecked(obj) {
for (var i = 0;i < obj.elements.length;i++){
if (obj.elements[i].checked == true){
var weekLogId=obj.elements[i].value;
var url="......";
window.location.href = url;
}
}
}
</SCRIPT>

5.radio 全选
function checkAll(e, itemName)
{
  var aa = document.getElementsByName(itemName);
  for (var i=0; i<aa.length; i++)
   aa[i].checked = e.checked;
}
function check(e, allName)
{
  var all = document.getElementsByName(allName)[0];
  if(!e.checked) all.checked = false;
  else
  {
    var aa = document.getElementsByName(e.name);
    for (var i=0; i<aa.length; i++)
     if(!aa[i].checked) return;
    all.checked = true;
  }
   
<input type=checkbox checked name=allTeams onclick="checkAll(this, 'teamIds')">

<input type="checkbox" name="teamIds" checked value="<%=.....%>" onclick="check(this, 'allTeams')">

6.显示、隐藏
链接实现
<script language="javascript">
  function showLay(divId){
        var objDiv = eval(divId);
        if (objDiv.style.display=="none"){
                eval("sp"+divId+".innerHTML='隐藏'");
                objDiv.style.display="";
        }else{
                eval("sp"+divId+".innerHTML='查看'");
                objDiv.style.display="none";
        }}
  </script>

   <td>
      <a href="#"  onclick="showLay('Layer1')"><span id="spLayer1">查看</span></a>
      <br>
      <div id="Layer1" style="display:none;">......</div>
     </td>

按钮实现
<SCRIPT LANGUAGE="JavaScript">
function hidden_show()
{
 var obj = document.getElementById("Layer1");
 if(obj.style.visibility == "")
  obj.style.visibility = "hidden";
 else
  obj.style.visibility = "";
}
</SCRIPT>
<td>
      <INPUT TYPE="button" onclick="hidden_show();" value="hidden/show">
     <br>
      <div id="Layer1" >
       <%=weekPlan%>
      </div>
     </td>

posted @ 2006-04-17 17:33 阿成 阅读(546) | 评论 (0) | 编辑 收藏
十四种Java开发工具点评
在计算机开发语言的历史中，从来没有哪种语言象Java那样受到如此众多厂商的支持，有如此多的开发工具，Java菜鸟们如初入大观园的刘姥姥，看花了眼，不知该何种选择。的确，这些工具各有所长，都没有绝对完美的，就算是老鸟也很难做出选择。在本文中我简要介绍了常见的十五种Java开发工具的特点，管中窥“器”，希望能对大家有所帮助。

   1、JDK （Java Development Kit）

　　SUN的Java不仅提了一个丰富的语言和运行环境，而且还提了一个免费的Java开发工具集(JDK)。开发人员和最终用户可以利用这个工具来开发java程序。

   JDK简单易学，可以通过任何文本编辑器（如：Windows 记事本、UltrEdit、Editplus、FrontPage以及dreamweaver等）编写Java源文件，然后在DOS状况下利通过javac命令将Java源程序编译成字节码，通过Java命令来执行编译后的Java文件，这能带给DOS时代程序员美好的回忆。

  Java 初学者一般都采用这种开发工具。

  2、Java Workshop

1143135411556_3614.gif

      Sun MicroSystems公司于1996年3月26日推出了Java WorkShop 1.0，这是业界出现的第一个供Internet网使用的多平台开发工具，它可以满足各公司开发Internet和Intranet网应用软件的需要。Java WorkShop完全用Java语言编写，是当今市场上销售的第一个完全的Java开发环境，目前Java WorkShop的最性版本是3.0。Java Workshop的特点表现如下：

　　1）结构易于创建：在创建平台中立的网格结构方面，Java Workshop比其他任何一种Java开发工具都要方便。

　　2）可视化编程：Java Workshop的可视化编程特性是很基本的。Java Workshop允许程序员重新安排这些操作，甚至可以确定触发操作行为的过滤器。Java Workshop产生的模板带有许多注释，这对程序员是很有帮助的。

　　此外，Java WorkShop支持JDK1.1.3以及JavaBeans组件模型，API和语言特征增加了编译Java应用程序的灵活性。 Java WorkShop开发环境由于完全用Java写成，所以可移植性极好,以致于多个平台都能支持,目前Java WorkShop支持Solaris操作环境SPARC及Intel 版）、Windows95、WindowsNT、以及HP/Ux等平台。适合于初学者进行一些简单的Java编程。Java WorkShop的缺点是Java Workshop中的每一个可视化对象都迟早会用到网格布局，这种设计方法是许多人不习惯的；Java Workdshop的调色板是较差的，仅仅能满足绝大部分应用的基本要求。

  3、NetBeans 与Sun Java Studio 5

1143135607062_8513.gif

    NetBeans是开放源码的Java集成开发环境(IDE)，适用于各种客户机和Web应用。 Sun Java Studio是Sun公司最新发布的商用全功能Java IDE，支持Solaris、Linux和Windows平台，适于创建和部署2层Java Web应用和n层J2EE应用的企业开发人员使用。

　　NetBeans是业界第一款支持创新型Java开发的开放源码IDE。开发人员可以利用业界强大的开发工具来构建桌面、Web或移动应用。同时，通过NetBeans和开放的API的模块化结构，第三方能够非常轻松地扩展或集成NetBeans平台。

　　NetBeans3.5.1主要针对一般Java软件的开发者，而Java One Studio5则主要针对企业做网络服务等应用的开发者。Sun不久还将推出Project Rave，其目标是帮助企业的开发者进行软件开发。NetBeans 3.5.1版本与其他开发工具相比，最大区别在于不仅能够开发各种台式机上的应用，而且可以用来开发网络服务方面的应用，可以开发基于J2ME的移动设备上的应用等。在NetBeans 3.5.1基础上，Sun开发出了Java One Studio5，为用户提供了一个更加先进的企业编程环境。在新的Java One Studio5里有一个应用框架，开发者可以利用这些模块快速开发自己在网络服务方面的各种应用程序。

4.Borland 的JBuilder

  Jbuilder进入了Java集成开发环境的王国，它满足很多方面的应用，尤其是对于服务器方以及EJB开发者们来说。下面简单介绍一下Jbuilder的特点:

　　1）Jbuilder支持最新的Java技术，包括Applets、JSP/Servlets、JavaBean以及EJB(Enterprise JavaBeans)的应用。

　　2）用户可以自动地生成基于后端数据库表的EJB Java类，Jbuilder同时还简化了EJB的自动部署功能.此外它还支持CORBA，相应的向导程序有助于用户全面地管理IDL(分布应用程序所必需的接口定义语言Interface Definition Language)和控制远程对象。

　　3）Jbuilder支持各种应用服务器。Jbuilder与Inprise Application Server紧密集成，同时支持WebLogic Server，支持EJB 1.1和EJB 2.0，可以快速开发J2EE的电子商务应用。

　　4）Jbuilder能用Servlet和JSP开发和调试动态Web 应用。

　　5）利用Jbuilder可创建(没有专有代码和标记)纯Java2应用。由于Jbuilder是用纯Java语言编写的，其代码不含任何专属代码和标记，它支持最新的Java标准。

　　6）Jbuilder拥有专业化的图形调试介面，支持远程调试和多线程调试，调试器支持各种JDK版本,包括J2ME/J2SE/J2EE。

　　JBuilder环境开发程序方便，它是纯的Java 开发环境，适合企业的J2EE开发；缺点是往往一开始人们难于把握整个程序各部分之间的关系，对机器的硬件要求较高，比较吃内存，这时运行速度显得较慢。

　5、Oracle 的JDeveloper

  Oracle9i JDeveloper（定为9.0版，最新为10g）为构建具有J2EE功能，XML和Web services的复杂的，多层的Java应用程序提供了一个完全集成的开发环境。它为运用Oracle9i数据库和应用服务器的开发人员提供特殊的功能和增强性能，除此以外，它也有资格成为用于多种用途Java开发的一个强大的工具。

　　Oracle9i JDeveloper的主要特点如下：

　　① 具有UML（Unified Modeling Language，一体化建模语言）建模功能。可以将业务对象及e-business应用模型化。

　　② 配备有高速Java调试器（Debuger）、内置Profiling工具、提高代码质量的工具“CodeCoach”等。

　　③ 支持SOAP（Simple Object Access Protocol）“简单对象访问协议”、UDDI（Universal Description, Discovery and Integration）“统一描述、发现和集成协议”、WSDL（Web Services Description Language）“WEB服务描述语言”等Web服务标准。

　　JDeveloper 不仅仅是很好的 Java 编程工具，而且是 Oracle Web 服务的延伸，支持 Apache SOAP，以及 9iAS ，可扩充的环境和 XML 和 WSDL 语言紧密相关。Oracle9i Jdeveloper完全利用Java编写，能够与以前的Oracle服务器软件以及其他厂商支持J2EE的应用服务器产品相兼容，而且在设计时着重针对Oracle9i，能够无缝化跨平台之间的应用开发，提供了业界第一个完整的、集成了J2EE和XML的开发环境，允许开发者快速开发可以通过Web、无线设备及语音界面访问的Web服务和交易应用，以往只能通过将传统Java编程技巧与最新模块化方式结合到一个单一集成的开发环境中之后才能完成J2EE应用开发生命周期管理的事实，从根本上得到改变。缺点就是对于初学者来说，较复杂，也比较难。

   6、IBM的Visual Age for Java

   Visual Age for Java是一个非常成熟的开发工具，它的特性以于IT开发者和业余的Java编程人员来说都是非常用有用的。它提供对可视化编程的广泛支持，支持利用CICS连接遗传大型机应用，支持EJB的开发应用，支持与Websphere的集成开发，方便的bean创建和良好的快速应用开发(RAD)支持和无文件式的文件处理。

　　IBM为建设Web站点所推出的WebSphere Studio Advanced Edition及其包含的VisualAge for Java Professional Edition软件已全面转向以Java为中心，这样，Java开发人员对WebSphere全套工具的感觉或许会好了许多。Studio所提供的工具有：Web站点管理、快速开发 JDBC页向导程序、HTML编辑器和HTML语法检查等。这确实是个不错的HTML站点页面编辑环境。Studio和VisualAge集成度很高，菜单中提供了在两种软件包之间快速移动代码的选项。这就让使用Studio的Web页面设计人员和使用VisualAge的Java程序员可以嗷ソ换晃募⑿ぷ鳌?BR>
　　Visual Age for Java支持团队开发，内置的代码库可以自动地根据用户做出改动而修改程序代码，这样就可以很方便地将目前代码和早期版本做出比较。与Visual Age紧密结合的Websphere Studio本身并不提供源代码和版本管理的支持，它只是包含了一个内置文件锁定系统,当编辑项目的时候可以防止其他人对这些文件的错误修改，软件还支持诸如Microsoft Visual SourceSafe这样的第三方源代码控制系统。Visual Age for Java完全面向对象的程序设计思想使得开发程序非常快速、高效。你可以不编写任何代码就可以设计出一个典型的应用程序框架。Visual Age for Java作为IBM电子商务解决方案其中产品之一，可以无缝地与其他IBM产品，如WebSphere、DB2融合, 迅速完成从设计、开发到部署应用的整个过程。

　　Visual Age for Java独特的管理文件方式使其集成外部工具非常困难,你无法让Visual Age for Java与其他工具一起联合开发应用。

7、BEA 的 WebLogic Workshop

    BEA WebLogic Workshop是一个统一、简化、可扩展的开发环境，使所有的开发人员都能在 BEA WebLogic Enterprise Platform之上构建基于标准的企业级应用，从而提高了开发部门的生产力水平，加快了价值的实现。

　　WebLogic Workshop除了提供便捷的Web服务之外，它能够用于创建更多种类的应用。作为整个BEA WebLogic Platform的开发环境。不管是创建门户应用、编写工作流、还是创建Web应用，Workshop 8.1都可以帮助开发人员更快更好地完成。

　　WebLogic Workshop的主要特点如下：

　　① 使 J2EE 开发切实可行，提高开发效率

　　BEA WebLogic Workshop 使开发人员远离 J2EE 内在的复杂性，集中精力专注业务逻辑，无须操心单调乏味的基础结构代码。这种创新意味着，已被企业验证的 J2EE 的强大功能，最终被大多数不熟悉 Java 和 J2EE 的应用开发人员所掌握，从而使 IT 部门的工作效率提高一个数量级。

　　可视化设计器以及直观的概念，如事件、属性和控件等，实现了基于事件的开发。Workshop 简化的程序设计模型，使开发人员不必掌握复杂的 J2EE API 和面向对象的程序设计原理。所有开发人员，包括 J2EE 专家和具有可视化和过程化语言技能的应用开发人员在内，都可以共同工作在 BEA WebLogic Enterprise Platform 之上。Workshop 的可视化开发环境，创建带有代码注释的标准 Java 文件，用来说明由运行时框架实施的企业级需求。J2EE 和其他高级开发人员，借助功能强大的代码编辑功能，可以访问 Java 源代码，从而弥补了可视化设计器的不足。

　　② 构建企业级应用

　　通过在可伸缩、安全可靠的企业级架构上实施各种应用，BEA WebLogic Workshop 大大降低了开发风险。而且，所有应用的创建都使用标准的 J2EE 组件，既保护了您的技术投资，又保持了最大的灵活性。
BEA WebLogic Workshop 运行框架，是统一整个架构的汇聚层，使单一、简化的程序设计模型扩展到所有的 BEA WebLogic Enterprise Platform 应用类型。通过解释设计时创建的注释代码，运行时框架可以实现必要的 J2EE 组件，并且提取出与 J2EE 应用开发有关的所有底层细节。

　　③ 降低 IT 复杂性

　　BEA WebLogic Workshop 提供各种 Java 控件，使得与 IT 资源的连接更轻而易举。另外，在构建任何 BEA WebLogic Platform 的应用中，Java 控件不仅可扩展而且完全相同。这种强大、有效的方法能够：降低 IT 技术的复杂性，优化信息的可用性，推动包含"最佳业务方案"的可重用服务的开发，使开发人员能以更低的成本、更短的时间实现更大的产出。

　　利用 BEA WebLogic Workshop，任何开发人员都能以最大的生产效率，构建各种 Web 服务、Web 应用、门户和集成项目。BEA WebLogic Workshop是BEA的产品战略核心，它帮助客户接触和利用面向服务架构(SOA)的强大功能。BEA Weblogic Workshop 8.1极大简化了当前实际企业集成环境中企业级应用和服务的构建，并成为全面支持关键企业级应用(如异步、真正松耦合和粗粒度消息传送等)的自然选择。它的缺点就是过于复杂，对于初学者来说，理解起来较为困难。

8、WebGain 的Visual Cafe for Java

Visual Cafe 是只能在Symantec公司的Java虚拟机、Netscape公司的Java虚拟机和Microsoft虚拟机上工作的调试器。这对于开发者来讲是一个重要的特性,因为用户开发的Java代码中的许多软件bug就可能中会在某种特定的虚拟机上起作用。

　　在修改后进行编译基继续进行调试时,Visual Cafe会自动将文件存盘，使用Visual Cafe创建的原生应用具有许多特点。除了明显的速度提高之外,Symantec使类库的二进制方式比正常的JDK小Visual Cafe为所指定的关系自动生成或更新必要的Java代码。利用Visual Cafe，用户可以从一个标准对象数据库中集合完整的Java应用程序和Applet，而不必再编写源代码。Visual Cafe还提供了一个扩充的源代码开发工具集。　

　　Visual Cafe综合了Java软件的可视化源程序开发工具，它允许开发人员在可视化视图和源视图之间进行有效地转换。在可视化视图中进行的修改立即反映在源代码中。对源代码的改变自动更新可视化视图。

　　Visual Cafe具有许多源文件方面的特性，如全局检索和替换。绝大多数Java开发工具的文献的问题在于简单地挨个介绍开发工具的每部分组件，但用户在开应用时还需要一个面向任务的手册，利用这个手册你可以不必知道工具每一部分的特定功能就可以开始创建自己的应用。Visual Cafe提供了非常全面的用户指南,它对最开始的安装到创建第一个Java应用和Applet都提供了全面的帮助，Visual Cafe将自动生成所指明关系的必要Java代码。Visual Cafe可以在Windows 95和Windows NT平台下运行，Symantec公司为Java开发工作提供一个在Macintosh操作系统下可以运行的RAD工具。Visual Cafe编译器速度很快，在国际化支持方面比较突出；缺点就是对于初学者来说，较复杂，也比较难。

9、Macromedia的JRUN

    Macromedia公司的JRun是一个具有最广阔适用性的Java引擎，用于开发及实施由Java Servlets和JavaServer Pages编写的服务器端Java应用。JRun是第一个完全支持JSP 1.0 规格书的商业化产品，全球有超过80,000名开发人员使用JRun在他们已有的Web服务器上添加服务器端Java的功能。其中Web服务器包括了Microsoft IIS，Netscape Enterprise Server，Apache等。

　　JRun是开发实施服务器端Java的先进引擎。如果我们希望在我们的Web应用中添加服务器端Java功能，那么JRun将成为我们的正确选择。

　　JRun目前有3个版本，它是第一个支持Java Server Pages(JSP)规格书1.0的商业化产品。JSP是一种强大的服务器端技术，它是用于创建复杂Web应用的一整套快速应用开发系统。JRun可以使我们开始开发并测试Java应用。它最多接受5个并发的连接并且包括全部Java Servlet API，支持JavaServer Pages(JSP)，支持所有主要的Web servers和计算机平台。 JRun Pro能够在生产环境下承受大访问量的负载，帮助我们实施应用、服务或Web站点（包括内联网）。JRun Pro 支持无限量并发式连接运行多个Java虚拟机，包括多个并发的Java虚拟机（JVM）。提供一个远程管理applet以及一个远程可再分布式的管理applet。JRun Pro Unlimited包括了所有JRun Pro的功能，除次以外，还可以运行无限量的，并发的JVM。

　　JRun依靠其内置的JRun Web Server可以单独运行。使用服务器端Java，用户可以开发出复杂的商业应用系统。最重要的一点是，由于servlets的平台独立性，以及更加简单的开发、更快速的实施、更经济的维护成本，它是CGI(Common Gateway Interface)或Perl scripts的极佳的替代产品。缺点就是对于初学者来说，较复杂，也比较难。

10、JCreator

    JCreator 是一个Java程序开发工具，也是一个Java集成开发环境（IDE）。无论你是要开发Java应用程序或者网页上的Applet元件都难不倒它。在功能上与Sun公司所公布的JDK等文字模式开发工具相较之下来得容易，还允许使用者自订义操作窗口界面及无限Undo/Redo等功能。

　　JCreator为用户提供了相当强大的功能，例如项目管理功能，项目模板功能，可个性化设置语法高亮属性、行数、类浏览器、标签文档、多功能编绎器，向导功能以及完全可自定义的用户界面。通过JCreator，我们不用激活主文档而直接编绎或运行我们的JAVA程序。

　　JCreator能自动找到包含主函数的文件或包含Applet的Html文件，然后它会运行适当的工具。在JCreator中，我们可以通过一个批处理同时编绎多个项目。JCreator的设计接近Windows界面风格，用户对它的界面比较熟悉。其最大特点是与我们机器中所装的JDK完美结合，是其它任何一款IDE所不能比拟的。它是一种初学者很容易上手的java开发工具，缺点是只能进行简单的程序开发，不能进行企业J2EE的开发应用。

11、Microsoft VJ++
     Visual J++ 是Microsoft 公司推出的可视化的Java 语言集成开发环境(IDE)，为Java 编程人员提供了一个新的开发环境，是一个相当出色的开发工具。无论集成性、编译速度、调试功能、还是易学易用性，都体现了Microsoft 的一惯风格。Visual J++ 具有下面的特点：

　　1）Visual J++ 把Java 虚拟机(JVM)作为独立的操作系统组件放入Windows，使之从浏览器中独立出来。

　　2）Microsoft 的应用基本类库(AFC,Application Foundation Class Library)对SUN 公司的JDK 作了扩展，使应用基本类库更加适合在Windows 下使用。

　　3） Visual J++ 的调试器支持动态调试，包括单步执行、设置断点、观察变量数值等。

　　4） Visual J++ 提供了一些程序向导(Wizards)和生成器(Builders)，它们可以方便地帮助用户快速地生成Java 程序，帮助你在自己的工程中创建和修改文件。

　　5） Visual J++ 界面友好，其代码编辑器具有智能感知、联机编译等功能，使程序编写十分方便。Visual J++ 中建立了Java 的WFC，这一新的应用程序框架能够直接访问Windows 应用程序接口(API)，使你能够用Java 语言编写完全意义上的Windows 应用程序。

　　6）Visual J++ 中表单设计器的快速应用开发特性使用WFC 创建基于表单的应用程序变得轻松、简单。通过WFC 可以方便地使用ActiveX 数据对象(ADO,ActiveX Data Objects)来检索数据和执行简单数据的绑定。通过在表单设计器中使用ActiveX 数据对象，可以快速地在表单中访问和显示数据。

　　Visual J++能结合微软的一贯的编程风格，很方便进行Java 的应用开发，但它的移植性较差，不是纯的Java 开发环境。

12、Eclipse

    Eclipse是一种可扩展的开放源代码IDE。2001年11月，IBM公司捐出价值4,000万美元的源代码组建了Eclipse联盟，并由该联盟负责这种工具的后续开发。集成开发环境(IDE)经常将其应用范围限定在“开发、构建和调试”的周期之中。为了帮助集成开发环境(IDE)克服目前的局限性，业界厂商合作创建了Eclipse平台。Eclipse允许在同一IDE中集成来自不同供应商的工具，并实现了工具之间的互操作性，从而显著改变了项目工作流程，使开发者可以专注在实际的嵌入式目标上。

　　Eclipse框架的这种灵活性来源于其扩展点。它们是在XML中定义的已知接口，并充当插件的耦合点。扩展点的范围包括从用在常规表述过滤器中的简单字符串，到一个Java类的描述。任何Eclipse插件定义的扩展点都能够被其它插件使用，反之，任何Eclipse插件也可以遵从其它插件定义的扩展点。除了解由扩展点定义的接口外，插件不知道它们通过扩展点提供的服务将如何被使用。

　　利用Eclipse，我们可以将高级设计(也许是采用UML)与低级开发工具(如应用调试器等)结合在一起。如果这些互相补充的独立工具采用Eclipse扩展点彼此连接，那么当我们用调试器逐一检查应用时，UML对话框可以突出显示我们正在关注的器件。事实上，由于Eclipse并不了解开发语言，所以无论Java语言调试器、C/C++调试器还是汇编调试器都是有效的，并可以在相同的框架内同时瞄准不同的进程或节点。

　　Eclipse的最大特点是它能接受由Java开发者自己编写的开放源代码插件，这类似于微软公司的Visual Studio和Sun微系统公司的NetBeans平台。Eclipse为工具开发商提供了更好的灵活性，使他们能更好地控制自己的软件技术。Eclipse联盟已经宣布将在2004年中期发布其3.0版软件。这是一款非常受欢迎的java开发工具，这国内的用户越来越多，实际上实用它java开发人员是最多的。缺点就是较复杂，对初学者来说，理解起来比较困难。

13、Ant

    Another Neat Tool(Ant)是一种基于Java的build工具。理论上来说，它有些类似于（Unix）C中的make ，但没有make的缺陷。因为Ant的原作者在多种(硬件)平台上开发软件时，无法忍受这些工具的限制和不便。类似于make的工具本质上是基于shell（语言）的：他们计算依赖关系，然后执行命令（这些命令与你在命令行敲的命令没太大区别）。这就意味着你可以很容易地通过使用OS特有的或编写新的（命令）程序扩展该工具；然而，这也意味着你将自己限制在了特定的OS，或特定的OS类型上，如Unix。Ant就不同了。与基于shell命令的扩展模式不同，Ant用Java的类来扩展。（用户）不必编写shell命令，配置文件是基于XML的，通过调用target树，就可执行各种task。每个task由实现了一个实现了特定Task接口的对象来运行。

　　Ant支持一些可选task，一个可选task一般需要额外的库才能工作。可选task与Ant的内置task分开，单独打包。这个可选包可以从你下载Ant的同一个地方下载。ANT本身就是这样一个流程脚本引擎，用于自动化调用程序完成项目的编译，打包，测试等。除了基于JAVA是平台无关的外，脚本的格式是基于XML的，比make脚本来说还要好维护一些。Ant是Apache提供给Java开发人员的构建工具，它可以在Windows OS和Unix OS下运行，它不仅开放源码并且还是一个非常好用的工具。Ant是Apache Jakarta中一个很好用的Java开发工具，Ant配置文件采用XML文档编写，所以Java程序员对其语法相当熟悉，Ant是专用于Java项目平台，能够用纯Java来开发，它能够运行于Java安装的平台，即体现了它的跨平台功能。它的缺点显示执行结果只能是DOS字符界面，不能进行复杂的java程序开发。

14、IntelliJ

    Intellij IDEA是一款综合的Java 编程环境，被许多开发人员和行业专家誉为市场上最好的IDE。它提供了一系列最实用的的工具组合：智能编码辅助和自动控制，支持J2EE，Ant，JUnit和CVS集成，非平行的编码检查和创新的GUI设计器。IDEA把Java开发人员从一些耗时的常规工作中解放出来，显著地提高了开发效率。具有运行更快速，生成更好的代码；持续的重新设计和日常编码变得更加简易，与其它工具的完美集成；很高的性价比等特点。在4.0版本中支持Generics，BEA WebLogic集成，改良的CVS集成以及GUI设计器。

　　IntelliJ IDEA能尽可能地促进程序员的编程速度。它包括了很多辅助的功能，并且与Java结合得相当好。不同的工具窗口围绕在主编程窗口周围，当鼠标点到时即可打开，无用时也可轻松关闭，使用户得到了最大化的有效屏幕范围。以技术为导向的IDEA集成了调试器，支持本地和远程的调试，即使我们需要修改一些设置上的东西使我们的工作顺利进展。另外，它还提供了通常的监视，分步调试以及手动设置断点功能，在这种断点模式下，我们可以自动地在断点之外设置现场访问，甚至可以浏览不同的变量的值。IDE支持多重的JVM设置，几个编译程序和Ant建造系统，并且，它使得设置多重的自定义的类途径变得简单。

　　IntelliJ Idea是一个相对较新的Java IDE。它是Java开发环境中最为有用的一个。高度优化的IntelleJ Idea使普通任务变得相当容易，Idea支持很多整合功能，更重要的使它们设计的好容易使用。Idea支持XML中的代码实现，Idea同时还会校正XML，Idea支持JSP的结构。作用于普通Java代码的众多功能同样适用于JSP（比如整合功能），同时支持JSP调试；支持EJB，尽管它不包括对个别应用服务器的特殊支持。Idea支持Ant建立工具，不仅是运行目标它还支持编译与运行程序前后运行目标，另外也支持绑定键盘快捷键。在编辑一个Ant建立XML文件时，Idea还对组成Ant工程的XML部分提供支持。IntelliJ IDEA 被称为是最好的JAVA IDE开发平台，这套软件就是以其聪明的即时分析和方便的 refactoring 功能深获大家所喜爱。缺点是较复杂，对初学者来说，理解起来比较困难。

　　小结

　　现在常用的Java项目开发环境有：JBuilder、VisualAge for Java、Forte for Java, Visual Cafe、Eclipse、NetBeans IDE、JCreator +J2SDK、jdk+记事本、EditPlus+ J2SDK等等。一般开发J2EE项目时都需要安装各公司的应用服务器（中间件）和相应的开发工具，在使用这些开发工具之前，我们最好能熟知这些软件的优点和缺点，以便根据实际情况选择应用。编程工具只是工具，为了方便人们工作而开发的，各有特点，因此，选工具主要的依据自己将要从事的领域是什么，而不是盲目的认为那种工具好，那种工具不好。最后希望大家都能找到自己合适的java 开发工具。

posted @ 2006-04-05 13:37 阿成 阅读(217) | 评论 (0) | 编辑 收藏
Eclipse快捷键大全

Eclipse 快捷键大全
类别 命令 键序列 说明
C/C++ Source Add Block Comment Ctrl+Shift+/ C/C++ Editor
C/C++ Source Add Include Ctrl+Shift+N C/C++ Editor
C/C++ Source Comment Ctrl+/ C/C++ Editor
C/C++ Source Find Declaration Ctrl+G C/C++ Editor
C/C++ Source Find References Ctrl+Shift+G C/C++ Editor
C/C++ Source Format Ctrl+Shift+F C/C++ Editor
C/C++ Source Go to Matching Bracket Ctrl+Shift+P C/C++ Editor
C/C++ Source Go to next C/C++ member Ctrl+Shift+向下键 C/C++ Editor
C/C++ Source Go to previous C/C++ member Ctrl+Shift+向上键 C/C++ Editor
C/C++ Source Open Declaration F3 C/C++ Editor
C/C++ Source Open Definition Ctrl+F3 C/C++ Editor
C/C++ Source Open Type Ctrl+Shift+T C/C++ Editor
C/C++ Source Remove Block Comment Ctrl+Shift+\ C/C++ Editor
C/C++ Source Show outline Ctrl+O C/C++ Editor
C/C++ Source Uncomment Ctrl+\ C/C++ Editor
Makefile Source Comment Ctrl+/ Makefile Editor
Makefile Source Open declaration F3 Makefile Editor
Makefile Source Uncomment Ctrl+\ Makefile Editor
Refactor - C/C++ Redo - Refactoring Alt+Shift+Y C/C++ Editor
Refactor - C/C++ Rename - Refactoring Alt+Shift+R C/C++ Editor
Refactor - C/C++ Undo - Refactoring Alt+Shift+Z C/C++ Editor
View Zoom In Ctrl+= 在窗口中
View Zoom Out Ctrl+- 在窗口中
搜索 工作空间中的声明 Ctrl+G 在窗口中
搜索 工作空间中的引用 Ctrl+Shift+G 在窗口中
搜索 打开“搜索”对话框 Ctrl+H 在窗口中
搜索 显示“文件中的出现位置”快速菜单 Ctrl+Shift+U 在窗口中
文件 “新建”菜单 Alt+Shift+N 在窗口中
文件 保存 Ctrl+S 在窗口中
文件 全部保存 Ctrl+Shift+S 在窗口中
文件 全部关闭 Ctrl+Shift+F4 在窗口中
文件 全部关闭 Ctrl+Shift+W 在窗口中
文件 关闭 Ctrl+F4 在窗口中
文件 关闭 Ctrl+W 在窗口中
文件 刷新 F5 在窗口中
文件 属性 Alt+Enter 在窗口中
文件 打印 Ctrl+P 在窗口中
文件 新建 Ctrl+N 在窗口中
文件 重命名 F2 在窗口中
文本编辑 上一个词语 Ctrl+左箭头 编辑文本
文本编辑 上滚行 Ctrl+向上键 编辑文本
文本编辑 下一个词语 Ctrl+右箭头 编辑文本
文本编辑 下滚行 Ctrl+向下键 编辑文本
文本编辑 全部展开 Ctrl+Numpad_Multiply 编辑文本
文本编辑 切换折叠 Ctrl+Numpad_Divide 编辑文本
文本编辑 删除上一个词语 Ctrl+Backspace 编辑文本
文本编辑 删除下一个词语 Ctrl+Delete 编辑文本
文本编辑 删除至行末 Ctrl+Shift+Delete 编辑文本
文本编辑 删除行 Ctrl+D 编辑文本
文本编辑 在当前行上面插入行 Ctrl+Shift+Enter 编辑文本
文本编辑 在当前行下面插入行 Shift+Enter 编辑文本
文本编辑 复制行 Ctrl+Alt+向下键 编辑文本
文本编辑 将行上移 Alt+向上键 编辑文本
文本编辑 将行下移 Alt+向下键 编辑文本
文本编辑 展开 Ctrl+Numpad_Add 编辑文本
文本编辑 折叠 Ctrl+Numpad_Subtract 编辑文本
文本编辑 改写切换 Insert 编辑文本
文本编辑 更改为大写 Ctrl+Shift+X 编辑文本
文本编辑 更改为小写 Ctrl+Shift+Y 编辑文本
文本编辑 选择上一个词语 Ctrl+Shift+左箭头 编辑文本
文本编辑 选择下一个词语 Ctrl+Shift+右箭头 编辑文本
文本编辑 重复行 Ctrl+Alt+向上键 编辑文本
查看 Java 包资源管理器 Alt+Shift+Q，P 在窗口中
查看 Java 声明 Alt+Shift+Q，D 在窗口中
查看 Java 类型层次结构 Alt+Shift+Q，T 在窗口中
查看 Javadoc Alt+Shift+Q，J 在窗口中
查看 变量 Alt+Shift+Q，V 在窗口中
查看 同步 Alt+Shift+Q，Y 在窗口中
查看 备忘单 Alt+Shift+Q，H 在窗口中
查看 控制台 Alt+Shift+Q，C 在窗口中
查看 搜索 Alt+Shift+Q，S 在窗口中
查看 断点 Alt+Shift+Q，B 在窗口中
查看 显示视图 (查看: 大纲) Alt+Shift+Q，O 在窗口中
查看 显示视图 (查看: 问题) Alt+Shift+Q，X 在窗口中
浏览 &Quick Cross References Alt+Shift+P 编辑 Java 源代码
浏览 Open AspectJ Type Alt+Shift+A 在窗口中
浏览 Open AspectJ Type in Hierarchy Alt+Shift+H 在窗口中
浏览 “显示位置”菜单 Alt+Shift+W 在窗口中
浏览 上一个编辑位置 Ctrl+Q 在窗口中
浏览 下一页 Ctrl+. 在窗口中
浏览 前一页 Ctrl+, 在窗口中
浏览 前移历史记录 Alt+右箭头 在窗口中
浏览 后退历史记录 Alt+左箭头 在窗口中
浏览 在层次结构中打开类型 Ctrl+Shift+H 在窗口中
浏览 快速大纲 Ctrl+O 编辑 Java 源代码
浏览 快速层次结构 Ctrl+T 编辑 Java 源代码
浏览 打开声明 F3 在窗口中
浏览 打开外部 Javadoc Shift+F2 在窗口中
浏览 打开类型 Ctrl+Shift+T 在窗口中
浏览 打开类型层次结构 F4 在窗口中
浏览 打开结构 Ctrl+F3 编辑 Java 源代码
浏览 打开调用层次结构 Ctrl+Alt+H 在窗口中
浏览 打开资源 Ctrl+Shift+R 在窗口中
浏览 转至上一个成员 Ctrl+Shift+向上键 编辑 Java 源代码
浏览 转至下一个成员 Ctrl+Shift+向下键 编辑 Java 源代码
浏览 转至匹配的方括号 Ctrl+Shift+P 编辑 Java 源代码
浏览 转至行 Ctrl+L 编辑文本
源代码 切换 Ant 标记出现 Alt+Shift+O 编辑 Ant 构建文件
源代码 切换标记出现 Alt+Shift+O 编辑 Java 源代码
源代码 切换注释 Ctrl+/ 编辑 Java 源代码
源代码 切换注释 Ctrl+7 编辑 Java 源代码
源代码 切换注释 Ctrl+Shift+C 编辑 Java 源代码
源代码 在文件中重命名 Alt+Shift+R 编辑 Ant 构建文件
源代码 快速辅助 － 在文件中重命名 Ctrl+2，R 编辑 Java 源代码
源代码 快速辅助 － 指定给字段 Ctrl+2，F 编辑 Java 源代码
源代码 快速辅助 － 指定给局部变量 Ctrl+2，L 编辑 Java 源代码
源代码 打开外部文档 Shift+F2 编辑 Ant 构建文件
源代码 显示工具提示描述 F2 编辑 Ant 构建文件
源代码 显示源代码快速菜单 Alt+Shift+S 在窗口中
源代码 格式 Ctrl+Shift+F 编辑 Ant 构建文件
源代码 格式化 Ctrl+Shift+F 编辑 Java 源代码
源代码 添加 Javadoc 注释 Alt+Shift+J 在窗口中
源代码 添加块注释 Ctrl+Shift+/ 编辑 Java 源代码
源代码 添加导入 Ctrl+Shift+M 编辑 Java 源代码
源代码 组织导入 Ctrl+Shift+O 在窗口中
源代码 缩进行 Ctrl+I 编辑 Java 源代码
源代码 除去出现注释 Alt+Shift+U 编辑 Java 源代码
源代码 除去块注释 Ctrl+Shift+\ 编辑 Java 源代码
窗口 上一个编辑器 Ctrl+Shift+F6 在窗口中
窗口 上一个视图 Ctrl+Shift+F7 在窗口中
窗口 上一个透视图 Ctrl+Shift+F8 在窗口中
窗口 下一个编辑器 Ctrl+F6 在窗口中
窗口 下一个视图 Ctrl+F7 在窗口中
窗口 下一个透视图 Ctrl+F8 在窗口中
窗口 切换至编辑器 Ctrl+Shift+E 在窗口中
窗口 将活动视图或编辑器最大化 Ctrl+M 在窗口中
窗口 打开编辑器下拉列表 Ctrl+E 在窗口中
窗口 显示标尺上下文菜单 Ctrl+F10 编辑文本
窗口 显示系统菜单 Alt+- 在窗口中
窗口 显示视图菜单 Ctrl+F10 在窗口中
窗口 显示键辅助 Ctrl+Shift+L 在对话框和窗口中
窗口 激活编辑器 F12 在窗口中
编辑 Add Block Comment Ctrl+Shift+/ Editing in Structured Text Editors
编辑 Format Active Elements Ctrl+I Editing in Structured Text Editors
编辑 Format Document Ctrl+Shift+F Editing in Structured Text Editors
编辑 Move Alt+Shift+V Editing JSP Source
编辑 Occurrences in File Ctrl+Shift+A Editing in Structured Text Editors
编辑 Open Selection F3 Editing in Structured Text Editors
编辑 Quick Fix Ctrl+1 Editing in Structured Text Editors
编辑 Remove Block Comment Ctrl+Shift+\ Editing in Structured Text Editors
编辑 Rename Alt+Shift+R Editing JSP Source
编辑 Rename XSD element Alt+Shift+R Editing XSD context
编辑 Restore Last Selection Alt+Shift+向下键 Editing in Structured Text Editors
编辑 Select Enclosing Element Alt+Shift+向上键 Editing in Structured Text Editors
编辑 Select Next Element Alt+Shift+右箭头 Editing in Structured Text Editors
编辑 Select Previous Element Alt+Shift+左箭头 Editing in Structured Text Editors
编辑 Show Tooltip Description F2 Editing in Structured Text Editors
编辑 Toggle Comment Ctrl+Shift+C Editing in Structured Text Editors
编辑 “快速差别”开关 Ctrl+Shift+Q 编辑文本
编辑 上下文信息 Alt+? 在窗口中
编辑 上下文信息 Alt+Shift+? 在窗口中
编辑 内容辅助 Alt+/ 在对话框和窗口中
编辑 切换插入方式 Ctrl+Shift+Insert 编辑文本
编辑 删除 Delete 在窗口中
编辑 剪切 Ctrl+X 在对话框和窗口中
编辑 剪切 Shift+Delete 在对话框和窗口中
编辑 增量查找 Ctrl+J 编辑文本
编辑 增量逆向查找 Ctrl+Shift+J 编辑文本
编辑 复制 Ctrl+C 在对话框和窗口中
编辑 复制 Ctrl+Insert 在对话框和窗口中
编辑 复原上一个选择 Alt+Shift+向下键 编辑 Java 源代码
编辑 快速修正 Ctrl+1 在窗口中
编辑 撤消 Ctrl+Z 在窗口中
编辑 文字补全 Ctrl+Alt+/ 编辑文本
编辑 显示工具提示描述 F2 编辑 Java 源代码
编辑 查找上一个 Ctrl+Shift+K 编辑文本
编辑 查找下一个 Ctrl+K 编辑文本
编辑 查找并替换 Ctrl+F 在窗口中
编辑 粘贴 Ctrl+V 在对话框和窗口中
编辑 粘贴 Shift+Insert 在对话框和窗口中
编辑 选择上一个元素 Alt+Shift+左箭头 编辑 Java 源代码
编辑 选择下一个元素 Alt+Shift+右箭头 编辑 Java 源代码
编辑 选择全部 Ctrl+A 在对话框和窗口中
编辑 选择外层元素 Alt+Shift+向上键 编辑 Java 源代码
编辑 重做 Ctrl+Y 在窗口中
运行／调试 Debug AspectJ/Java Application Alt+Shift+D，C 在窗口中
运行／调试 Debug on Server Alt+Shift+D，R 在窗口中
运行／调试 EOF Ctrl+Z 在控制台中
运行／调试 Profile on Server Alt+Shift+P，R 在窗口中
运行／调试 Run AspectJ/Java Application Alt+Shift+X，C 在窗口中
运行／调试 Run on Server Alt+Shift+X，R 在窗口中
运行／调试 切换单步执行过滤器 Shift+F5 在窗口中
运行／调试 切换行断点 Ctrl+Shift+B 在窗口中
运行／调试 单步跳入 F5 调试
运行／调试 单步跳入选择的内容 Ctrl+F5 调试
运行／调试 单步跳过 F6 调试
运行／调试 单步返回 F7 调试
运行／调试 执行 Ctrl+U 在窗口中
运行／调试 显示 Ctrl+Shift+D 在对话框和窗口中
运行／调试 检查 Ctrl+Shift+I 在对话框和窗口中
运行／调试 继续 F8 调试
运行／调试 调试 Ant 构建 Alt+Shift+D，Q 在窗口中
运行／调试 调试 Eclipse 应用程序 Alt+Shift+D，E 在窗口中
运行／调试 调试 JUnit 插件测试 Alt+Shift+D，P 在窗口中
运行／调试 调试 JUnit 测试 Alt+Shift+D，T 在窗口中
运行／调试 调试 Java Applet Alt+Shift+D，A 在窗口中
运行／调试 调试 Java 应用程序 Alt+Shift+D，J 在窗口中
运行／调试 调试 SWT 应用程序 Alt+Shift+D，S 在窗口中
运行／调试 调试上次启动 F11 在窗口中
运行／调试 运行 Ant 构建 Alt+Shift+X，Q 在窗口中
运行／调试 运行 Eclipse 应用程序 Alt+Shift+X，E 在窗口中
运行／调试 运行 JUnit 插件测试 Alt+Shift+X，P 在窗口中
运行／调试 运行 JUnit 测试 Alt+Shift+X，T 在窗口中
运行／调试 运行 Java Applet Alt+Shift+X，A 在窗口中
运行／调试 运行 Java 应用程序 Alt+Shift+X，J 在窗口中
运行／调试 运行 SWT 应用程序 Alt+Shift+X，S 在窗口中
运行／调试 运行上次启动 Ctrl+F11 在窗口中
运行／调试 运行至行 Ctrl+R 调试
重构 － Java 内联 Alt+Shift+I 在窗口中
重构 － Java 将局部变量转换为字段 Alt+Shift+F 编辑 Java 源代码
重构 － Java 抽取局部变量 Alt+Shift+L 在窗口中
重构 － Java 抽取方法 Alt+Shift+M 在窗口中
重构 － Java 撤销 － 重构 Alt+Shift+Z 在窗口中
重构 － Java 显示重构快速菜单 Alt+Shift+T 在窗口中
重构 － Java 更改方法特征符 Alt+Shift+C 在窗口中
重构 － Java 移动 － 重构 Alt+Shift+V 在窗口中
重构 － Java 重做 － 重构 Alt+Shift+Y 在窗口中
重构 － Java 重命名 － 重构 Alt+Shift+R 在窗口中
项目 全部构建 Ctrl+B 在窗口中

posted @ 2006-04-05 13:33 阿成 阅读(219) | 评论 (0) | 编辑 收藏
Powered by:
BlogJava
Copyright ©2024 阿成