它们是应用启动的时候，通过 org.directwebremoting.servlet.DwrServlet 初始化 dwr-2.0.5.jar!/org/directwebremoting/dwr.xml 文件加载进来的。例如：

<converter id="date" class="org.directwebremoting.convert.DateConverter"/>　注册了 date 转换器
<convert converter="date" match="java.util.Date"/>　应用注册的 date 转换器应用到 java.util.Date 类型

看到上面，你也许会惊讶一下，我们平时可能也就用下 bean 转换器，其他用内置就行。然而 DWR 确为我们考虑的很周到的，包括 hibernate 相关的，URL、Servlet、Dom 等相关类型的转换器。

2. DWR 如何确定用哪个 Converter?

DWR 是根据方法参数来确定入口参数的 Converter、根据返回值类型确定传向 JS 的出口参数的 Converter。总之是以 Java 方法原型为基准来决定每一参数或返回值各自用哪个 Converter 来转换数据。

在 BaseCallMarshaller.marshallInbound(HttpServletRequest request, HttpServletResponse response) 方法中，使用

Class paramType = method.getParameterTypes()[j] 来获得参数的类型，然后从已加载的 Converter Map 中找到 Converter 名称，进而确定 Converter 类名。

而确定返回值类型就不是直接用反射的 method.getReturnType()。而是以反射方式调用方法后，根据具体返回值的类型来确定的。见：

Replay DefaultRemoter.execute(Call) 方法中的
Object reply = chain.doFilter(object, method, call.getParameters());　再进入到
Object ExecuteAjaxFilter.doFilter(Object obj, Method method, Object[] params Ajax FilterChain){
      return method.invoke(obj, params);
}

就是根据上面的返回值，然后在

DefaultConverterManager.convertOutbound(Object, OutboundContext) 方法中的

Converter converter = getConverter(object); 　//根据返回值 object  确定该用的 Converter。

3. DWR Converter 的调用

多留意下 DWR 自带的 Converter，可以看到所有的 Converter 直接或简接的 extends BaseV20Converter implements Converter，其实 BaseV20Converter(DWR 1.x 中对应为 BaseV10Converter) 本身就实现了 Converter。在 BaseV20Converter 抽象类中默认实现了 Converter 的方法

public void setConverterManager(ConverterManager config)  {  }

具体的 Converter 只要专心去实现接口 Converter 中的另两个方法:

Object convertInbound(Class paramType, InboundVariable data, InboundContext inctx) throws MarshallException;
OutboundVariable convertOutbound(Object data, OutboundContext outctx) throws MarshallException;

运行时，它们相应的被 ConvertManager(默认为 DefaultConvertManager) 的
Object convertInbound(Class paramType, InboundVariable iv, InboundContext inctx, TypeHintContext incc) throws MarshallException
OutboundVariable convertOutbound(Object object, OutboundContext outctx) throws MarshallException
来调用。

DWR 对每个参数或返回值至少会应用一次 Converter，但对于复杂的类型会递归的调用 Converter，比如，要完成

JS "{id:123, name: 'Unmi', blogs:['http://unmi.blogjava.net','http://blog.csdn.net/kypfos']}"  到 Java 的 Person{int id, String name, String[] blogs;} 的转换，就会使用到 bean->primitive->array 三个 Converter。

4. 定制自己的 Converter

基本上 DWR  内置的 Converter 就够用的，但也有可能需要定定自己的 Converter。从 DWR 的 Converter 实现来看，一般会用两种方式：

1) extends BaseV20Converter implements Converter，实现 Converter 的 converterInbound() 和 converterOutbound() 方法
2) extends BasicObjectConverter implements Converter，或继承 BeanConverter，实现 BasicObjectConverter 的 getPropertyMapFromObject()，getPropertyMapFromObject() 和 createTypeHintContext() 方法。

前一种方式，请参照 org.directwebremoting.convert.DateConverter 的源码实现：

convertInbound() 由 JS 的字符串转换成要求的 Date、Time、Timestamp 或 Calender 对像。
convertOubound() 把 Java 的类型转换成 JS 的 new Date() 类型，注意返回值的写法：
                             return new SimpleOutboundVariable("new Date(" + millis + ")", outctx, true);

第二种继承 BasicObjectConverter 或是 BeanConverter 的做法，可参考 BeanConverter  的源码实现。表现在 JSON 和 Java 对象间的转换，要是引入解析 JSON 的 JAR 包或许能有不少帮助。

定制 Converter 的内容讲的很少，主要是真有这方面的需要的时候请参考 DWR  的相关源码，实际中理解各个接口方法参数的意义，及返回值的要求。对待开源组件还是要保持阅读源码的好习惯。

好啦，自己的 Converter 写好，需要注册，需要应用。我们还是参考 DWR 的做法，写在自己的 dwr.xml 中。例如定制了 com.unmi.dwr.converter.SpecialConverter，要对 com.unmi.model.SpecialObject 进行出入类型的转换，就这么写：

<converter id="special" class="com.unmi.dwr.converter.SpecialConverter"/>　注册了 special 转换器
<convert converter="special" match="com.unmi.model.SpecialObject"/>　应用注册的 special 转换器应用到 com.unmi.model.SpecialObject  类型

5. 小结

用 DWR 其实也有段时日了，未曾系统的学，总是遇一问题、扫除一个，不免也会去找找相关更系统的资料。然而着下此篇的动机是上周六在书城翻了下 《 DWR 实战》，它实际讲 DWR 本身的较少。最后我第一个想了解了是 DWR 能完成 JS 与 Java 间什么类型的转换，第一手的资料网上也没搜索到，于是进到源码中去，亲身历练，也更加深了印象。

读者也许和我一样目的，只想看看内置的转换器有哪些，能转换哪些类型，那就只需看最为抢眼的那张表格吧。需要定制 Converter 应该很少，就像我们很少定制 Struts 的 Converter、Hibernate 的 UserType 和 iBatis 的 TypeHandler 一样。因此也就对定制 DWR 的 Converter 所用篇幅不多。

对待开源，自己总有个习惯就是必须有相关的源代码伴随在它身边。开源组件的使用一般不难，碰到问题，既然源码都掌握了，我想总能从源码中找出原因来。尚且，对这样的知名组件越发深入，就更能嚼出许多味多。


参考：DWR 2.0.5 的源代码，对 DWR 项目进行单步调试

原文：http://www.blogjava.net/Unmi/archive/2009/06/23/283741.html

Cache是一种用于提高系统响应速度、改善系统运行性能的技术。尤其是在Web应用中，通过缓存页面的输出结果，可以很显著的改善系统运行性能。

OSCache标记库由OpenSymphony设计，它是一种开创性的缓存方案，它提供了在现有JSP页面之内实现内存缓存的功能。OSCache是个一个被广泛采用的高性能的J2EE缓存框架，OSCache还能应用于任何Java应用程序的普通的缓存解决方案。

1 The init() method (which the developer can override) is called only once in a servlet’s life, and always before the servlet can service any client requests.

2 The init() method gives the servlet access to the Serv-letConf g and ServletContext objects, which the servlet needs to get information about the servlet conf guration and the web app.

3 The Container ends a servlet’s life by calling its destroy() method.

4 Most of a servlet’s life is spent running a service() method for a client request.

5 Every request to a servlet runs in a separate thread! There is only one instance of any particular servlet class.

6 Your servlet will almost always extend javax.servlet.http.HttpServlet, from which it inherits an implementation of the service() method that takes an HttpServletRequest and an HttpServletResponse.

7 HttpServlet extends javax.servlet.GenericServlet—an abstract class that implements most of the basic servlet methods.

8 GenericServlet implements the Servlet interface.

9 Servlet classes (except those related to JSPs) are in one of two packages: javax.servlet or javax.servlet.http.

10 You can override the init() method, and you must override at least one service method (doGet(), doPost(), etc.)

The HttpServlet’s doGet() and doPost() methods take an HttpServletRequest and an HttpServletResponse.

1 The service() method determines whether doGet() or doPost() runs based on the HTTP Method (GET, POST, etc.) of the HTTP request.

2 POST requests have a body; GET requests do not, although GET requests can have request parameters appended to the request URL (sometimes called “the query string”).

3 GET requests are inherently (according to the HTTP spec) idempotent. They should be able to run multiple times without causing any side effects on the server. GET requests shouldn’t change anything on the server. But you could write a bad, non-idempotent doGet() method.

4 POST is inherently not idempotent, so it’s up to you to design and code your app in such a way that if the client sends a request twice by mistake, you can handle it.

5 If an HTML form does not explicitly say “method=POST”, the request is sent as a GET, not a POST. If you do not have a doGet() in your servlet, the request will fail.

6 You can get parameters from the request with the getParameter(“paramname”) method. The return value is always a String.

7 If you have multiple parameter values for a given param-eter name, use the getParameterValues(“paramname”) method that returns a String array.

8  You can get other things from the request object including headers, cookies, a session, the query string, and an input stream

Post与Get区别：
1. Get用于从服务端获取数据，Post用于向服务器端提交数据；
2. Get提交后，参数保留在浏览器地址栏，Post不会；
3. Get提交时，URL会带参数，Post不会。因为URL是保存到http协议头部。而Post参数保存到http协议Body中
4. Get容易产生重复提交，Post不会。

 

You use the Response to send data back to the client.

1 The most common methods you’ll call on the response object (HttpServletResponse) are setContentType() and getWriter().

2 Be careful—many developers assume the method is getPrintWriter(), but it’s getWriter().

3 The getWriter() method lets you do character I/O to write HTML (or something else) to the stream.

4 You can also use the response to set headers, send errors, and add cookies.

5 In the real world, you’ll probably use a JSP to send most HTML responses, but you may still use a response stream to send binary data

(like a JAR f le, perhaps) to the client.

6 The method you call on your response for getting a binary stream is getOutputStream().

7 The setContentType() method tells the browser how to handle the data coming in with the response. Typical content types are “text/html”, “application/pdf”, and “image/jpeg”.

8 You don’t have to memorize content types (also known as MIME types).

9 You can set response headers using addHeader() or setHeader(). The difference depends on whether the header is already part of the response. If it is, setHeader() will replace the value, but addHeader will add an additional value to the existing response. If the header is not already part of the response, then setHeader() and addHeader() behave in exactly the same way.

10 If you don’t want to respond to a request, you can redirect the request to a different URL. The browser takes care of sending the new request to the URL you provide.

11 To redirect a request, call sendRedirect(aStringURL) on the response.

12 You cannot call sendRedirect() after the response is committed! In other words, if you’ve already written something to the stream, it’s too late to do a redirect.

13 A request redirect is different from a request dispatch. A request dispatch (covered more in another chapter) happens on the server, while a redirect happens on the client. A request dispatch hands the request to another component on the server, usually within the same web app. A request redirect simply tells the browser to go a different URL

• 将javarebel.jar加入classpath（不建议将javarebel.jar放在WEB-INF/lib下，因为生产环境不需要它）
• 命令行中加入下面的启动参数
  java -noverify -javaagent:C:\libraries\javarebel.jar -Drebel.dirs=c:\workspace\project\classes
Drebel.dirs指向工程中.class文件的目录，不必指定具体的类名。另外，javarebel.jar的名字不能修改。

在Myeclipse中使用：
    window-preference-Tomcat 6.x-JDK-Optional JDK arguments下设置如下：
   

1 -noverify -javaagent:D:/servers/javarebel-2.0-M1a/javarebel.jar

CVS服务器端：
CVS 下载：http://www.march-hare.com/cvspro/
CVS 下载地址：http://www.cvshome.org/ (最新版本：hp:1.12.11,Linux and win32:1.11.17)
cvsnt 下载地址：http://www.cvsnt.com/cvspro/ (最新版本：2.0.58d)

CVS客户端：
TortoiseCVS 下载地址：http://www.tortoisecvs.org/ (最新版本：1.8.11)
wincvs 下载地址：http://cvsgui.sourceforge.net/download.html (最新版本：1.3.20.3)
Python 下载地址：http://www.python.org/download/ (最新版本：2.4)
TCL 下载地址：http://www.activestate.com/Products/ActiveTCL/ (最新版本：8.4.9.0)
SmartCVS 下载地址：http://www.regnis.de/download.html (最新版本：3.0.6)

CVSWEB 下载地址：http://www.freebsd.org/projects/cvsweb.html (最新版本：3.0.5)
viewcvs 下载地址：http://viewcvs.sourceforge.net/(最新版本：0.9.2)
CvsGraph 下载地址：http://www.akhphd.au.dk/~bertho/cvsgraph/(最新版本:1.5.1)

缺陷跟踪：
CVSTrac 下载地址：http://www.cnpack.org/ (http://www.cvstrac.org/)(最新版本：1.1.5)

基于CVS的代码统计工具：按代码量，按开发者的统计表等：
StatCVS 下载地址：http://sourceforge.net/projects/statcvs (最新版本：0.2.2)

CVS权限管理（CVSACL is a patch for CVS）：
cvsacl 下载地址：http://cvsacl.sourceforge.net/(最新版本：1.2.2)

subversion服务器端：
subversion 下载地址：http://subversion.tigris.org/project_packages.html#binary-packages (最新版本：1.3.2)

subversion客户端：
tortoisesvn 下载地址：http://tortoisesvn.tigris.org/ (最新版本：1.4.0)
rapidsvn 下载地址：http://rapidsvn.tigris.org/ (最新版本：0.9.3)

在表达式中有特殊意义，需要添加 """ 才能匹配该字符本身的字符汇总

字符	说明
^	匹配输入字符串的开始位置。要匹配 "^" 字符本身，请使用 ""^"
$	匹配输入字符串的结尾位置。要匹配 "$" 字符本身，请使用 ""$"
( )	标记一个子表达式的开始和结束位置。要匹配小括号，请使用 ""(" 和 "")"
[ ]	用来自定义能够匹配 '多种字符' 的表达式。要匹配中括号，请使用 ""[" 和 ""]"
{ }	修饰匹配次数的符号。要匹配大括号，请使用 ""{" 和 ""}"
.	匹配除了换行符（"n）以外的任意一个字符。要匹配小数点本身，请使用 ""."
?	修饰匹配次数为 0 次或 1 次。要匹配 "?" 字符本身，请使用 ""?"
+	修饰匹配次数为至少 1 次。要匹配 "+" 字符本身，请使用 ""+"
*	修饰匹配次数为 0 次或任意次。要匹配 "*" 字符本身，请使用 ""*"
|	左右两边表达式之间 "或" 关系。匹配 "|" 本身，请使用 ""|"

比较{? + *}用法

 1public class DataMatcher {
 2    public static void main(String[] args) {
 3        String input = "aab ab acb ";
 4        String regex = "e.+?d";
 5        String regex1 = "a*b";
 6        String regex2 = "a+b";
 7        String regex3 = "a?b";
 8        
 9        Pattern p = Pattern.compile(regex1);
10        Matcher m = p.matcher(input);
11                
12        while(m.find()){
13            System.out.println("match: '" + m.group() + "' start: " + m.start() + " end: " + m.end());
14        }
15    }
16}

regex1 result:

1match: 'aab' start: 0 end: 3
2match: 'ab' start: 4 end: 6
3match: 'b' start: 9 end: 10

regex2 result

1match: 'aab' start: 0 end: 3
2match: 'ab' start: 4 end: 6

regex3 result

1match: 'ab' start: 1 end: 3
2match: 'ab' start: 4 end: 6
3match: 'b' start: 9 end: 10

{.}的用法

1String regex = "a.*?b";
2String input = "eaab ab eb acb acsd df ad";
3

1match: 'aab' start: 1 end: 4
2match: 'ab' start: 5 end: 7
3match: 'acb' start: 11 end: 14

1String input = "eaab ab eb acb acsd df ad";
2String regex = "(a.*?)(b|d)";

1match: 'aab' start: 1 end: 4
2match: 'ab' start: 5 end: 7
3match: 'acb' start: 11 end: 14
4match: 'acsd' start: 15 end: 19
5match: 'ad' start: 23 end: 25

1String input = "a b c da ab";
2String regex = "[ab]";

1match: 'a' start: 0 end: 1
2match: 'b' start: 2 end: 3
3match: 'a' start: 7 end: 8
4match: 'a' start: 9 end: 10
5match: 'b' start: 10 end: 11

类加载器

Java中类的查找与装载出现的问题总是会时不时出现在Java程序员面前，这并不是什么丢脸的事情，相信没有一个Java程序员没遇到过ClassNotException,因此不要为被人瞅见自己也犯这样的错误而觉得不自然，但是在如果出现了ClassNotFoundException后异常后一脸的茫然，那我想你该了解一下java的类装载的体制了，同时为了进行下面的关于类装载器之间的隔离性的讨论，我们先简单介绍一下类装载的体系结构。

1. Java类装载体系结构

装载类的过程非常简单：查找类所在位置，并将找到的Java类的字节码装入内存，生成对应的Class对象。Java的类装载器专门用来实现这样的过程，JVM并不止有一个类装载器，事实上，如果你愿意的话，你可以让JVM拥有无数个类装载器，当然这除了测试JVM外，我想不出还有其他的用途。你应该已经发现到了这样一个问题，类装载器自身也是一个类，它也需要被装载到内存中来，那么这些类装载器由谁来装载呢，总得有个根吧？没错，确实存在这样的根，它就是神龙见首不见尾的Bootstrap ClassLoader. 为什么说它神龙见首不见尾呢，因为你根本无法在Java代码中抓住哪怕是它的一点点的尾巴，尽管你能时时刻刻体会到它的存在，因为java的运行环境所需要的所有类库，都由它来装载，而它本身是C++写的程序，可以独立运行,可以说是JVM的运行起点,伟大吧。在Bootstrap完成它的任务后，会生成一个AppClassLoader(实际上之前系统还会使用扩展类装载器ExtClassLoader，它用于装载Java运行环境扩展包中的类),这个类装载器才是我们经常使用的，可以调用ClassLoader.getSystemClassLoader() 来获得，我们假定程序中没有使用类装载器相关操作设定或者自定义新的类装载器，那么我们编写的所有java类通通会由它来装载，值得尊敬吧。AppClassLoader查找类的区域就是耳熟能详的Classpath，也是初学者必须跨过的门槛，有没有灵光一闪的感觉，我们按照它的类查找范围给它取名为类路径类装载器。还是先前假定的情况，当Java中出现新的类，AppClassLoader首先在类传递给它的父类类装载器，也就是Extion ClassLoader，询问它是否能够装载该类，如果能，那AppClassLoader就不干这活了，同样Extion ClassLoader在装载时，也会先问问它的父类装载器。我们可以看出类装载器实际上是一个树状的结构图，每个类装载器有自己的父亲，类装载器在装载类时，总是先让自己的父类装载器装载(多么尊敬长辈),如果父类装载器无法装载该类时，自己就会动手装载，如果它也装载不了，那么对不起，它会大喊一声：Exception，class not found。有必要提一句，当由直接使用类路径装载器装载类失败抛出的是NoClassDefFoundException异常。如果使用自定义的类装载器loadClass方法或者ClassLoader的findSystemClass方法装载类，如果你不去刻意改变，那么抛出的是ClassNotFoundException。

我们简短总结一下上面的讨论：

1.JVM类装载器的体系结构可以看作是树状结构。

2.父类装载器优先装载。在父类装载器装载失败的情况下再装载，如果都装载失败则抛出ClassNotFoundException或者NoClassDefFoundError异常。

那么我们的类在什么情况下被装载的呢？

2. 类如何被装载

在java2中，JVM是如何装载类的呢，可以分为两种类型，一种是隐式的类装载，一种是显式的类装载。

2.1 隐式的类装载

隐式的类装载是编码中最常用得方式：

A b = new A();

如果程序运行到这段代码时还没有A类，那么JVM会请求装载当前类的类装器来装载类。问题来了，我把代码弄得复杂一点点，但依旧没有任何难度，请思考JVM得装载次序：

package test;

Public class A{

    public void static main(String args[]){

        B b ＝ new B();

    }

}

class B{C c;}

class C{}

揭晓答案，类装载的次序为A->B，而类C根本不会被JVM理会,先不要惊讶，仔细想想，这不正是我们最需要得到的结果。我们仔细了解一下JVM装载顺序。当使用Java A命令运行A类时，JVM会首先要求类路径类装载器(AppClassLoader)装载A类，但是这时只装载A，不会装载A中出现的其他类(B类)，接着它会调用A中的main函数，直到运行语句b ＝ new B()时，JVM发现必须装载B类程序才能继续运行，于是类路径类装载器会去装载B类，虽然我们可以看到B中有有C类的声明，但是并不是实际的执行语句，所以并不去装载C类，也就是说JVM按照运行时的有效执行语句，来决定是否需要装载新类，从而装载尽可能少的类，这一点和编译类是不相同的。

2.2 显式的类装载

使用显示的类装载方法很多，我们都装载类test.A为例。

使用Class类的forName方法。它可以指定装载器，也可以使用装载当前类的装载器。例如：

Class.forName("test.A");                                            

它的效果和

Class.forName("test.A",true,this.getClass().getClassLoader());

是一样的。

使用类路径类装载装载.

ClassLoader.getSystemClassLoader().loadClass("test.A");

使用当前进程上下文的使用的类装载器进行装载，这种装载类的方法常常被有着复杂类装载体系结构的系统所使用。

Thread.currentThread().getContextClassLoader().loadClass("test.A")

使用自定义的类装载器装载类

public class MyClassLoader extends URLClassLoader{

public MyClassLoader() {

        super(new URL[0]);

    }

}

MyClassLoader myClassLoader = new MyClassLoader();

myClassLoader.loadClass("test.A");

MyClassLoader继承了URLClassLoader类，这是JDK核心包中的类装载器，在没有指定父类装载器的情况下，类路径类装载器就是它的父类装载器，MyClassLoader并没有增加类的查找范围，因此它和类路径装载器有相同的效果。

我们已经知道Java的类装载器体系结构为树状，多个类装载器可以指定同一个类装载器作为自己的父类，每个子类装载器就是树状结构的一个分支，当然它们又可以个有子类装载器类装载器，类装载器也可以没有父类装载器，这时Bootstrap类装载器将作为它的隐含父类，实际上Bootstrap类装载器是所有类装载器的祖先，也是树状结构的根。这种树状体系结构，以及父类装载器优先的机制，为我们编写自定义的类装载器提供了便利，同时可以让程序按照我们希望的方式进行类的装载。例如某个程序的类装载器体系结构图如下：

图2：某个程序的类装载器的结构

解释一下上面的图，ClassLoaderA为自定义的类装载器，它的父类装载器为类路径装载器，它有两个子类装载器ClassLoaderAA和ClassLaderAB，ClassLoaderB为程序使用的另外一个类装载器，它没有父类装载器，但有一个子类装载器ClassLoaderBB。你可能会说，见鬼，我的程序怎么会使用这么复杂的类装载器结构。为了进行下面的讨论，暂且委屈一下。

3. 奇怪的隔离性

我们不难发现，图2中的类装载器AA和AB， AB和BB，AA和B等等位于不同分支下，他们之间没有父子关系，我不知道如何定义这种关系，姑且称他们位于不同分支下。两个位于不同分支的类装载器具有隔离性，这种隔离性使得在分别使用它们装载同一个类，也会在内存中出现两个Class类的实例。因为被具有隔离性的类装载器装载的类不会共享内存空间，使得使用一个类装载器不可能完成的任务变得可以轻而易举，例如类的静态变量可能同时拥有多个值（虽然好像作用不大），因为就算是被装载类的同一静态变量，它们也将被保存不同的内存空间，又例如程序需要使用某些包，但又不希望被程序另外一些包所使用，很简单，编写自定义的类装载器。类装载器的这种隔离性在许多大型的软件应用和服务程序得到了很好的应用。下面是同一个类静态变量为不同值的例子。

package test;

public class A {

 public static void main( String[] args ) {

    try {

      //定义两个类装载器

      MyClassLoader aa= new MyClassLoader();

      MyClassLoader bb = new MyClassLoader();

      //用类装载器aa装载testb.B类

      Class clazz=aa.loadClass("testb. B");

      Constructor constructor=

        clazz.getConstructor(new Class[]{Integer.class});

      Object object =

     constructor.newInstance(new Object[]{new Integer(1)});

      Method method =

     clazz.getDeclaredMethod("printB",new Class[0]);

      //用类装载器bb装载testb.B类

      Class clazz2=bb.loadClass("testb. B");

      Constructor constructor2 =

        clazz2.getConstructor(new Class[]{Integer.class});

      Object object2 =

     constructor2.newInstance(new Object[]{new Integer(2)});

      Method method2 =

     clazz2.getDeclaredMethod("printB",new Class[0]);

      //显示test.B中的静态变量的值

      method.invoke( object,new Object[0]);

      method2.invoke( object2,new Object[0]);

    } catch ( Exception e ) {

      e.printStackTrace();

    }

 }

}

//Class B 必须位于MyClassLoader的查找范围内，

//而不应该在MyClassLoader的父类装载器的查找范围内。

package testb;

public class B {

    static int b ;

    public B(Integer testb) {

        b = testb.intValue();

    }

    public void printB() {

        System.out.print("my static field b is ", b);

    }

}

public class MyClassLoader extends URLClassLoader{

 private static File file = new File("c:""classes ");

 //该路径存放着class B，但是没有class A

 public MyClassLoader() {

    super(getUrl());

 }

 public static URL[] getUrl() {

    try {

      return new URL[]{file.toURL()};

    } catch ( MalformedURLException e ) {

      return new URL[0];

    }

 }

}

程序的运行结果为：

my static field b is 1

my static field b is 2

程序的结果非常有意思，从编程者的角度，我们甚至可以把不在同一个分支的类装载器看作不同的java虚拟机，因为它们彼此觉察不到对方的存在。程序在使用具有分支的类装载的体系结构时要非常小心，弄清楚每个类装载器的类查找范围，尽量避免父类装载器和子类装载器的类查找范围中有相同类名的类（包括包名和类名），下面这个例子就是用来说明这种情况可能带来的问题。

假设有相同名字却不同版本的接口 A，

版本 1：

package test;

Intefer Same{ public String getVersion(); }

版本 2：

Package test;

Intefer Same{ public String getName(); }

接口A两个版本的实现：

版本1的实现

package test;

public class Same1Impl implements Same {

public String getVersion(){ return "A version 1";}

}

版本2的实现

public class Same 2Impl implements Same {

public String getName(){ return "A version 2";}

}

我们依然使用图2的类装载器结构，首先将版本1的Same和Same的实现类Same1Impl打成包same1.jar，将版本2的Same和Same的实现类Same1Impl打成包same2.jar。现在，做这样的事情，把same1.jar放入类装载器ClassLoaderA的类查找范围中，把same2.jar放入类装器ClassLoaderAB的类查找范围中。当你兴冲冲的运行下面这个看似正确的程序。

实际上这个错误的是由父类载器优先装载的机制造成，当类装载器ClassLoaderAB在装载Same2Impl类时发现必须装载接口test.Same，于是按规定请求父类装载器装载，父类装载器发现了版本1的test.Same接口并兴冲冲的装载，但是却想不到Same2Impl所希望的是版本2 的test.Same，后面的事情可想而知了，异常被抛出。

我们很难责怪Java中暂时并没有提供区分版本的机制，如果使用了比较复杂的类装载器体系结构，在出现了某个包或者类的多个版本时，应特别注意。

掌握和灵活运用Java的类装载器的体系结构，对程序的系统设计，程序的实现，已经程序的调试，都有相当大的帮助。希望以上的内容能够对您有所帮助。