欧美中文在线观看,有码一区二区三区,在线中文字幕视频

《设计模式》之Java解读--桥接Bridge

Thu, 29 Jul 2010 05:56:00 GMT

摘要: 1、核心意图： ��抽象部分和实现部分分离�Q��它们都可以独立的变化�?该模式的目标是通过把高层的抽象和底层的实现分开�Q�分别构��q��c�d��ơ结构，�q��过实现部分的接口将两部分进行桥接，从而达到高层抽象和底层实现可以独立的方便扩展的目的。其核心是分��，和委托�? 2、��n边实例： Java语言的一个非帔R��要的特点是��^台的无关性，对于一般的高��语言所�~�写的程序，如果要在不同的��^��C��... 阅读全文

林光�?/a> 2010-07-29 13:56 发表评论

Java Class Loader

Sun, 30 Aug 2009 12:54:00 GMT

态库、动态连接库

�E�序�~�制一般需�l�编辑、编译、连接、加载和�q�行几个步骤。在我们的应用中�Q�有一些公�׃��码是需要反复��用，��把�q�些代码�~�译�?#8220;�?#8221;文�g�Q�在�q�接步骤中，�q�接器将从库文�g取得所需的代码，复制到生成的可执行文件中。这�U�库�U�Cؓ静态库�Q�其特点是可执行文�g中包含了库代码的一份完整拷贝；�~�点��是被多�ơ��用就会有多䆾冗余拯��?/p>

��Z��克服�q�个�~�点可以采用动态连接库。这个时候连接器仅仅是在可执行文件中打上标志�Q�说明需要��用哪些动态连接库�Q�当�q�行�E�序�Ӟ��加蝲器根据这些标志把所需的动态连接库加蝲到内存�?/p>

另外在当前的�~�程环境中，一般都提供�Ҏ��让程序在�q�行的时候把某个特定的动态连接库加蝲�q�运行，也可以将其卸载（例如Win32的LoadLibrary()&FreeLibrary()和Posix的dlopen()&dlclose()�Q�。这个功能被�q�泛地用于在�E�序�q�行时刻更新某些功能模块或者是�E�序外观�?/p>

What is ClassLoader?

与普通程序不同的是，Java�E�序�Q�class文�g�Q��ƈ不是本地的可执行�E�序。当�q�行Java�E�序�Ӟ��首先�q�行JVM�Q�Java虚拟机）�Q�然后再把Java class加蝲到JVM里头�q�行�Q�负责加载Java class的这部分��叫做Class Loader�?/p>

JVM本��n包含了一个ClassLoader�U�CؓBootstrap ClassLoader�Q�和JVM一��P��Bootstrap ClassLoader是用本地代码实现的，它负责加载核心Java Class�Q�即所有java.*开头的�c�）。另外JVM�q�会提供两个ClassLoader�Q�它们都是用Java语言�~�写的，由Bootstrap ClassLoader加蝲�Q�其中Extension ClassLoader负责加蝲扩展的Java class�Q�例如所有javax.*开头的�c�d��存放在JRE的ext目录下的�c�）�Q�Application ClassLoader负责加蝲应用�E�序自��n的类�?/p>

When to load the class?

什么时候JVM会��用ClassLoader加蝲一个类呢？当你使用java��L��行一个类�Q�JVM使用Application ClassLoader加蝲�q�个�c�；然后如果�c�A引用了类B�Q�不��是直接引用�q�是用Class.forName()引用�Q�JVM��׃��扑ֈ�加蝲�c�A的ClassLoader�Q��ƈ用这个ClassLoader来加载类B�?/p>

Why use your own ClassLoader?

��g��JVM自��n的ClassLoader已经��_��了，��Z��么我们还需要创��q��ClassLoader呢？

因�ؓJVM自带的ClassLoader只是懂得从本地文件系�l�加载标准的java class文�g�Q�如果编写你自己的ClassLoader�Q�你可以做到�Q?br /> 1�Q�在执行非置信代码之前，自动验证数字�{�֐�
2�Q�动态地创徏�W�合用户特定需要的定制化构建类
3�Q�从特定的场所取得java class�Q�例如数据库�?br /> 4) �{�等

事实上当使用Applet的时候，��q��C��特定的ClassLoader�Q�因��旉��要从�|�络上加载java class�Q��ƈ且要��查相关的安全信息�?/p>

目前的应用服务器大都使用了ClassLoader技术，即��你不需要创��q��ClassLoader�Q�了解其原理也有助于更好地部�|�自��q��应用�?nbsp;

ClassLoader Tree & Delegation Model

当你军_��创徏你自��q��ClassLoader�Ӟ��需要��承java.lang.ClassLoader或者它的子�c�R��在实例化每个ClassLoader对象�Ӟ��需要指定一个父对象�Q�如果没有指定的话，�pȝ��自动指定ClassLoader.getSystemClassLoader()为父对象。如下图�Q?/p>

在Java 1.2后，java class的加载采用所谓的委托模式�Q�Delegation Modle�Q�，当调用一个ClassLoader.loadClass()加蝲一个类的时候，��遵循以下的步骤�Q?br /> 1�Q�检查这个类是否已经被加载进来了�Q?br /> 2�Q�如果还没有加蝲�Q�调用父对象加蝲该类
3�Q�如果父对象无法加蝲�Q�调用本对象的findClass()取得�q�个�c�R�?/p>

所以当创徏自己的Class Loader�Ӟ��只需要重载findClass()�q�个�Ҏ��?/p>

Unloading? Reloading?

当一个java class被加载到JVM之后�Q�它有没有可能被卸蝲呢？我们知道Win32有FreeLibrary()函数�Q�Posix有dlclose()函数可以被调用来卸蝲指定的动态连接库�Q�但是Java�q�没有提供一个UnloadClass()的方法来卸蝲指定的类�?/p>

在Java中，java class的卸载仅仅是一�U�对�pȝ��的优化，有助于减��应用对内存的占用。既然是一�U�优化方法，那么��完全是JVM自行军_��如何实现�Q�对Java开发�h员来说是完全透明的�?/p>

在什么时候一个java class/interface会被卸蝲呢？Sun公司�?a class or interface may be unloaded if and only if its class loader is unreachable. Classes loaded by the bootstrap loader may not be unloaded."

事实上我们关心的不是如何卸蝲�cȝ��Q�我们关心的是如何更新已�l�被加蝲了的�c�M��而更新应用的功能。JSP则是一个非常典型的例子�Q�如果一个JSP文�g被更改了�Q�应用服务器则需要把更改后的JSP重新�~�译�Q�然后加载新生成的类来响应后�l�的��h��?/p>

其实一个已�l�加载的�c�L��无法被更新的�Q�如果你试图用同一个ClassLoader再次加蝲同一个类�Q�就会得到异常（java.lang.LinkageError: duplicate class definition�Q�，我们只能够重新创��Z��个新的ClassLoader实例来再�ơ加载新�c�R��至于原来已�l�加载的�c�，开发�h员不必去��它�Q�因为它可能�q�有实例正在被��用，只要相关的实例都被内存回收了�Q�那么JVM��׃��在适当的时候把不会再��用的�c�d��载�?/p>

林光�?/a> 2009-08-30 20:54 发表评论

TOMCAT源码�ȝ��一

Sun, 30 Aug 2009 12:05:00 GMT

首先不得不说�q�个�c�org.apache.tomcat.util.net.JIoEndpoint�Q�它负责所有的TCP��h��q�接�Q�实��C��一个服务器模式�Q�启用一个后台监听线�E�，负责接收到来的socket�Q�然后从�U�程池中取出响应的worker�Q�扔�l�worker�q�行处理�Q�自��q��l�监听。其�ơworker是一个负责处理socket的一个线�E�，��是它带着用户的请求开始进入Tomcat世界的，默认的worker��d��?00个，卻I��最�?00个线�E�。当处理完一个请求的时候，�q�个�U�程�q�不会销毁，而是�q�入wait��d��Q�这个线�E�的对象也不会销毁，是进入了一个栈里面�Q�对应workstack那个数据�l�构。每当接收线�E�拿��C��个socket的时候，��先从栈里面拿出一个已有的�U�程对象�Q�然后就利用该对象的assign�Ҏ��Q�将�q�个socket�l�它�Q��ƈ调用notify重新唤醒�q�个worker的处理线�E�。以后我们做��型服务器的时候，可以借鉴它的实现方式。正在研�I�多�U�程的朋友，�q�个�cȝ��对让你可以学的透彻�Q?/p>

相对应的�q�有一个org.apache.tomcat.util.net.NioEndpoint�Q�这个和前面那个功能差不多，但是用了NIO包里的API�Q�有一个最大的区别��是�Q�接收线�E�接收一个socket之后�Q�可能会��这个socket先放入缓存池�Q�然后worker从池里面拿socket��d��理，比前面那个类看�v来功能和性能都会提升很多�Q�不�q�代码行�?K多，相当复杂�Q�设计不够精巧，有兴��可以去研究下�?/p>

org.apache.tomcat.util.buf.MessageBytes�Q�这是一个接�q�底层的字符串处理类�Q��ؓ什么说是接�q�底层，是因为socket接收�q�来的都是字节类型，而java用的是char或者String�Q�这之间的�{换涉及到�~�码问题和性能问题�Q�所以凡是socket收进来的信息�Q�全部都用这个类表示�Q�只有当要输出字�W�串的时候，才会��里面的字节�q�行转换�Q�实��C��U��g�q�加载的懒模式，被Tomcat底层所使用的Request�c�，��是大量使用了这个类来存放数据。我们来��小�H�视一下，Request�c�：

private MessageBytes methodMB = MessageBytes.newInstance();
private MessageBytes unparsedURIMB = MessageBytes.newInstance();
private MessageBytes uriMB = MessageBytes.newInstance();
private MessageBytes decodedUriMB = MessageBytes.newInstance();
private MessageBytes queryMB = MessageBytes.newInstance();
private MessageBytes protoMB = MessageBytes.newInstance();
// remote address/host
private MessageBytes remoteAddrMB = MessageBytes.newInstance();
private MessageBytes localNameMB = MessageBytes.newInstance();
private MessageBytes remoteHostMB = MessageBytes.newInstance();
private MessageBytes localAddrMB = MessageBytes.newInstance();
private MimeHeaders headers = new MimeHeaders();

或许大家会觉得，构造出�q�么多的�c�，性能会高到哪里去�Q�其实不是这��L��Q�不停的构造和销毁对象的��会损耗相当的性能�Q�但是一个对象被构造出来，可以重复利用�Q�那��q��当完��了�Q�这个类��是如此的设计，其中有一个回收资源的�Ҏ��Q�叫recycle()�Q�这个方法可以清�I�里面的数组�Q�清�I�里面的对象�Q�而不会销毁自己本�w�，因�ؓ使用它的对象�Q�只要调用recycle�Q�以后又可以重复使用了�?/p>

MessageBytes其实内置�?个重要的�c�，org.apache.tomcat.util.buf.ByteChunk和org.apache.tomcat.util.buf.CharChunk�Q�这2个类带我们回��C��C时代�Q��ؓ什么这么说�Q�因为它��直就是一个字�W�串处理�c�，一些眼熟的��法全部映入眼帘�Q�比如字�W��{匚w��法�Q�indexOf�Q�startsWith�Q�判断字�W��{是否相等�Q�查扑֭��W�，�{�等�Q�比之JDK提供的性能更好�Q�功能更强大�Q�这句话说过了，呵呵�Q?/p>

�q�有一个实用的值得学习的数据结构是�Q�org.apache.tomcat.util.buf.Ascii�Q�如果知道表驱动的朋友们�Q�一定对�q�个�c�d��熟悉了，判断大小写？判断是不是英文单词？判断是不是空白符�Q�判断是不是数字�Q�将字节�c�d��转换为int、long�c�d��Q�大��写转换�Q�等�{�。这些都是大学计��机评��的课后练习题

林光�?/a> 2009-08-30 20:05 发表评论

如何处理HTTP POST/GET��h��

Sat, 29 Aug 2009 03:56:00 GMT

期：2005-11-14 11:44:00 [Host01.Com] 讉K��Q?font color="#c0c0c0"> 　　　　[全屏查看全文]

Servlet通过下面的方法来提供服务�Q?

实现service�Ҏ��?br />
实现HttpServlet的doMethod�Ҏ��Q�doGet、doDelete、doOptions�?doPost、doPut、doTrace�Q��?/li>

    通常�Q�service�Ҏ��用来从客戯��求（request�Q�中提取信息�Q�访问扩展资源，�q�基于上面的信息提供响应�Q�response�Q��?

    对于HTTP Servlets�Q�正��提供响应的�q�程是首先填写响应（response�Q�的头信息，然后从响应（response�Q�中得到输出��，最后向输出��中写入内容信息。响应（response�Q�头信息必须最先设�|�。下面将描述如何从请求（request�Q�中获得信息和��生HTTP响应�Q�response�Q��?

取得客户端请�?
一个HttpServletRequest对象提供到达HTTP 头部数据�Q�也允许你获取客��L��的数据。怎样获取�q�些数据取决于HTTP端请求方法。不��用��M��HTTP方式�Q�你都可以用 getParameterValues�Ҏ��q�回特定名称的参数倹{��对于用 HTTP GET ��h��的方式，�q�个getQueryString�Ҏ��会�q�回一个可以用来分析的倹{�?

客户端请求（request�Q�包含了从客��L��传递到Servlet的数据。所有的��h��Q�request�Q�都实现了ServletRequest接口。这个接口定义了一些方法访问下面的信息�Q�如�?4-1所�C��?

�?4-1  ServletRequest接口�Ҏ��
            �c?�?�?�q?                         �?�?�?�?
            参数�Q�用来在客户端和Servlet之间传送信�?getAttribute(String name)
            getAttributeNames()
            getInputStream()
            getParameter(String name)
            getParameterMap()
            getParameterNames()
            getParameterValues(String name)
            对象值属性，用来在Servlet容器和Servlet
            之间�Q�或者协作的Servlet之间传递信�?    removeAttribute(String name)
            setAttribute(String name, Object o)
            有关��h��使用的协议信息，
            客户端和服务器在��h��中的调用	   getContentLength()
            getContentType()
            getProtocol()
            getReader()
            getRealPath(String path)
            getRemoteAddr()
            getRemoteHost()
            getRequestDispatcher(String path)
            有关��h��使用的协议信息，
            客户端和服务器在��h��中的调用       getScheme()
            getServerName()
            getServerPort()
            isSecure()
            有关localization的信�?       getCharacterEncoding()
            getLocale()
            getLocales()
            setCharacterEncoding(String env)

下面的代码段�C��了如何��用request中的�Ҏ��获得客户端信息�?

Enumeration params = request.getParameterNames();
            String paramName = null;
            String[] paramValues = null;
            while (params.hasMoreElements()) {
            paramName = (String) params.nextElement();
            paramValues = request.getParameterValues(paramName);
            System.out.println("\nParameter name is " + paramName);
            for (int i = 0; i < paramValues.length; i++) {
            System.out.println(", value " + i + " is " + paramValues[i].toString());
            }
            }

HTTP Servlets使用HTTP request对象�Q�HttpServletRequest�Q�，它包含了request URL、HTTP头信息、查询字�W�串�Q�等�{�。HTTP request URL 包括几个部分�Q?br /> http://: ?

一般情况下�Q?

requestURI = contextPath + servletPath + pathInfo
            Context path�Q�通过getContextPath�Ҏ��获得�?
            Servlet Path�Q�通过getServletPath�Ҏ��获得�?
            PathInfo�Q�通过getPathInfo�Ҏ��获得�?/ccid_code>

如表14-2所�C��?

�?4-2  路径的对�?
            Request Path	            Path Elements
            /catalog/help/feedback.jsp	ContextPath: /catalog ServletPath:
            /help/feedback.jsp PathInfo: null

提供HTTP响应
响应�Q�response�Q�包含了在服务器和客��L��之间传递的数据。所有的响应�Q�response�Q�都实现了ServletResponse接口。这个接口定义了一些方法提供给开发�h员��用，如表14-3所�C��?

�?4-3  ServletResponse接口�Ҏ��
            �c?�?�?�q?                          �?�?�?�?
            获得向客��L��发送数据的输出��? 发送字�W�流�Q�getWriter()
            发送字节流�Q�getOutputStream()
            指示响应�q�回的内容类型（例如�Q�text/html�Q?
            已经注册的内容类型名�U�C��存在IANA
            �Q�Internet Assigned Numbers Authority�Q?setContentType(java.lang.String type)
            指出是否是缓冲输出。默认情况下写入输出�?
            内容被立卛_��送到客户端。��用缓冲后写入输出的内容先
            不发送到客户端，�q�样Servlet有更多的旉���讄���相应�?
            状态码和头信息�Q�或者�{�U�d��其他的Web资源	 flushBuffer()
            getBufferSize()
            isCommitted()
            reset()
            resetBuffer()
            setBufferSize(int size)
            setContentLength(int len)
            讄���localization信息	            getCharacterEncoding()
            getLocale()
            setLocale(java.util.Locale loc)

HTTP response�c�（HttpServletResponse�Q�有一些代表HTTP头信息的域：

状态码用来指出响应�Q�response�Q�失败的原因�?

Cookies在客��L��存储应用相关的信息，有时cookies用来�l�护和标识用��L��session�?

Servlet首先讄��响应�Q�response�Q�头信息�Q�包括响应（response�Q�的内容�c�d��和缓冲区大小�Q�然后在doGet�Ҏ��中从响应�Q�response�Q�获得PrintWriter �Q�最后向输出中写入HTML代码�Q�调用close()�Ҏ��提交�q�次对客��L��的响应（response�Q�。示范代码如下：

public void doGet (HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException, IOException
            {
            // 讄���头信�?
            response.setContentType("text/html");
            response.setBufferSize(8192);
            PrintWriter out = response.getWriter();
            // 向response中输�?
            out.println("" +
            "+
            messages.getString("TitleBookDescription")
            +");
            ...
            out.println("");
            // 关闭输出��?
            out.close();
            }

林光�?/a> 2009-08-29 11:56 发表评论

TOMCAT源码分析(消息处理)

Wed, 26 Aug 2009 12:53:00 GMT

�Q�前�a�

我们知道了tomcat的整体框架了�Q?也明白了里面都有些什么组�Ӟ�� 以及各个�l��g是干什么用的了�?/span>

http://www.csdn.net/Develop/read_article.asp?id=27225

我想�Q�接下来我们应该��M��解一�?tomcat 是如何处理jsp和servlet��h��的�?/span>

1. 我们以一个具体的例子�Q�来跟踪TOMCAT�Q?/span>看看它是如何�?/span>Request一层一层地递交�l�下一个容器，�q�最后交�l?/span>Wrapper来处理的�?/span>

�?/span>http://localhost:8080/web/login.jsp��Z��?/span>

�Q�以下例子，都是�?/span>tomcat4 源码为参考）

�q�篇心得主要分�ؓ3个部分：前期�Q?中期�Q?和末期�?/span>

前期�Q�讲解了在浏览器里面输入一个URL�Q�是怎么被tomcat抓住的�?/span>

中期�Q�讲解了被tomcat抓住后，又是怎么在各个容器里面穿梭，最后到达最后的处理地点�?/span>

末期�Q�讲解到达最后的处理地点后，又是怎么具体处理的�?/span>

2�?/span> 前期 Request的born.

在这里我先简单讲一下request�q�个东西�?/span>

我们先看着�q�个URL�Q?/span>http://localhost:8080/web/login.jsp 它是动用�?080端口来进行socket通讯的�?/span>

我们知道, 通过

InputStream in = socket.getInputStream() �?/span>

OutputStream out = socket.getOutputStream()

��可以实现消息的来来往往了�?/span>

但是如果把Stream�l�应用层看，昄��操作��h��不方�ѝ�?

所以，在tomcat 的Connector里面�Q?socket被封装成了Request和Response�q�两个对象�?/span>

我们可以��单地把Request看成��发到服务器来的数据�Q�把Response看成惛_��出服务器的数据�?/span>

但是�q�样又有其他问题了啊�Q?Request�q�个对象是把socket��装��h��了，但是他提供的又东西太多了�?/span>

诸如Request.getAuthorization(), Request.getSocket()�?nbsp;像Authorization�q�种东西开发�h员拿来基本上用不太着�Q�而像socket�q�种东西�Q�暴露给开发�h员又有潜在的危险�?而且啊，在Servlet Specification里面标准的通信�c�L��ServletRequest和HttpServletRequest�Q�而非�q�个Request�c�R�?So, So, So. Tomcat必须得捣持捣持Request才行�?最后tomcat选择了��用捣持模式（应该叫适配器模式）来解册��个问题。它把org.apache.catalina.Request 捣持成了 org.apache.coyote.tomcat4.CoyoteRequest�?而CoyoteRequest又实��C��ServletRequest和HttpServletRequest �q�两�U�接口�?�q�样��提供给开发�h员需要且刚刚需要的�Ҏ��了�?/span>

ok, �?/span>我们�?tomcat的顶层容�?- StandardEngin 的invoke()�Ҏ��q�里讄��一个断点，然后讉K��

http://localhost:8080/web/login.jsp�Q?我们来看看在前期都会路过哪些地方�Q?/span>

1. run(): 536, java.lang.Thread, Thread.java

CurrentThread

2. run():666, org.apache.tomcat.util.threads.ThreadPool$ControlRunnable, ThreadPool.java

ThreadPool

3. runIt():589, org.apache.tomcat.util.net.TcpWorkerThread, PoolTcpEndpoint.java

ThreadWorker

4. processConnection(): 549

org.apache.coyote.http11.Http11Protocol$Http11ConnectionHandler, Http11Protocol.java

http protocol parser

5. Process(): 781, org.apache.coyote.http11.Http11Processor, Http11Processor.java

http request processor

6. service(): 193, org.apache.coyote.tomcat4.CoyoteAdapter,CoyoteAdapter.java

adapter

7. invoke(): 995, org.apache.catalina.core.ContainerBase, ContainerBase.java

StandardEngin

1. �ȝ��E?/span>

2. 启动�U�程�?

3. 调出�U�程池里面空闲的工作�U�程�?/span>

4. �?080端口传过来由httpd协议��装的数据，解析成Request和Response对象�?/span>

5. 使用Http11Processor来处理request

6. �?/span>Http11Processor里面�Q?又会call CoyoteAdapter来进行适配处理�Q�把Request适配成实��C��ServletRequest和HttpServletRequest接口�?/span>CoyoteRequest.

7. ��C��q�里�Q�前期的��L��拔皮工作��基本上搞定�Q�可以交�l?/span>StandardEngin 做核心的处理工作了�?/span>

3. 中期�?在各个容器间的穿梭�?/span>

Request在各个容器里面的�I�梭大致是这样一�U�方式：

每个容器里面都有一个管道（pipline�Q�，专门用来传送Request用的�?/span>

��道里面又有好几个阀门（valve�Q�，专门用来�q��oRequest用的�?/span>

在管道的低部通常都会放上一个默认的阀们�?�q�个阀们至��会做一件事情，��是把Request交给子容器�?/span>

让我们来惌��一下：

当一个Request�q�入一个容器后�Q?它就在管道里面流动，波罗~ 波罗~ 波罗~ 地穿�q�各个阀门。在��到最后一个阀门的时候，吧唧~ 那个该死的阀门就把它扔给了子容器�?然后又开�?波罗~ 波罗~ 波罗~ ... 吧唧~.... 波罗~ 波罗~ 波罗~ ....吧唧~....

��是通过�q�种方式�Q?Request 走完了所有的容器。（感觉有点像消化系�l�，最后一个地�Ҏ��点像那里~ �Q?/span>

OK�Q?让我们具体看看都有些什么容器，各个容器里面又都有些什么阀门，�q�些阀们都�Ҏ��们的Request做了些什么吧�Q?/span>

3.1 StandardEngin 的pipeline里面攄��是：StandardEnginValve

在这里，VALVE做了三�g事：

1. 验证传递过来的request是不�?/span>httpservletRequest.

2 验证传递过来的 request 是否携带�?/span>host header信息.

3 选择相应�?/span>host��d��理它。（一般我们都只有一个host:localhost�Q�也��是127.0.0.1�Q��?/span>

��C��q�个地方�Q?/span>我们�?/span>request��已�l�完成了�?/span>Engin�q�个部分的历史��命，通向前途未卜的下一站： host了�?/span>

3.2 StandardHost 的pipline里面攄��是： StandardHostValve

1. 验证传递过来的request是不�?/span>httpservletRequest.

2. �Ҏ��Request来确定哪�?/span>Context来处理�?/span>

Context其实��是webapp�Q?/span>比如http://localhost:8080/web/login.jsp

�q�里web��是Context�|�！

3. 既然��定了是哪个Context了，那么��应该把那个Context�?/span>classloader付给当前�U�程了�?/span>

Thread.currentThread().setContextClassLoader(context.getLoader().getClassLoader());

�q�样request��只看得见指定的context下面�?/span>classes啊， jar啊这些，而看不见tomcat本��n的类�Q?/span>什�?/span>Engin啊， Valve啊�?/span>不然�q�得了啊�Q?/span>

4. 既然request��C��q�里了，看来用户是准备访问web�q�个web app了，咋们得更��C��下这个用��L��session不是�Q?Ok , ��q��manager更新一下用��L��session信息

5. 交给具体的Context 容器�ȝ��l�处理Request.

6. Context处理完毕了，�?/span>classloader�q�回来�?/span>

3.3 StandardContext 的pipline里面攄��是： StandardContextValve

1. 验证传递过来的request是不�?/span>httpservletRequest.

2. 如果request意图不轨�Q�想要访�?/span>/meta-inf, /web-inf�q�些目录下的东西�Q�呵呵，没有用D!

3. �q�个时候就会根�?/span>Request到底�?/span>Servlet�Q?/span>�q�是jsp�Q?/span>�q�是静态资源来军_��到底用哪�U?/span>Wrapper来处理这�?/span>Reqeust了�?/span>

4. 一旦决定了到底用哪�U?/span>Wrapper�Q?/span>OK�Q�交�l�那�?/span>Wrapper处理�?/span>

4. 末期�?不同的需求是怎么处理�?

StandardWrapper

之前对Wrapper没有做过讲解�Q�其实它是这样一�U�东�ѝ�?/span>

我们在处理Request的时候，可以分成3�U��?/span>

处理静态的�Q?org.apache.catalina.servlets.DefaultServlet

处理jsp的：org.apache.jasper.servlet.JspServlet

处理servlet的：org.apache.catalina.servlets.InvokerServlet

不同的request��q��q?�U�不同的servlet��d��理�?/span>

Wrapper��是对它们的一�U�简单的��装�Q�有了Wrapper后，我们��可以轻村֜�拦截每次的Request。也可以�Ҏ��地调用servlet的init()和destroy()�Ҏ��Q?便于��理嘛！

具体情况是这么滴�Q?/span>

如果request是找jsp文�g�Q�StandardWrapper里面��׃��装一个org.apache.jasper.servlet.JspServlet��d��理它�?/span>

如果request是找静态资�?�Q�StandardWrapper里面��׃��装一个org.apache.jasper.servlet.DefaultServlet ��d��理它�?/span>

如果request是找servlet �Q�StandardWrapper里面��׃��装一个org.apache.jasper.servlet.InvokerServlet ��d��理它�?/span>

StandardWrapper同样也是容器�Q�既然是容器�Q?那么里面一定留了一个管道给request�ȝ��Q�管道低部肯定也有一个阀�?�?)�Q�用来做最后一道拦截工�?

在这最底部的阀门里�Q�其实就主要做了两�g�?

一是启动过滤器�Q�让request在N个过滤器里面�{�一通，如果OK�Q?那就PASS�?否则��p��到其他地方去了�?/span>

二是servlet.service((HttpServletRequest) request,(HttpServletResponse) response); �q�个�Ҏ��.

如果�?JspServlet�Q?那么先把jsp文�g�~�译成servlet_xxx, 再invoke servlet_xxx的servie()�Ҏ��?/span>

如果�?DefaultServlet�Q?��q��接找到静态资源，取出内容�Q?发送出厅R�?/span>

如果�?InvokerServlet�Q?��p��用那个具体的servlet的service()�Ҏ��?/span>

ok! 完毕�?/span>

�?: StandardWrapper 里面的阀门是最后一道关口了�?如果�q�个阀门欲意把request交给StandardWrapper 的子容器处理�?对不��P�� 在设计考虑的时候， Wrapper��p��考虑成最末的一个容器，压根儿就不会�l�Wrapper��d��子容器的��Z��Q?如果��是要调用addChild(), 立马抛出IllegalArgumentException�Q?/span>

参考：

<http://jakarta.apache.org/tomcat/>
<http://www.onjava.com/pub/a/onjava/2003/05/14/java_webserver.html>

作者Blog�Q?/strong>http://blog.csdn.net/ThomasHuang/

相关文章

TOMCAT源码分析(消息处理)

TOMCAT源码分析(启动框架)

林光�?/a> 2009-08-26 20:53 发表评论

TOMCAT源码分析(启动框架

Wed, 26 Aug 2009 12:49:00 GMT

TOMCAT源码分析(启动框架)     选择�?ThomasHuang �?Blog

关键�?/font> tomcat 源代�?源码 source code architecture

出处

TOMCAT源码分析(启动框架)
前言�Q?br />    本文是我阅读了TOMCAT源码后的一些心得�?主要是讲解TOMCAT的系�l�框�Ӟ�� 以及启动��程。若有错漏之处，敬请批评指教�Q?br /> ��Q?br />    毕竟TOMCAT的框架还是比较复杂的�Q?单是从文字上理解�Q?是不那么�Ҏ��掌握TOMCAT的框架的�?所以得实践、实��c��再实践�?��下蝲一份TOMCAT的源码，调试通过�Q?然后单步跟踪其启动过�E��?如果有不明白的地方，再来查阅本文�Q?看是否能得到帮助�?我相信这��h��果以及学习速度都会好很多！

1. Tomcat的整体框架结�?br />    Tomcat的基本框�Ӟ�� 分�ؓ4个层�ơ�?br />    Top Level Elements:
    Server
    Service
   Connector
    HTTP
    AJP
   Container
   Engine
     Host
   Context
   Component
    manager
   logger
   loader
   pipeline
   valve
         ...
   站在框架的顶层的是Server和Service
   Server: 其实��是BackGroud�E�序�Q?在Tomcat里面的Server的用处是启动和监听服务端事�g�Q�诸如重启、关闭等命��o�?在tomcat的标准配�|�文�Ӟ��server.xml里面�Q?我们可以看到“”�q�里�?SHUTDOWN"��是server在监听服务端事�g的时候所使用的命令字�Q?br />    Service�Q?在tomcat里面�Q?service是指一�c�问题的解决�Ҏ��?nbsp; 通常我们会默认��用tomcat提供的：Tomcat-Standalone 模式的service�?在这�U�方式下的service既给我们提供解析jsp和servlet的服务，同时也提供给我们解析静态文本的服务�?br />
   Connector: Tomcat都是在容器里面处理问题的�Q?而容器又到哪里去取得输入信息呢？
Connector��是专干�q�个的�?他会把从socket传递过来的数据�Q?��装成Request, 传递给容器来处理�?br />    通常我们会用��C��U�Connector,一�U�叫http connectoer�Q?用来传递http需求的�?另一�U�叫AJP�Q?在我们整合apache与tomcat工作的时候， apache与tomcat之间��是通过�q�个协议来互动的�?�Q�说到apache与tomcat的整合工作，通常我们的目的是��Z��让apache 获取静态资源，而让tomcat来解析动态的jsp或者servlet。）
   Container: 当http connector把需求传递给��的container: Engin的时候，我们的视�U�就应该�U�d��到Container�q�个层面来了�?br />    在Container�q�个层，我们包含�?�U�容器： Engin, Host, Context.
   Engin: 收到service传递过来的需求，处理后， ��结果返回给service( service 是通过 connector �q�个媒介来和Engin互动�?).
   Host: Engin收到service传递过来的需求后�Q�不会自己处理，而是交给合适的Host来处理�?br /> Host在这里就是虚拟主机的意思，通常我们都只会��用一个主机，�?#8220;localhost”本地机来处理�?
   Context: Host接到了从Host传过来的需求后�Q?也不会自己处理，而是交给合适的Context来处理�?
   比如�Q?<http://127.0.0.1:8080/foo/index.jsp>
         <http://127.0.1:8080/bar/index.jsp>
   前者交�l�foo�q�个Context来处理，后者交�l�bar�q�个Context来处理�?br />    很明昑֐��Q?context的意思其实就是一个web app的意思�?br />    我们通常都会在server.xml里面做这��L��配置

   �q�个context容器�Q�就是用来干我们该干的事儿的地方的�?br />
   Compenent: 接下来，我们�l�箋讲讲component是干什么用的�?br />    我们得先理解一下容器和�l��g的关�p�R�?br />    需求被传递到了容器里面，在合适的时候，会传递给下一个容器处理�?br />    而容器里面又盛装着各种各样的组�Ӟ�� 我们可以理解为提供各�U�各��L��增值服务�?br />    manager: 当一个容器里面装了manager�l��g后，�q�个容器��支持session��理了，事实上在tomcat里面的session��理�Q?��是靠的在context里面装的manager component.
   logger: 当一个容器里面装了logger�l��g后， �q�个容器里所发生的事情， ��p��该组件记录下来啦�Q?我们通常会在logs/ �q�个目录下看�?catalina_log.time.txt 以及 localhost.time.txt 和localhost_examples_log.time.txt�?�q�就是因为我们分别�ؓ�Q�engin, host以及context(examples)�q�三个容器安装了logger�l��g�Q?�q�也是默认安装，又叫做标�?�Q�）
   loader: loader�q�个�l��g通常只会�l�我们的context容器使用�Q?loader是用来启动context以及��理�q�个context的classloader用的�?br />     pipline: pipeline是这样一个东西，当一个容器决定了要把从上�U�传递过来的需求交�l�子容器的时候，他就把这个需求放�q�容器的��道(pipeline)里面厅R�?而需求傻呼呼得在��道里面��动的时候， ��׃��被管道里面的各个阀门拦截下来�?比如��道里面放了两个阀门�?�W�一个阀门叫�?#8220;access_allow_vavle”�Q?也就是说需求流�q�来的时候，它会看这个需求是哪个IP�q�来的，如果�q�个IP已经在黑名单里面了， sure, 杀�Q?�W�二个阀门叫�?#8220;defaul_access_valve”它会做例行的��查，如果通过的话�Q�OK�Q?把需求传递给当前容器的子容器�?��是通过�q�种方式�Q?需求就在各个容器里面传递，��动�Q?最后抵辄��的地的了�?br />     valve: ��是上面所说的阀门啦�?br />    Tomcat里面大概��是�q�么些东西，我们可以��单地�q�么理解tomcat的框�Ӟ��它是一�U�自上而下�Q?容器里又包含子容器的�q�样一�U�结构�?br /> 2. Tomcat的启动流�E?br />    �q�篇文章是讲tomcat怎么启动的，既然我们大体上了解了TOMCAT的框架结构了�Q?那么我们可以望文生意地就猜到tomcat的启动，会先启动父容器，然后逐个启动里面的子容器�?启动每一个容器的时候，都会启动安插在他�w�上的组件�?当所有的�l��g启动完毕�Q?所有的容器启动完毕的时候， tomcat本��n也就启动完毕了�?br />    ��理成章圎ͼ� 我们同样可以猜到�Q?tomcat的启动会分成两大部分�Q?�W�一步是装配工作�?�W�二步是启动工作�?
   装配工作��是为父容器装上子容器，为各个容器安插进�l��g的工作�?�q�个地方我们会用到digester模式�Q?至于digester模式什么，有什么用�Q?怎么工作�? 请参�?<http://software.ccidnet.com/pub/article/c322_a31671_p2.html>
   启动工作是在装配工作之后�Q?一旦装配成功了�Q?我们��只需要点燃最上面的一根导�U�，整个tomcat��׃��被激�z��v来�?�q�就好比我们要开一辆已�l�装配好了的汽�R的时候一��P��我们只要把钥匙插�q�钥匙孔�Q�一拧，汽�R的引擎就会发动�v来，�I��׃��开��h��Q?安全装置��׃��生效�Q?如此一来，汽�R整个��发动�v来了。（�q�个�q�程��实和TOMCAT的启动过�E�不谋而和�Q?让我们不得不怀�?TOMCAT的设计者是在GE做JAVA开发的�Q��?br /> 2.1 一些有意思的名称�Q?br />    Catalina
   Tomcat
   Bootstrap
   Engin
   Host
   Context
   他们的意思很有意思：
   Catalina: �q�程轰炸�?br />    Tomcat: 熊猫轰炸�?-- 轰炸机的一�U�（�q�让我想起了让国人引以�ؓ豪的熊猫手机�Q�是不是英文可以叫做tomcat??? �Q?又让我想起了另一则广告：波导-手机中的战斗机、�L�?客机中的战斗�?�Q?br />    Bootstap: 引导
   Engin: 发动�?br />    Host: ��L��Q�领�?br />    Context: 内容�Q?目标�Q?上下�?br />
   ... 在许多许多年后， ��C��人类已经灭绝�?后现代生物发��C��q�些单词零落零落在一块�?一个自以�ؓ聪明的家伙把�q�些东西��译出来了：
   在地勤�h员的引导(bootstrap)下，一架蘪炸架(catalina)腄��跃�v�Q?�q�看是熊猫蘪炸机(tomcat)�Q?�q�看�q�是熊猫轰炸机！凭借着优秀的发动机技�?engin)�Q?�q�架熊猫轰炸机飞临了敌国的领土上�I?host)�Q?对准目标(context)投下了毁天灭地的核弹��_��波~ ��C��生物��p��么隔屁了~

   �l�g��所�q�ͼ� �q�又不得不让��惛_��GE是不是也参与了军事设备的生��呢？
   反对��帝国主义！反对��霸权主义！和��^万岁�Q?自由万岁�Q?br />
2.2 历史��是那么惊�h的相��|�� tomcat的启动就是从org.apache.catalina.startup.Bootstrap�q�个�c�L��然启动的�Q?br />    在Bootstrap里做了两件事�Q?br />    1. 指定�?�U�类型classloader:
      commonLoader: common/classes、common/lib、common/endorsed
      catalinaLoader: server/classes、server/lib、commonLoader
      sharedLoader�Q?nbsp; shared/classes、shared/lib、commonLoader
   2. 引导Catalina的启动�?br />       用Reflection技术调用org.apache.catalina.startup.Catalina的process�Ҏ��Q?�q�传递参数过厅R�?br />
2.3 Catalina.java
   Catalina完成了几个重要的��d��Q?br />    1. 使用Digester技术装配tomcat各个容器与组件�?br />       1.1 装配工作的主要内�Ҏ��安装各个大�g�?比如server下有什么样的servcie�?Host会容�U�_��个context�?Context都会使用到哪些组件等�{��?
      1.2 同时呢，在装配工作这一步， �q�完成了mbeans的配�|�工作�?在这里，我简单地但不十分�_��地描�q�C��下mbean是什么，�q�什么用的�?br />           我们自己生成的对象，自己��理�Q?天经��C��Q?但是如果我们创徏了对象了�Q?惌��别�h来管�Q?怎么办呢�Q?我想臛_��得告诉别人我们都有什么，以及通过什么方法可以找�?nbsp; 吧！ JMX技术给我们提供了一�U�手�D�c�?JMX里面主要�?�U�东�ѝ��Mbean, agent, connector.
       Mbean�Q?用来映射我们的对象。也许mbean��是我们创徏的对象，也许不是�Q?但有了它�Q?��可以引用到我们的对象了�?br />        Agent: 通过它， ��可以找到mbean了�?br />        Connector: �q�接Agent的方式�?可以是http的，也可以是rmi的，�q�可以直接通过socket�?br />       发生在tomcat 装配�q�程中的事情: GlobalResourcesLifecycleListener �cȝ��初始化会被触发：
         protected static Registry registry = MBeanUtils.createRegistry(); 会运�?br />          MBeanUtils.createRegistry() 会依�?org/apache/catalina/mbeans/mbeans-descriptors.xml�q�个配置文�g创徏 mbeans. Ok, 外界��有了条途径讉K��tomcat中的各个�l��g了。（有点像后门儿�Q?br />    2. 为top level 的server 做初始化工作�?实际上就是做通常会配�|�给service的两条connector.(http, ajp)
   3. 从server�q�个容器开始启动，点燃整个tomcat.
   4. 为server做一个hook�E�序�Q?��当server shutdown的时候，关闭tomcat的各个容器用�?br />    5. 监听8005端口�Q?如果发�?SHUTDOWN"�Q�默认培植下字符�Ԍ��q�来�Q?关闭8005serverSocket�?br /> 2.4 启动各个容器
   1. Server
      触发Server容器启动�?before_start)�Q?启动�?start)�Q?启动�?after_start)3个事�Ӟ�� q�运行相应的事�g处理器�?br />       启动Server的子容器�Q�Servcie.
   2. Service
      启动Service的子容器�Q�Engin
      启动Connector
   3. Engin
      ��C��Engin�q�个层次�Q�以及以下��别的容器�Q?Tomcat��׃��用了比较一致的启动方式了�?br />       首先�Q?nbsp; �q�行各个容器自己�Ҏ��一些�Q�?br />       随后�Q?nbsp; 触发启动前事�?br />       立即�Q?nbsp; 讄��标签�Q�就表示该容器已�l�启�?br />       接着�Q?nbsp; 启动容器中的各个�l��g�Q?loader, logger, manager�{�等
      再接着�Q�启动mapping�l��g。（�?�Q?br />       紧跟着�Q�启动子容器�?br />       接下来，启动该容器的��道(pipline)
      然后�Q?nbsp; 触发启动中事�?br />       最后，触发启动后事件�?br />
      Engin大致会这么做�Q?Host大致也会�q�么做， Context大致�q�是会这么做�?那么很显然地�Q?我们需要在�q�里使用��C��码复用的技术�?tomcat在处理这个问题的时候，漂亮��C��用了抽象�c�L��处理�?ContainerBase. 最后��得这部分完成复杂功能的代码显得干净利落�Q?�q�练爽快�Q?实在是��o��得叹��止， �l�细品来�Q?直觉如��n佳珍�Q?另�h齉K��留香�Q?留恋往�q�啊�Q?br />
      Engin的触发启动前事�g里，会激�zȝ��定在Engin上的唯一一个Listener�Q�EnginConfig�?br />       �q�个EnginConfig�c�d��本上没有做什么事情， ��是把EnginConfig的调试��别设�|��ؓ和Engin相当�?另外��是输出几行文本�Q?表示Engin已经配置完毕�Q?�q�没有做什么实质性的工作�?br />       �?: mapping�l��g的用处是�Q?当一个需求将要从父容器传递到子容器的时候，而父容器又有多个子容器的话，那么应该选择哪个子容器来处理需求呢�Q?�q�个由mapping �l��g来定夺�?br />
   4. Host
       同Engin一��P�� 也是调用ContainerBase里面的start()�Ҏ��Q?不过之前做了些自个儿的�Q�?��是往Host�q�个容器的通道�Q�pipline�Q�里面，安装了一个叫�?br /> “org.apache.catalina.valves.ErrorReportValve”的阀门�?br />        �q�个阀门的用处是这��L��Q?nbsp; 需求在被Engin传递给Host后，会��l�传递给Context做具体的处理�?�q�里需求其实就是作为参��C��递的Request, Response�?所以在context把需求处理完后，通常会改动response�?而这个org.apache.catalina.valves.ErrorReportValve的作用就是检察response是否包含错误�Q?如果有就做相应的处理�?br />    5. Context
       ��C��q�里�Q?��q��于轮��C��tomcat启动中真正的重头戏，启动Context了�?br /> StandardContext.start() �q�个启动Context容器的方法被StandardHost调用.
5.1 webappResources 该context所指向的具体目�?br /> 5.2 安装defaultContex, DefaultContext ��是默认Context�?如果我们在一个Host下面安装了DefaultContext�Q�而且defaultContext里面又安装了一个数据库�q�接池资源的话�?那么其他所有的在该Host下的Context, 都可以直接��用这个数据库�q�接池，而不用格外做配置了�?br /> 5.3 指定Loader. 通常用默认的org.apache.catalina.loader.WebappLoader�q�个�c�R�?nbsp; Loader��是用来指定�q�个context会用到哪些类啊，哪些jar包啊�q�些什么的�?br /> 5.4 指定 Manager. 通常使用默认的org.apache.catalina.session. StandardManager �?Manager是用来管理session的�?br />      其实session的管理也很好实现�?以一�U�简单的session��理��Z��?当需求传递过来的时候，在Request对象里面有一个sessionId 属性�?OK�Q?得到�q�个sessionId后，我们��可以把它作为map的key�Q�而value我们可以攄��一个HashMap. HashMap里边儿，再放我们��x��的东�ѝ�?br /> 5.5 postWorkDirectory (). Tomcat下面有一个work目录�?我们把��时文仉��扔在那儿厅R�?�q�个步骤��是在那里创��Z��个目录�?一般说来会�?CATALINA_HOME%/work/Standalone\localhost\ �q�个地方生成一个目录�?br /> 5.6 Binding thread。到了这里， ��应该发�?class Loader 互换了�?之前是看得见tomcat下面所有的class和lib. 接下来需要看得见当前context下的class�?所以要讄��contextClassLoader, 同时�q�要把旧的ClassLoader记录下来�Q�因��Z��后还要用的�?br /> 5.7 启动 Loader. 指定�q�个Context具体要��用哪些classes�Q?用到哪些jar文�g�?如果reloadable讄��成了true, ��׃��启动一个线�E�来监视classes的变化，如果有变化就重新启动Context�?br /> 5.8 启动logger
5.9 触发安装在它�w�上的一个监听器�?br /> lifecycle.fireLifecycleEvent(START_EVENT, null);
作�ؓ监听器之一�Q�ContextConfig会被启动. ContextConfig��是用来配置web.xml的�?比如�q�个Context有多��Servlet�Q?又有多少Filter�Q?��是在这里给Context装上�ȝ��?br /> 5.9.1 defaultConfig. 每个context都得配置 tomcat/conf/web.xml �q�个文�g�?br /> 5.9.2 applicationConfig 配置自己�?WEB-INF/web.xml 文�g
5.9.3 validateSecurityRoles 权限验证�?通常我们在访�?admin 或�?manager的时候，需要用戯��么是admin的要么是manager的，才能讉K��?而且我们�q�可以限刉��些资源可以访问，而哪些不能�?都是在这里实现的�?br /> 5.9.4 tldScan: 扫描一下，需要用到哪些标�{?tag lab)
5.10 启动 manager
5.11 postWelcomeFiles() 我们通常会用到的3个启动文件的名称�Q?br /> index.html、index.htm、index.jsp ��p��默认地绑在了�q�个context�?br /> 5.12 listenerStart 配置listener
5.13 filterStart 配置 filter
5.14 启动带有1的Servlet.
��序是从��到大： 1,2,3… 最后是0
默认情况下，臛_��会启动如�?个的Servlet:
org.apache.catalina.servlets.DefaultServlet
      处理静态资源的Servlet. 什么图片啊�Q?html啊， css啊， js啊都找他
org.apache.catalina.servlets.InvokerServlet
      处理没有做Servlet Mapping的那些Servlet.
org.apache.jasper.servlet.JspServlet
      处理JSP文�g�?
       5.15 标识context已经启动完毕�?br /> ��C��多少个步骤啊�Q?Context�ȝ��是启动完毕喽�?br />     OK! 走到了这里，每个容器以及�l��g都启动完毕�?Tomcat�l�于不辞辛劳��Cؓ人民服务了！
3. 参考文献：
    <http://jakarta.apache.org/tomcat/>
    <http://www.onjava.com/pub/a/onjava/2003/05/14/java_webserver.html>

4. 后记
    �q�篇文章是讲解tomcat启动框架的，�q�有��文章是讲解TOMCAT里面的消息处理流�E�的�l�节的�?文章内容已经写好了，现在正在整理阶段�?�怿�很快��可以做出来�Q?大家共同研究共同�q�步�?br />     �q�篇文章是独自分析TOMCAT源码所写的�Q?所以一定有地方是带有个��Z��观色彩，隑օ�会有片面之处。若有不当之处敬��h��评指教，�q�样不仅可以使刚开始研�I�TOMCAT的兄弟们��走弯�\�Q?我也可以学到东西�?br />     email: sojan_java@yahoo.com.cn

5. tomcat源码分析(消息处理)

林光�?/a> 2009-08-26 20:49 发表评论

用Digester��化XML文档处理

Wed, 26 Aug 2009 12:27:00 GMT

Digester框架属于Jakarta Commons�Q�它以规则和模式为基��处理XML文档。与SAX和DOM之类的标准API相比�Q�Digester不涉及太多的�l�节问题�Q�非帔R��合于对XML文档�q�行��单的处理�?
在Java和XML开发中�Q�一个常见的��d��是把XML文档转换成对应的Java Bean对象的层�ơ结构。�h们经常用标准的SAX和DOM API来完成这个�Q务。虽然这两种API都很强大和灵�z�，但对于某些简单的��d��来说�Q�它们显得操作层�ơ太低，也就是说�Q�涉及了太多的细节问题。Jakarta Digester框架能够很好地满��c�d��合的需要�?

Digester框架��?
Jakarta的Digester框架从Struts框架发展而来�Q�原先被用来处理struts-config.xml配置文�g�Q�但很快��Z��认识到它有着更广泛的用途，把它转入了Jakarta Commons��目。Jakarta Commons的目标是提供一�?#8220;可重用Java�l��g的仓�?#8221;。Digester最新的版本�?.3�Q�于2002�q?�?3日发布�?
Digester框架允许开发者指定一�l�动作，当解析器在XML文档中发现某些特定的��单模式时动作被执行。Digester框架带有10个预定义的规则（Rule�Q�，�늛�了unmarshalling XML�Q�例如创建Bean或设�|�Bean属性）的大多数需求（ marshalling的原意是�?#8220;配制整齐�Q�编�l�列�?#8221;�Q�marshalling是在内存中�ؓJava对象生成XML描述文档的过�E�，而unmarshalling是指把XML形式的描�q��{换到可用Java代码操作的对象的�q�程�Q�我们称之�ؓ“反配�?#8221;�Q�，但必要时用户可以定义和实现自��q��规则�?
在本文的例子中，我们��反配制下面�q�个XML文档�Q?

Author 1 Title 1 Author 2 His One Book Mag Title 1
Some Headline

Another Headline
Author 2 His Other Book Mag Title 2
Second Headline

下面是Bean的代码。注意��用Digester框架�Ӟ��Bean�c�d��d��义成public�?

import java.util.Vector; public class Catalog { private Vector books; private Vector magazines; public Catalog() { books = new Vector(); magazines = new Vector(); } public void addBook( Book rhs ) { books.addElement( rhs ); } public void addMagazine( Magazine rhs ) { magazines.addElement( rhs ); } public String toString() { String newline = System.getProperty( "line.separator" ); StringBuffer buf = new StringBuffer(); buf.append( "--- Books ---" ).append( newline ); for( int i=0; i

1 2 下一��?gt;>

Digester框架以模式（Pattern�Q�和规则�Q�Rule�Q��ؓ基础处理输入的XML。模式必��M��XML元素匚w��Q�包括其名字和在文档树内的位�|�。描�q�匹配模式的语法�c�M��于XPath匚w��模式�Q�例如：catalog模式匚w��层�?ccid_code>元素�Q�catalog/book模式匚w��直接嵌套�?lt;catalog>元素内的元素�Q�但不匹配文档内其他位置�?lt;book>元素�Q?/ccid_code>�?
所有的模式都必��L��定其完整名称——从根元素开始的完整路径。唯一的例外是包含通配�W�（“*”�Q�的模式�Q�例�?/name模式匚w��XML文档内�Q何位�|�的元素。但是根元素不必特别指出�Q�因为所有的路径都是从根元素开始的�l�对路径�?
当Digester发现一个指定的模式�Q�它��执行关联的��d��。由此可见，Digester框架昄��与SAX解析器有着密切的关�p�（实际上，Digester�c�d��C��org.xml.sax.ContentHandler�Q��ƈ�l�护着解析栈）。所有在Digester中��用的规则必须扩展org.apache.commons.digester.Rule�Q�后者本�w�提供了一些类��g��SAX的ContentHandler回调函数的方法。例如，当遇到匹配元素的开始标记和�l�束标记�Ӟ��begin()�Ҏ��和end()�Ҏ��分别被调用�?
一旦遇到匹配元素的内容�Q�body()�Ҏ��被调用；最后被调用的方法是finish()�Q�这个方法在匚w��元素的结束标记处理完毕之后被调用�Q�用来执行可能需要的事后清理��d��。然而，大多数时候我们不必关注这些方法，因�ؓ框架提供的标准规则很可能已经提供了所有必需的功能�?
要反配制一个文档，首先创徏一个org.apache.commons.digester.Digester�cȝ��实例�Q�如果必要的话，�q�行一些配�|�操作，指定必需的模式和规则�Q�最后向parse()�Ҏ��传递一个XML文�g的引用。下面的DigesterDriver�C��了这一处理�q�程�Q�必��d��命��o行上指定输入XML文档的名�U�ͼ��?

import org.apache.commons.digester.*; import java.io.*; import java.util.*; public class DigesterDriver { public static void main( String[] args ) { try { Digester digester = new Digester(); digester.setValidating( false ); digester.addObjectCreate( "catalog", Catalog.class ); digester.addObjectCreate( "catalog/book", Book.class ); digester.addBeanPropertySetter( "catalog/book/author", "author" ); digester.addBeanPropertySetter( "catalog/book/title", "title" ); digester.addSetNext( "catalog/book", "addBook" ); digester.addObjectCreate( "catalog/magazine", Magazine.class ); digester.addBeanPropertySetter( "catalog/magazine/name", "name" ); digester.addObjectCreate( "catalog/magazine/article", Article.class ); digester.addSetProperties( "catalog/magazine/article", "page", "page" ); digester.addBeanPropertySetter( "catalog/magazine/article/headline" ); digester.addSetNext( "catalog/magazine/article", "addArticle" ); digester.addSetNext( "catalog/magazine", "addMagazine" ); File input = new File( args[0] ); Catalog c = (Catalog)digester.parse( input ); System.out.println( c.toString() ); } catch( Exception exc ) { exc.printStackTrace(); } } }

在上面的代码中，我们首先创徏了Digester�cȝ��一个实例digester�Q�然后指定它不要用DTD验证XML文档的合法性——这是因为我们没有�ؓXML文档定义DTD。接下来�Q�我们指定了模式和关联的规则�Q�ObjectCreateRule创徏指定�cȝ��一个实例，�q�将它压入解析栈。SetPropertiesRule把Bean属性设�|�成当前XML元素的属性值——规则的�W�一个参数是XML属性的名称�Q�第二个参数是Bean属性的名称�?
SetPropertiesRule获取的是XML属性的��|��而BeanPropertySetterRule获取的是位于当前元素内的原始字符数据倹{��用BeanPropertySetterRule时不必指定要讄��的Bean属性名字，默认是当前XML元素的名�U�。在上面的例子中�Q�在匚w��catalog/magazine/article/headline模式的规则定义中使用的就是默认倹{��最后，SetNextRule弹出解析栈顶部的对象�Q��ƈ把该对象传递给它下面对象的指定名称的方法——通常用来把一个配�|�完毕的Bean插入父对象�?
注意�Q�我们可以�ؓ同一个模式注册多个规则。如果注册了多个规则�Q�则�q�些规则按照它们被加入到Digester的次序执行，例如�Q�如果要处理catalog/magazine/article�?article>元素�Q�我们首先创建合适的article Bean�Q�然后设�|�page属性，最后弹出完成后的article Bean�Q��ƈ把它插入magazine�?

调用��L��Ҏ��
我们不仅可以讄��Bean的属性，而且�q�可以调用堆栈内对象的�Q意方法。这通过CallMethodRule完成�Q�我们只需指定�Ҏ��名字�Q�如有必要，再说明调用的参数�c�d��和数量。CallParamRule用来定义传递给被调用函数的参数��|��参数值可以从当前XML元素的命名的属性获取，也可以从当前元素包含的原始字�W�数据获取。例如，在前面实现DigesterDriver的例子中�Q�我们可以不用BeanPropertySetterRule�Q�而是通过昑ּ�调用属性的set�Ҏ��辑ֈ�同样的目的：

digester.addCallMethod( "catalog/book/author", "setAuthor", 1 ); digester.addCallParam( "catalog/book/author", 0 );

上面的第一行代码给��Z��要调用的�Ҏ��Q�即setAuthor()�Q�，以及该调用需要的参数数量�Q�即1�Q�。第二行代码的意思是�?author>元素包含的字�W�数据获取函数参数的��|��把它作�ؓ参数数组的第一个传入（即烦引是0的数�l�元素）。如果我们指定了XML元素属性的名称�Q�例如digester.addCallParam( "catalog/book/author", 0, "author" );�Q�，则参数值将从当前元素的相应属性��D��取�?
�q�里必须注意的是�Q?#8220;digester.addCallMethod( "pattern", "methodName", 0 );”�q�个语句不是指定了一个不带参数的�Ҏ��调用�Q�而是指定了带有一个参数的�Ҏ��调用�Q�它的值就是当前XML元素的字�W�数据！�q�样�Q�我们又有了另一�U�替代BeanPropertySetterRule的办法：

digester.addCallMethod( "catalog/book/author", "setAuthor", 0 );

如果要调用一个确实没有参数的�Ҏ��Q�必��采用如下�Ş式：digester.addCallMethod( "pattern", "methodName" );�?

标准规则概要
下面��要说明所有标准规则�?
创徏
ObjectCreateRule�Q�利用指定类的默认构造函敎ͼ�创徏该类的一个对象，�q�把对象压入栈。当元素处理�l�束�Ӟ��对象被弹出。被实例化的�c�d��通过class对象或类的全�U�给出�?
FactoryCreateRule�Q�利用指定的工厂�c�d��Z��个对象，把对象压入栈。对于没有提供默认构造函数的�c�，�q�一规则很有用。用于该规则的工厂类必须实现org.apache.commons.digester.ObjectCreationFactory接口�?
讄��属�?
SetPropertiesRule�Q�利用指定名�U�的XML元素属性��|��讄��层Bean的一个或者多个指定名�U�的属性。XML元素的属性名�U�和Bean的属性名�U�C��String[]数组形式传入该规则（通常用来处理
之类的结构）�?
BeanPropertySetterRule�Q�把��层Bean的指定名�U�的属性设�|�成当前XML元素包含的字�W�数据。（通常用来处理10之类的结构）�?
SetPropertyRule�Q�设�|�顶层Bean的一个属性。无论是Bean属性的名称�Q�还是赋予该属性的��|��都在当前XML元素中以属性的形式指定�Q�例如：
�?
��理�?子关�p?
SetNextRule�Q�弹出栈��的对象�Q�把它传递给紧接其下的另一个对象的指定名称的方法。通常用来把一个已�l�初始化的Bean插入到父对象�?
SetTopRule�Q�把栈里面上数第二的对象传递给��层的对象。当子对象提供了一个setParenet�Ҏ��Ӟ��q�一规则很有用�?
SetRootRule�Q�调用栈底对象的一个方法，�q�把栈顶的对象作为参��C��入�?
调用��L��Ҏ��
CallMethodRule�Q�调用顶层Bean的指定名�U�的�Ҏ��。被调用的方法可以有��L��多个参数�Q�参数的值通过后��的CallParamRule�l�出�?
CallParamRule�Q�表�C�方法调用的参数。参数的值或者取自指定名�U�的XML元素的属性，或者是当前元素包含的原始字�W�数据。这个规则要求用一个整数指定它在参数列表中的位�|��?

通过XML指定规则
在前面的内容中，我们用程序代码的方式指定模式和规则，�q�些模式和规则都是在�~�译的时候就已经��定�Q�虽然从概念上来讲比较简单，但却不能说尽善尽��：Digester框架的��M��目标是在�q�行时识别和处理各种数据�l�构�Q�但如果我们用编�E�的�Ҏ��指定模式和规则，则所有行为在�~�译时已�l�固定！如果Java源程序中包含了大量固定的字符�Ԍ��通常意味着�E�序在执行某些配�|�操作，�q�部分操作可以被�Q�或许是应该被）延迟到运行时�q�行�?
org.apache.commons.digester.xmlrules包解决了�q�个问题。这个包提供了一个DigesterLoader�c�，它能够从XML文档��d��模式/规则对，�q�回配置好的Digester对象。用来配�|�Digester对象的XML文档必须遵从digester-rules.dtd�Q�这个DTD是xmlrules包的一部分�?
下面��是本文例子的配�|�文件rules.xml。有几点必须说明�?
首先�Q�模式可以用两种方式指定�Q�或者��?ccid_code>元素�Q�或者通过代表规则的XML元素的属性。这两种办法可以混合使用�Q�且元素是可以嵌套的。其�ơ，元素�?lt;set-properties-rule>一起��用，用来把XML属性映��到Bean属性。最后，��当前发行的Digester软�g包而言�Q�我们不能在配置文�g中指定BeanPropertySetterRule�Q�正如前面所介绍的，我们用CallMethodRule来达到同��L��目标�?

现在�Q�所有实际的操作都�{�U�d��了Digester和DigesterLoader�c�，XmlRulesDriver�c�d��变得相当��单。运行下面的XmlRulesDriver�Ӟ��在第一个命令行参数中指定目录文档的名字�Q�在�W�二个参��C��指定rules.xml�Q�注意，DigesterLoader不是从File或者org.xml.sax.InputSource��d��rules.xml文�g�Q�而是要求指定一个URL�Q�因此，下面代码中File引用被�{换成了等��L��URL�Q��?

import org.apache.commons.digester.*; import org.apache.commons.digester.xmlrules.*; import java.io.*; import java.util.*; public class XmlRulesDriver { public static void main( String[] args ) { try { File input = new File( args[0] ); File rules = new File( args[1] ); Digester digester = DigesterLoader.createDigester( rules.toURL() ); Catalog catalog = (Catalog)digester.parse( input ); System.out.println( catalog.toString() ); } catch( Exception exc ) { exc.printStackTrace(); } } }

�l�束语：本文对Jakarta Commons Digester的介�l�就到这里结束。当�Ӟ��q�有许多内容�q�里��未涉及。其中一个在�q�里忽略的主题是XML名称�I�间�Q�Digester允许把规则定义成只能�Ҏ��一个名�U�空间内定义的元素�v作用�?
另外�Q�我们简单地提及了通过扩展Rule�c�d��发定制规则的问题。按照习惯，Digester�c�L��供了push()、peek()和pop()�Ҏ��Q��得开发者能够自由地直接操作解析栈�?
参考：
Jakarta Commons Digester Homepage
Jakarta Struts Homepage

林光�?/a> 2009-08-26 20:27 发表评论

ThreadLocal与synchronized

Tue, 25 Aug 2009 12:36:00 GMT

相关文章:
正确理解ThreadLocal
ThreadLocal与synchronized

推荐圈子: Pipboy
更多相关推荐
昨天上Java版块逛了一圈，一�?�?千�h��览的帖子引起了偶滴注意 ThreadLocal与synchronized �Q?��以上的回复�Q��见大家对�q�个问题的兴��?

老实��_��从看到这个帖子的题目开始，��p��得帖子的作者估计是在概念上有所��h��?于是乎想写个咚咚�Q�同大家分��n一下自��q��心得�?

帖子上，讨论的�h很多�Q�高手不乏，各抒��p��Q�但不知新手们看明白没有�Q�因此，�q�里偶以最��z�列表方式来说一说相关问题�?

1�Q�区别ThreadLocal �?synchronized

ThreadLocal是一个线�E�隔��?或者说是线�E�安�?的变量存储的��理实体�Q�注意：不是存储用的�Q�，它以Java�c�L��式表玎ͼ�
synchronized是Java的一个保留字�Q�只是一个代码标识符�Q�它依靠JVM的锁机制来实��C��界区的函数、变量在CPU�q�行讉K��中的原子性�?
两者的性质、表现及设计初衷不同�Q�因此没有可比较性�?

2.理解ThreadLocal中提到的变量副本
事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的�Q�而是Thread�U�程对象自��n保存。当用户调用ThreadLocal对象的set(Object o)�Ӟ��该方法则通过Thread.currentThread()获取当前�U�程�Q�将变量存入Thread中的一个Map内，而Map的Key��是当前的ThreadLocal实例。请看源码，�q�是最主要的两个函敎ͼ�能看出ThreadLocal与Thread的调用关�p�：

Java代码
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

�Q�有兴趣的朋友可以阅读Java的ThreadLocal源码�Q�因此，我们可以知道�Q�所谓的变量副本�Q�即是对Object Reference�Q�对象引用）的拷贝�?

3.理解Thread�?ThreadLocal对变量的引用关系
实际上Thread和ThreadLocal对变量引用关�p�d��像是坐标�p�M��的X轴和Y��_��是从两个�l�度上来�l�织对变量的引用的�?

首先说Thread�?我们知道一个ThreadOne的执行会贯穿多个�Ҏ��MethodA、MethodB、MethodC�q�些�Ҏ��可能分布于不同的�c�d��例。假设，�q�些�Ҏ��分别使用了ThreadLocalA、ThreadLocalB、ThreadLocalC来保存线�E�本地变量，那么�q�些变量都存于ThreadOne的Map中，�q��用各自的ThreadLocal实例作�ؓkey�?因此�Q�可以认为，借助ThreanLocal的set�Ҏ��Q�在X轴上�Q�Thread横向兌��同一�U�程上下文中来自多个Method的变量引用副本�?

接着说ThreadLocal�?一个MethodA中的X变量��被多个�U�程ThreadOne、ThreadTwo、ThreadThree所讉K��。假设MethodA使用ThreadLocal存储X�Q�通过set�Ҏ��Q�以ThreadLocal作�ؓkey��|��不同线�E�来访时的不同的变量值引用保存于ThreadOne、ThreadTwo、ThreadThree的各自线�E�上下文中，��保每个�U�程有自��q��一个变量倹{��因此，可以认�ؓ�Q�ThreadLocal是以Method为Y��_��U�向兌��了处于同一�Ҏ��中的不同�U�程上的变量�?

希望能对大家有所帮助�Q�这样可以少走很多弯路哦�?

本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/yangairong1984/archive/2008/04/15/2294572.aspx

林光�?/a> 2009-08-25 20:36 发表评论

Mon, 22 Jun 2009 07:06:00 GMT
　一、下载�ƈ解压�~�cactus
　　下蝲地址为http://Java.chinaitlab.com/tools/45970.Html 。将cactus的lib目录下的cactus-ant-1.7.1.jar复制到ant的lib目录�?br /> 　　二、配�|�cactus
　　cactus的配�|�很��单，新徏一个cactus.properties文�g�Q��ƈ把它攑֜�ant脚本中的cactus��d��的classpath下，文�g中包括如下内�?br /> 　　cactus.sysproperties=cactus.contextURL
　　#cactus-sample-servlet-cactified��是你的��试应用所在�\径，8080�?zmkey style="border-bottom: #ff6c00 2px dotted; float: none; cursor: pointer; font-weight: bold; margin-right: 3px; cssfloat: none" class="zoomino-searchword" offset="52" path="body > div:eq(0) > div:eq(3) > table:eq(2) > tbody:eq(0) > tr:eq(0) > td:eq(0) > div:eq(0) > #content:eq(0) > br:eq(4)" anchorType="previous" jQuery1245654007453="6">端口�?img style="border-bottom: medium none; border-left: medium none; padding-bottom: 0px; margin: 0px; padding-left: 0px; width: 12px; padding-right: 0px; display: inline; background-position: -18px -23px; float: none; height: 14px; border-top: medium none; border-right: medium none; padding-top: 0px; cssfloat: none" class="zoominoBgImage" src="http://static.zoomino.cn/static-ox/images/blank.gif" width="1" height="1" alt="" />
　　cactus.contextURL = http://localhost:8080/cactus-sample-servlet-cactified
　　cactus.servletReDirectorName = ServletRedirector
　　cactus.jspRedirectorName = JspRedirector
　　cactus.filterRedirectorName = FilterRedirector
　　具体的做法结合ant脚本再进一步解释�?br /> 　　三、运行ant脚本
　　 ant脚本主要执行以下��d��
　　1、设定classpath
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　2、定义相关�Q�?br /> 　　
　　
　　
　　
　　
　　
　　3、编译应用的�c�L��件和��试的类文�g
　　4、打包整个应用�ؓwar文�g
　　需要注重的是，不仅要打包应用类�Q�测试类也要打包
　　　　 description="Generate the runtime war">
　　　　 webXML="${src.webapp.dir}/WEB-INF/web.xml">
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　 < lib dir="project.classpath"/>
　　
　　
　　5、在应用的web.xml文�g中添加测试所需的各�U�映��?br /> 　　cactus提供了两个task来完成这个工作，CactifyWar和WebXmlMerge�?br /> 　　CactifyWar的功能是自动在已�l�打包的应用的web.xml文�g中添加所需的映��。WebXmlMerge是提供合�q�两个web.xml文�g的功能�?br /> 　　　　 depends="war, compile.cactus, test.prepare.logging">
　　
　　　　 destfile="${tomcat.home}/webapps/${project.name}-cactified.war"
　　 >
　　
　　
　　
　　
　　
　　6、运行测�?br /> 　　cactus提供了cactus和RunServerTests两个task来运行测试�?br highlighted="1" /> 　　"cactus" task是通过复制容器服务器的最��文件�ƈ�q�行来运行测试，因此需要制定容器服务器的类型，启动速度�E�快点，另外配置比较方便�Q�但是无法测试象tomcat�q�接�?img style="border-bottom: medium none; border-left: medium none; padding-bottom: 0px; margin: 0px; padding-left: 0px; width: 12px; padding-right: 0px; display: inline; background-position: -18px -23px; float: none; height: 14px; border-top: medium none; border-right: medium none; padding-top: 0px; cssfloat: none" class="zoominoBgImage" src="http://static.zoomino.cn/static-ox/images/blank.gif" width="1" height="1" alt="" />�{�资源。另外对tomcat5.5的支持也不好�?br /> 　　"RunServerTests"是通过直接启动容器服务��h��q�行��试�Q�因此速度�E�慢�Q�且配置较麻烦，但能��试各种资源�?br /> 　　　　 description="Run tests on Tomcat ">
　　
　　
　　　　 testURL="http://localhost:8080/${project.name}-cactified/ServletRedirector?Cactus_Service=RUN_TEST"
　　 startTarget="_StartTomcat"
　　 stopTarget="_StopTomcat"
　　 testTarget="_Test"/>
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　
　　文章来源: baike.duba.net

林光�?/a> 2009-06-22 15:06 发表评论

�l�servlet写单元测试的�ȝ��

Mon, 22 Jun 2009 05:39:00 GMT

�l�servlet写单元测试的�ȝ��收藏
servlet的测试一般来说需要容器的支持�Q�不是像通常的java�cȝ��junit��试一��L��单，

下面通过对HelloWorld代码的测试阐�q�C��几种servlet��试�Ҏ��?br />
被测试的HelloWorld�cȝ��代码如下�Q?br />
/**
* 被测试的servlet
*/

import java.io.IOException;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.cactus.WebRequest;
import org.apache.cactus.server.HttpServletRequestWrapper;

public class HelloWorld extends HttpServlet{

public void saveToSession(HttpServletRequest request) {

         request.getSession().setAttribute("testAttribute",request.getParameter("testparam"));

}

public void doGet(HttpServletRequest request,HttpServletResponse response) throws IOException{

         String username=request.getParameter("username");

         response.getWriter().write(username+":Hello World!");

}

public boolean authenticate(){

        return true;

}

}

以HelloWorld��Z��Q�我�ȝ��了Servlet的多�U�测试方法如下：

一.使用HttpUnit��试

import com.meterware.httpunit.GetMethodWebRequest;
import com.meterware.httpunit.WebRequest;
import com.meterware.httpunit.WebResponse;
import com.meterware.servletunit.InvocationContext;
import com.meterware.servletunit.ServletRunner;
import com.meterware.servletunit.ServletUnitClient;
import junit.framework.Assert;
import junit.framework.TestCase;

public class HttpUnitTestHelloWorld extends TestCase {

protected void setUp() throws Exception {
super.setUp();
}

protected void tearDown() throws Exception {
super.tearDown();
}

public void testHelloWorld() {

try {

   // 创徏Servlet的运行环�?/p>
   ServletRunner sr = new ServletRunner();

   // 向环境中注册Servlet

   sr.registerServlet("HelloWorld", HelloWorld.class.getName());

   // 创徏讉K��Servlet的客��L��

   ServletUnitClient sc = sr.newClient();

   // 发送请�?/p>
   WebRequest request = new GetMethodWebRequest("http://localhost/HelloWorld");
   request.setParameter("username", "testuser");

   InvocationContext ic = sc.newInvocation(request);

   HelloWorld is = (HelloWorld) ic.getServlet();

   // ��试servlet的某个方�?/p>
   Assert.assertTrue(is.authenticate());

   // 获得模拟服务器的信息

   WebResponse response = sc.getResponse(request);

   // 断言

   Assert.assertTrue(response.getText().equals("testuser:Hello World!"));

} catch (Exception e) {

   e.printStackTrace();

}

}

}

上述例子其实是junit的一个测试例子，在其中��用了httpunit模拟的servlet环境,使用上述�Ҏ��试

servlet可以��q��容器�Q�容易把该测试写入ant或maven脚本�Q�让��试�q�行�?br />
httpunit�|�址�Q�http://httpunit.sourceforge.net/

使用该种�Ҏ��试的弱点就是：如果要��用request(response)的setCharercterEncoding�Ҏ��Ӟ��试会出��C��些问�?

而且httpunit在测试servlet行�ؓ�Ӟ��采用的是完全模拟��览器，有时��试比较隑ֆ��?br />
�?使用cactus��试

/**
* cactus��试servlet的例�?br /> * 必须要有tomcat的支�?br /> *
*/

import junit.framework.Test;
import junit.framework.TestSuite;
import org.apache.cactus.ServletTestCase;
import org.apache.cactus.WebRequest;
import org.apache.cactus.WebResponse;
public class CactusHelloWorld extends ServletTestCase{

     HelloWorld servlet;
     public CactusHelloWorld(String theName) {
         super(theName);
     }

     protected void setUp() throws Exception {
         super.setUp();
         servlet = new HelloWorld();
     }

     protected void tearDown() throws Exception {
         super.tearDown();
     }

     /**
      * ��试�Ҏ��试参数在此讄��
      *
      * @param webrequest
      */

     public void beginSaveToSessionOK(WebRequest request) {
         request.addParameter("testparam", "it works!");
     }

     /**
      * ��试�Ҏ��试参数在此讄��
      *
      * @param webrequest
      */

     public void beginDoGet(WebRequest request) {
         request.addParameter("username", "testuser");
     }

     /**
      * 调用servlet的测试方�?br />       *
      */

     public void testSaveToSessionOK() {
         servlet.saveToSession(request);
         assertEquals("it works!", session.getAttribute("testAttribute"));
     }

     public void testDoGet() {
         try {
             servlet.doGet(request, response);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     /**
      * 此方法可以判断测试方法的输出�Q�会传递测试方法的reponse�l�end***,�q�且格式化�ؓcactus
      * 的WebResponse或者可以跟httpunit集成�Q�格式化为httpunit的response
      *
      * @param response
      */

     public void endDoGet(WebResponse response) {
         String content;
         content = response.getText();
         assertEquals("testuser:Hello World!", content);
     }
}

cactus具备丰富灉|��的测试功能，如要��试doGet�Ҏ��Q�分为beginDoGet(模拟��试参数讄��)、DoGet(执行��试)、endDoGet(状态结果验�?

相比httpunit来说�Q�写��试更�ؓ�Ҏ��Q�测试servlet更�ؓ专业,��程更�ؓ清晰�Q�但是cactus需要容器支持，使得��试不可以自动进行，但是

如果使用一个嵌入式的容器，��试��可以自动了�?br />
cactus是一个servlet和jsp的测试框�?http://jakarta.apache.org/cactus/getting_started.html

�?使用Jetty作�ؓ嵌入式容器测试servlet.

/**
* 一个关于嵌入式jetty��试的例子，jetty作�ؓstubs的一个例�?br /> *
*/
package com.easyjf.testexample;

import org.mortbay.jetty.Connector;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.bio.SocketConnector;
import org.mortbay.jetty.servlet.ServletHandler;

import com.meterware.httpunit.WebClient;
import com.meterware.httpunit.WebConversation;
import com.meterware.httpunit.WebResponse;

import junit.framework.Assert;
import junit.framework.TestCase;

public class JettySampleTest extends TestCase {

Server server;
protected void setUp() throws Exception {
      //通过代码讄��q�启动一个服务器�Q�该服务器是servlet的测试容�?br />       super.setUp();
      server = new Server();
      Connector connector=new SocketConnector();
      connector.setPort(80);
      server.setConnectors(new Connector[]{connector});
      ServletHandler handler=new ServletHandler();
      server.setHandler(handler);
      handler.addServletWithMapping("HelloWorld", "/");
      server.start();
}

protected void tearDown() throws Exception {
super.tearDown();
server.stop();
}

public void testHellWorld() {
try {
   WebConversation wc = new WebConversation();
   WebResponse web = wc.getResponse("http://127.0.0.1/HelloWorld");
   String result=web.getText();
   Assert.assertEquals(result,"it works!");
} catch (Exception e) {
   e.printStackTrace();
}
}
}

可以发现�Q�jetty可以充当一个servlet的容器，方便的是,jetty支持嵌入式服务，卛_��以通过代码来启动，

所以要写自动测试的例子很方便，可以�l�合httpunit或者cactus�q�行servlet��试�?br />
jetty主页�Q�http://docs.codehaus.org/display/JETTY/Embedding+Jetty

�?使用mock对象�Q�此处��用easymock

import java.io.PrintWriter;
import java.io.Writer;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import junit.framework.Assert;
import junit.framework.TestCase;
import static org.easymock.EasyMock.*;
public class MockTestServlet extends TestCase {

    public void testService() throws Exception {

        System.out.println("service");

        HttpServletRequest request = createMock(HttpServletRequest.class);

        HttpServletResponse response = createMock(HttpServletResponse.class);

        //Creating the ServletConfig mock here

        ServletConfig servletConfig = createMock(ServletConfig.class);

        //Creating the ServletContext mock here

        ServletContext servletContext = createMock(ServletContext.class);

        //Create the target object

        HelloWorld4 instance = new HelloWorld();

        //初始化servlet,一般由容器承担�Q�一般调用servletConfig作�ؓ参数初始化，此处模拟容器行�ؓ

        instance.init(servletConfig);

        //在某些方法被调用时设�|�期望的�q�回��|��如下�q�样��׃��会去实际调用servletConfig的getServletContext�Ҏ��Q�而是直接�q�回

        //servletContext,�׃��servletConfig是mock出来的，所以可以完全控制�?/p>
        expect(servletConfig.getServletContext()).andReturn(servletContext).anyTimes();

        expect(request.getParameter("username")).andReturn("testuser");

        PrintWriter pw=new PrintWriter(System.out,true);

        expect(response.getWriter()).andReturn(pw).anyTimes();

        //以上均是录制�Q�下面�ؓ重放�Q�该�U�机制�ؓeasymock��试机制�Q�要理解��L��easymock��试的一些资�?br />         replay(request);
        replay(response);
        replay(servletConfig);
        replay(servletContext);

        instance.doGet(request, response);

        pw.flush();


        //验证�l�果是否预期�Q�如果预期，则会在pw上写出testuser.
        verify(request);
        verify(response);
        verify(servletConfig);
        verify(servletContext);
   }
}

mock��试注重行�ؓ�Q�mock对象其实都是模拟的对象，�Ҏ��一般直接给��Z��个返回��|��没有具体的对象逻辑�Q�mock对象

是用来帮助测试要��试的类的。比如要��试servlet的内部行为，又不惌��容器�{�环境，��可以采用mock��试�?br />
easymock是mock��试的一个框�Ӟ��http://www.easymock.org/

发表�?@ 2007�q?2�?0�?22:13:00|评论(2)

��C��? 设计模式之创建模�?| 旧一��? 服务定位器模�?service locator)wldandanpig 发表�?007�q?�?4�?10:09:40 IP:举报
请问��g��
public String saveInfo()
{
String reqInfo = request.getParameter("reqInfo");
String sessInfo = (String)request.getSession().getAttribute("sessInfo");

request.setAttribute("reqInfo" , "response:"+reqInfo);
request.getSession().setAttribute("sessInfo", "response:"+reqInfo);

return "SUCCESS";
}
�q�个�Ҏ��怎么��试啊cz_hyf 发表�?007�q?�?4�?17:20:23 IP:举报
如果用httpunit的话

public void testHelloWorld() {

try {

// 创徏Servlet的运行环�?/p>
ServletRunner sr = new ServletRunner();

// 向环境中注册Servlet

sr.registerServlet("HelloWorld", HelloWorld.class.getName());

// 创徏讉K��Servlet的客��L��

ServletUnitClient sc = sr.newClient();

// 发送请�?/p>
WebRequest request = new GetMethodWebRequest("http://localhost/HelloWorld");
request.setParameter("reqInfo", "......");

InvocationContext ic = sc.newInvocation(request);

HelloWorld is = (HelloWorld) ic.getServlet();

// ��试servlet的某个方�?/p>
Assert.assertEquals(is.saveInfo,"SUCCESS");

} catch (Exception e) {

e.printStackTrace();

}

}

如果�q�不攑ֿ��Q�不妨把request和request.session中的值取出来看看是否是你放进�ȝ��

本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/cz_hyf/archive/2007/02/10/1507211.aspx

林光�?/a> 2009-06-22 13:39 发表评论

jsp内徏对象

Thu, 04 Jun 2009 02:59:00 GMT

JSP的内建对象不需要由JSP�~�写人员实例�?它们均由容器��理和实�?在所有的JSP��面中都能��?只在Scriptlet或者表辑ּ�中��?它们�?

�Q�．request对象:

           代表��h��对象,被包装成HttpServletRequest接口,通过getParameter�Ҏ��得到request参数,通过 GET,POST,HEAD�{�方法得到request的类�?通过Cookies,Referer�{�可以得到Http�?来自客户端的��h��l?Servlet容器处理�?由request对象�q�行��装,作�ؓjspService()�Ҏ��的一个参数由容器传递给JSP��面.主要�Ҏ��?request.getAttribute("..");request.getParameter("xxx");request.getParameterValues("xxx");request.getHeader("xxx") 获取HTTP协议定义的文件头信息.request.getRequestURI()获取发出��h��字符串的客户端地址.request.getRemoteHost()客户端名,request.getRemoteAddr()客户端IP地址.request.getServerName()服务�?/a>名字.request.getServletPath();客户端所��h��的脚本文件的文�g路径.request.getServerPort()获取
�Q�．response

           响应��h��对象,被包装成HttpServletResponse接口,与requst对象一�?是缓冲输出流,可以讄��Http状态码和response 响应�?主要的方法有:response.addCookie(Cookie cookie);response.encodeURL();response.getOutputStream();response.sendRedirect("xxx") 把响应发到另一位置�q�行处理.

�Q�．pageContext

          被封装成javax.servlet.jsp.pageContext接口,它�ؓJSP��面包装��面的上下文.由容器创建和初始�?��理对属于JSP中特�D�可见部分中已命名对象的讉K��.可用getServletContext()�q�回Servlet Context对象(�q�个Servlet Context�Ҏ��有的��面都是�׃�n�?),forward("xxx")把页面重定向到另一��面或者Servlet�l��g�?

�Q�．session对象

           用来保存每个用户信息,以便跟踪每个用户的操作状�?其中session信息保存在容器中,session的ID保存在客��h��的Cookiek .(一般情况中,用户每次��d��pȝ��时容器会�l�此用户分配一个唯一的标识session id,用于区别其它用户,当用户退出系�l�时,�q�个标识��׃��自动消失.其接口�ؓHttpSession.主要的方法有:session.getId();getLastAccessedTime();setAttribute();

�Q�．application

         �?a class="channel_keylink" >服务�?/a>启动后创�?直到服务�?/a>关闭而停�?为多个应用程序保存信�?

�Q�．out对象:

            被封装成javax.servlet.jsp.JspWriter接口,它表�C�Zؓ客户打开的输出流,PrintWriter使用它向客户端发送输出流.即简单说向客��L��输出数据.�Ҏ��:out.print(....),out.newLine();out.flush();out.close();�{?�q�可获取输出�~�冲区的相关信息.如果要在��面中真正输��Z��个空�?需要用out.println("
")来实�?

�Q�．config

         被封装�ؓjavax.servlet.ServletConfig接口,它表�C�Z��Servlet的配�|?当一个Servlet初始化时,容器把某些信息通过此对象传递给�q�个Servlet.,常用的方法有:getServletContext();

�Q�．page

         是java.lang.Object�cȝ��一个实�?它指的是JSP实现�cȝ��实例.

�Q�．exception

        是java.lang.Throwable�cȝ��一个实�?它指的是�q�行时的异常,也就是被调用的错误页面的�l�果,只有在错误页�?在指令里有isErrorPage=true的页面中)才可以��?/p>

林光�?/a> 2009-06-04 10:59 发表评论

欧美中文在线观看,有码一区二区三区,在线中文字幕视频

《设计模式》之Java解读--桥接Bridge

Java Class Loader

TOMCAT源码�ȝ��一

如何处理HTTP POST/GET��h��

TOMCAT源码分析(消息处理)

TOMCAT源码分析(启动框架

用Digester���化XML文档处理

ThreadLocal与synchronized

�l�servlet写单元测试的�ȝ��

jsp内徏对象

用Digester��化XML文档处理