CN101398779A

CN101398779A - 测试逻辑与服务器端对象的松耦合式测试方法和***

Info

Publication number: CN101398779A
Application number: CNA2007101619216A
Authority: CN
Inventors: 南俊杰; 王紫瑶; 王萌; 李正辉
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 2007-09-26
Filing date: 2007-09-26
Publication date: 2009-04-01
Also published as: US7971090B2; US20090083578A1

Abstract

公开了一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法和***，该方法包括以下步骤：在客户端创建服务器端第一对象的代理；在客户端部署的测试用例使用所述代理调用服务器端的所述第一对象的方法，以进行测试；以及当所述调用服务器端的所述第一对象的方法的步骤产生第二对象时，则由所述第一对象的代理在客户端自动创建所述第二对象的代理；其中，上述使用和自动创建步骤是递归执行的。

Description

测试逻辑与服务器端对象的松耦合式测试方法和***

技术领域

本发明涉及计算机领域，具体涉及例如在SOA环境中服务器端服务和/或对象的测试，更具体地，涉及一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法和***。

背景技术

目前，服务器端编程通常是基于容器的，且所述服务和相关业务逻辑都位于不同的容器例如各种J2EE(Java 2平台企业版)容器中。在SOA(面向服务架构)环境中，也同样如此。服务和组件是在应用服务器中提供的，并由容器所维护。因此，如何为部署在服务器端容器中的这些服务和底层逻辑实现代码、以及相关辅助代码构造自动测试用例、并使得这种测试如测试J2SE(Java 2平台标准版)组件那样方便灵活，是一个有待解决的重要问题。

现有的测试工具都不够方便灵活，诸如JUnit及其扩展、ApacheCactus、Java Test System(JTS)等，因为它们是基于容器的测试框架。就是说，由于测试逻辑将越来越多地依赖于由容器所提供的服务功能，测试用例需要被打包和部署在服务器端容器中执行。某些测试工具可以在客户端构建测试装具(test harness)，并具有重定向代理以关联服务器端的测试用例(例如，Apache Cactus)，或者具有servlet和XML配置文件以暴露服务器端的测试用例(JUnitEE)。尽管如此，每当测试用例有什么变化时，就需要重新构建测试用例，并将其重新部署到服务器上。图1示出了现有技术中的这样一种典型的测试框架。

为构建用于基于容器的服务和组件(例如以Java编写的)的真正灵活的测试用例，特别是用于SOA环境中的服务测试的测试用例，可以考虑采用容器外的测试框架。

另一种得到广泛使用的技术是模拟对象(mock object)，它可在一定程度上解决容器外测试的问题。但这种技术仍存在如下一些问题：1.为容器中的众多复杂的组件和服务开发模拟对象是一种很繁重的任务，在松耦合的SOA环境中尤是如此；2.仍需要在容器内使用真实对象进行测试；3.不可能实现模拟服务器。因此，模拟对象技术不能解决服务器端服务和对象的测试问题。

显然，本领域中需要一种方便灵活的用于服务器端的服务和对象的测试的方法和***。

发明内容

根据本发明的一个方面，提供了一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法，该方法包括以下步骤：在客户端创建服务器端第一对象的代理；在客户端部署的测试用例使用所述代理调用服务器端的所述第一对象的方法，以进行测试；以及当所述调用服务器端的所述第一对象的方法的步骤产生第二对象时，则由所述第一对象的代理在客户端自动创建所述第二对象的代理；其中，上述使用和自动创建步骤是递归执行的。

根据本发明的另一个方面，提供了一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试***，该***包括：在客户端创建的服务器端第一对象的代理，该代理被配置为：可由在客户端部署的测试用例使用来调用服务器端的所述第一对象的方法，以进行测试；且当所述调用服务器端的所述第一对象的方法的过程产生第二对象时，在客户端自动创建所述第二对象的代理；以及由上述使用和自动创建过程递归创建且具有上述功能的第二对象及其他对象的代理。

附图说明

所附权利要求中阐述了被认为是本发明的特点的新颖特征。但是，通过在结合附图阅读时参照下面对说明性实施例的详细说明将更好地理解发明本身以及其优选使用模式、另外的目标、特征以及优点，在附图中：

图1示出了现有技术中的一种典型的测试框架；

图2示出了根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试***；

图3示出了根据本发明的实施例的上述***在测试用例中使用动态递归代理以便将容器内的测试逻辑从服务器端转移到客户端的过程和机制的示例性示意图；

图4示出了根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法；以及

图5示出了根据本发明的实施例的***针对一示例测试逻辑在客户端和服务器端所执行的具体步骤。

具体实施方式

下面参照附图本发明的实施例。然而，应当理解的是，本发明并不限于所介绍的特定实施例。相反，可以考虑用下面的特征和元素的任意组合来实施和实践本发明，而无论它们是否涉及不同的实施例。因此，下面的方面、特征、实施例和优点仅作说明之用而不应被看作是所附权利要求的要素或限定，除非权利要求中明确提出。在此说明书内对特征、优点或类似语言的提及并不是暗示可使用本发明实现的所有或某些特征和优点在本发明的任何单个实施例内。相反，涉及特征和优点的语言应被理解为仅意谓着与实施例相联系地描述的特定特征、优点和特性被包含在本发明的至少一个实施例内。

本发明提供了一种用于服务器端服务和/或对象例如Java对象的测试的新的方法，该方法通过动态递归代理将原来的容器内测试逻辑从服务器端下移到客户端。使用本发明，可以将测试逻辑的执行步骤与测试代码松耦合化。换言之，本发明使能使用客户端的代理来操纵容器中的远程服务器端对象。

所述动态递归代理具有以下特征：

■可覆盖可在服务器端暴露的所有服务和Java类；

■当需要时动态地和递归地创建代理，并且所述创建动态递归代理对于客户端代码是透明的；

■管理代理的生命周期与其相应的对象的生命周期；

■可被用作模拟服务器。

这种灵活的方法实现了客户端的测试逻辑，并且测试用例可通过动态代理操纵真实的目标对象。第一个远程对象需要通过远程动态代理被显式地创建，此后测试逻辑无需再显式创建代理，而由本发明的***自动生成它们。因此，测试者可以使用通用的自动化测试框架例如用于Java测试的JUnit以方便灵活的方式来开发和执行他们的测试逻辑，并使用真实的容器内对象而不是模拟对象。当发生任何变化时，测试者可以在客户端作出改变，并重新执行测试用例，而无需将测试用例重新部署到服务器端。

代理与其相应的对象拥有相同的接口。即使调试器也无法将代理与其对象区分开来。通过使用本发明，测试逻辑可以进行API级别的调试，这有助于在生产环境中的问题确定。因此，这些代理以在某种程度上实现了模拟服务器。

代理是以动态和递归的方式产生的。一旦创建了新的代理，它将与所有现有的代理和非代理对象无缝地协同工作。换言之，该代理可以使用其他代理和非代理对象作为参数或被其他代理和非代理对象用作参数，或在必要时返回新的代理作为返回值。这将极大缩短学习曲线：用户仅需要如何创建第一个代理。

代理与其相应对象拥有相同的生命周期。代理与其相应对象的创建几乎是同时发生的。当代理在客户端由例如Java垃圾收集器销毁时，服务器端相应的对象将很快被销毁。这防止了在长期运行中的内存泄露问题。

下面参照附图以Java环境并更具体地以Java实现的SOA环境为例来说明根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法和***。本领域的技术人员可理解，本发明并不局限于Java环境或SOA环境，而是适用于任何客户-服务器环境中的服务器端对象的测试。

图2示出了根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试***。如图所示，该***包括在客户端的代理201，以及在服务器端的中介202。

代理201位于客户端的测试装具中，并可与测试用例进行交互，即由测试用例调用以及将调用结果传递给测试用例。在本发明的一个实施例中，所述代理201、测试用例、及其所在的测试装具都位于J2SE环境中。而所述中介202位于服务器端的容器中，并可与服务器端的容器中所部署的对象交互，即调用所述对象，并获得所述调用的结果。在本发明的一实施例中，所述容器为J2EE容器，且所述中介为一个Java servlet。且进一步地，该***处于SOA环境中，且所述对象为服务和服务的支持对象例如Java对象。

在本发明的实施例中，所述代理201包括在客户端创建的服务器端第一对象的代理201以及在测试用例的执行过程中由该第一对象的代理动态和递归地创建的其他对象的代理201。

获得第一对象的代理201的过程可以是典型的Java远程动态代理使用场景，并且需要在客户端获得第一对象的接口或类。在Java中，提供了若干实现动态代理的方法。例如，JDK提供了基于Java接口生成动态代理的机制。此外，根据Java编译类，也可能利用某些Java字节码操纵框架来创建代理。具体地，客户端可向服务器端的中介202发送创建第一对象的请求，服务器端的中介202根据所接收到的请求创建第一对象，例如ServiceManager对象，将该对象及其索引标识注册在存储器中的一注册表中，并向客户端返回该对象的索引标识和该对象的接口或类，而客户端根据接收到的该对象的索引标识以及其接口或类，通过代理工厂创建该第一对象的代理201。当然，如果该第一对象的类或接口已在客户端存在或已由用户指定，则不需要重新从服务器下载类或接口，而只需要首先在服务器端创建该第一对象并返回该对象的索引标识。另一方面，其他对象的代理201则可在测试过程中，当由对第一对象或其他已生成对象的调用产生其他新的对象时，由所述第一对象或其他已生成对象的代理201使用Java的动态代理功能通过代理工厂根据所获得的所述其他新的对象的索引标识以及接口或类来创建。如此动态递归创建的代理对于客户端的测试用例来说是透明的，即测试用例不需要显式地创建除第一对象之外的其他服务器端对象的代理，它只需要创建或调用所述其他服务器端对象，而由本发明的***自动为其创建所需要的服务器端对象的代理。

既可以仅在测试用例开始执行时显式创建一个第一对象的代理201，并在测试用例的执行过程中递归创建其他对象的代理201；也可以在测试用例的执行过程中多次显式创建其他第一对象的代理201，并在测试用例的执行过程中由所述多个第一对象的代理201分别递归创建其他对象的代理201。

在本发明的一个实施例中，在客户端的第一对象的代理201和由其创建的其他对象对代理201以及在服务器端的相应的第一对象及其他对象属于同一个会话，并且所述注册对象及其索引标识包括将该对象及其索引标识注册在其所属的会话中。在本发明的一实施例中，会话是通过cookie机制创建和维护的。

由此所生成的所述代理201具有与其相应对象相同的接口或方法。这样，对外部的使用者或调用者来说，所述代理201与其相应的对象是完全相同的，因此，测试用例可通过所述代理201调用所述第一对象的各方法。并且，所生成的代理201可以与客户端存在的所有其他已生成的代理以及所有非代理对象相交互，也就是说，代理的方法能接受其他代理或非代理对象作为参数，而非代理对象的方法也能够接收代理作为参数。

具体地，所述代理201(包括所述第一对象的代理以及由所述第一对象的代理递归创建的其他代理)被配置为当接收到测试用例对服务器端的相应对象的方法的调用时(在本文中，对对象的方法的调用应被理解为也包括对对象的域的操作)，将所述测试用例对所述相应对象的方法的调用通过网络传递给服务器端的中介202，以及从中介202接收所述调用的执行结果。在本发明的一个实施例中，所述代理201通过HTTP请求将所述调用传送给所述中介202。当然，在本发明的其他实施例中，所述代理201也可使用其他协议将所述调用传送给所述中介。

在本发明的一实施例中，所述代理201在将对相应对象的方法的调用通过网络传递给服务器端的中介202之前，首先检查该调用中的全部参数，并将其中的代理替换为相应的索引标识，以便在服务器端的中介在接收到所述调用之后，可根据调用参数中的索引标识找到相应的对象。

此外，当调用服务器端的对象的方法的过程产生新的对象时，所述代理201可根据从中介202所接收到的所述新的对象的接口或类以及索引标识在客户端自动创建所述新的对象的代理202，例如通过Java的动态代理功能使用代理工厂来进行创建。如此创建的新的对象的代理将具有与其相应对象相同的接口或方法，因而可由测试用例用来调用其相应对象的方法，从而可用来生成进一步的新的对象的代理，并可与现有的代理以及非代理对象相交互。

此外，当所述代理201在调用服务器端的相应对象的方法以进行测试的过程中发现缺少类时，它可通过网络向所述中介202发送对该类的请求。例如，当所述代理201调用服务器端的相应对象的方法的返回值为运行时异常而在客户端没有该运行时异常的类时，所述代理201可向所述中介202请求该运行时异常的类的代码例如Java字节码，并在从所述中介202接收到到该类的代码时使用例如Java类加载器加载该类的代码。

此外，当客户端的代理201被释放时，它可通过网络向服务器端的所述中介202发送释放通知。例如，当Java中的垃圾回收功能在一代理不再存在引用时调用该代理的finalize方法将该代理销毁时，或客户端的测试用例或测试装具等主动通过调用代理的finalize方法来销毁该代理(例如在会话结束时，销毁参与该会话的所有代理和对象，以及在测试结束时销毁所生成的所有代理和对象)时，该代理在被销毁之前可例如通过HTTP协议向服务器端的中介202发送包含被销毁代理的对象索引标识的释放通知，这样，服务器端的中介202可在接收到所述销毁通知后，根据销毁通知中的对象索引标识销毁相应的对象，并取消对该对象及其索引标识的注册，例如删除存储器中的注册表中的相应条目。

这样，可以动态和递归地创建服务器端的所有服务以及可暴露的对象的代理，因而这些代理可用作模拟服务器。并且保证了代理的生命周期与其相应的对象的生命周期是一致的。

在服务器端部署的所述中介202被配置为当从网络接收到来自客户端的代理201的对服务器端的相应对象的方法的调用时，调用所述对象的方法，并将调用该对象的方法的执行结果例如正常返回值或异常信息通过网络传递给客户端的所述代理201。

此外，所述中介202还被配置为当接收到来自客户端的代理201的加载类如加载异常类的请求时，从该请求中获取该类的代码的资源地址，从所述资源地址获取该类的代码，并将该类的代码通过网络传递给户端的代理201。

此外，如上所述，当所述中介202通过网络接收到来自客户端的测试用例的对所述第一对象的构造方法的调用时，根据所接收到的调用来调用所述第一对象的构造方法，从而创建该第一对象；注册该第一对象以及该第一对象的索引标识；并将该第一对象的索引标识以及该第一对象的接口或类通过网络传递给客户端，以使得客户端根据接收到的该第一对象的索引标识及接口或类创建该第一对象的代理。在这里，所述第一对象的构造方法应被理解为也包括可用于创建该第一对象的、该第一对象类中的静态域以及其他静态方法。

在本发明的一实施例中，所述中介202被配置为在根据所接收到的调用来调用相应对象的方法之前，检查所述调用的全部参数，并将其中的索引标识替换为相应的服务器端对象。

此外，所述中介202被配置为当所述调用所述对象的方法的过程产生新的对象时，注册该新的对象以及该新的对象的索引标识；获得该新对象的接口或类；以及将该新对象的索引标识以及该新对象的接口或类通过网络传递给客户端的所述代理201。在本发明的一实施例中，所述中介202将所述新的对象及其索引标识注册在该对象所属的会话中。

所述中介201可使用Java的固有功能，例如java.lang.Class和java反射包中的API，来分析并获得任何Java对象包括所述第一对象和新对象的接口和操作。

此外，所述中介202还被配置为当接收到来自客户端的代理201的释放通知时，根据所述通知中的索引标识释放相应的对象，并取消该对象及其索引标识的注册。在本发明的一实施例中，所述中介202将根据所述通知中的索引标识释放相应的对象，并在该对象所属的会话中取消该对象及其索引标识的注册。

以上描述了根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试***，应指出的是，所描述的***仅为示例，而不是对本发明的限制。本发明的***可具有更多、更少或不同的模块，且各模块之间的连接关系和包含关系可以不同。例如，所述代理201中的与所述中介202交互的功能也可由一单独的模块来执行。

图3示意性地示出了根据本发明的实施例的上述***在测试用例中使用动态递归代理以便将容器内的测试逻辑从服务器端转移到客户端的过程和机制的示例。

如图所示，测试用例和代理都在J2SE环境中运行，而待测目标对象在服务器容器中运行。测试用例封装了测试逻辑，测试逻辑使用对象代理来调用对象方法，对象代理把对对象方法的调用传递到服务器端的中介，而中介将创建和管理相应的服务或Java对象实例。以这种方式，测试逻辑被从服务器端下移到客户端。

具体地，如图所示，在步骤1，测试用例使用第一动态代理201调用相应的远程对象的某种操作。客户端可使用对象或代理作为输入和输出参数。

在步骤2，动态代理201通过HTTP请求向服务器端中介202发送请求。

在步骤3，服务器端的中介202在服务器端调用操作。

在步骤4，如果在服务器端创建了返回对象，则中介202将查找所有的相关接口，并将对象及其索引标识注册在注册表中。

在步骤5，中介202将可用接口和对象索引标识返回到客户端的代理201。

在步骤6，代理201创建相应的其他代理，并将其返回给测试用例。

该过程然后可返回步骤1，调用所述第一对象的其他操作或通过新生成的代理201调用其相应对象的某种操作，从而迭代执行以上各步骤。

下面参照图4具体描述根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法。该方法可由上述本发明的***来执行，因此，为叙述简明起见，在以下对本发明的方法描述中省略了与以上描述重复的部分内容。

如图所示，在步骤401，在客户端创建服务器端第一对象的代理。获得第一对象的代理的过程可以是典型的Java远程动态代理使用场景，并且需要在客户端获得第一对象的接口或类。具体地，客户端可向服务器端的中介发送创建第一对象的请求，服务器端的中介根据所接收到的请求创建第一对象，将该对象及其索引标识注册在一注册表中，并向客户端返回该对象索引标识和该对象的接口或类，而客户端根据接收到的该对象的接口或类以及索引标识，通过代理工厂创建该第一对象的代理。当然，如果该第一对象的类或接口已在客户端存在或已由用户指定，则不需要重新从服务器下载类或接口，而只需要首先在服务器端创建该第一对象并返回该对象的索引标识。

在测试用例的执行过程中，即可以仅创建一个第一对象的代理，而所有其他对象的代理都由该第一对象的代理递归创建；也可以创建多个相同或不同的第一对象的代理，每个所述第一对象的代理均递归创建其各自的其他对象的代理。

在客户端创建第一对象的代理的过程可由在客户端部署的测试用例在测试过程的一开始或在测试过程中发起，或由客户端的测试装具发起，或由客户端的其他组件发起。

在步骤402，在客户端部署的测试用例使用创建的代理调用服务器端的相应对象的方法，以进行测试。就是说，在紧接着创建第一对象的代理之后，可使用该第一对象的代理调用该第一对象的方法；而在递归创建了其他对象的代理之后，可使用其他对象的代理调用相应的其他对象的方法。在进行所述方法调用时，客户端可使用客户端存在的对象或代理作为输入和输出参数。

在步骤403，所述代理将所述测试用例对所述第一对象的方法的调用通过网络传递给服务器端的中介。例如，所述代理可通过HTTP请求将所述调用传递给服务器的中介。当然，代理也可使用任何其他协议或技术将所述调用传递给服务器的中介。

在本发明的一实施例中，所述代理在将对所述第一对象的方法的调用通过网络传递给服务器端的中介之前，首先检查该调用中的全部参数，并将其中的代理替换为相应的索引标识。

在步骤404，所述中介在接收到来自客户端的调用后，调用所述第一对象的方法，以进行测试。

在本发明的一实施例中，所述中介在根据所接收到的调用来调用相应对象的方法之前，检查所述调用的全部参数，并将其中的索引标识替换为相应的服务器端对象。

在步骤405，所述中介判断所述调用是否产生了的第二对象。

如果该判断为所述调用产生了第二对象时，则在步骤406，由服务器端的中介查找该第二对象的所有相关接口或类，并注册该第二对象以及该第二对象的索引标识，例如将其注册在该第二对象所属的会话中。

在步骤407，所述中介将调用所述第一对象的方法的执行结果例如正常结果或关于异常的信息、以及所产生的第二对象的索引标识及其接口或类通过网络例如使用HTTP协议传递给客户端的所述第一对象的代理。

在步骤408，所述第一对象的代理根据接收到的来自服务器端的中介的所述第二对象的接口或类以及其索引标识，自动创建所述第二对象的代理。

由此所生成的该第二对象的代理具有与所述第二对象相同的接口或类。这样，对外部的使用者或调用者来说，该代理与该第二对象是完全相同的，此外，该第二对象的代理可以与客户端存在的其他代理和对象相交互。

此外，该第二对象的代理还能够将所接收到的对该第二对象的方法调用通过网络发送到服务器端的中介，并能够从服务器端的中介接收所述方法调用的执行结果，包括所述方法调用的返回值和异常等。如果所述方法调用的返回一新的对象，则该代理能够根据所返回的该新的对象的索引标识和接口或类生成该新的对象的代理。也就是说，该第二对象的代理能够动态地和递归地创建其他对象的代理。

另一方面，如果步骤405的判断为所述调用没有产生新的对象，则执行步骤409，在该步骤中，中介将该调用的结果传递给代理。

在步骤410，所述代理记录所述执行结果，以便由用户进行分析和调适等。

在测试用例的执行过程中，在步骤411，可判断一代理是否将被释放。例如，Java中的垃圾回收功能可在一对象不存在引用时调用该对象的finalize方法将该对象销毁。这样，根据本发明的实施例实现的代理可判断其finalize方法是否被调用，以确定其是否将被释放。当然，在本发明的其他实施例中，也可由客户端的测试用例或测试装具等主动通过调用代理的finalize方法来释放代理，例如，在一会话结束时释放参与该会话的所有代理。

如果步骤411的判断为是，则执行步骤412，在该步骤中，当客户端的一代理被释放时，该代理在被释放之前通过网络向服务器端的中介发送释放通知。

在步骤413，中介根据所接收到的释放通知释放相应的对象，并取消对该对象的注册。

当中介已根据来自客户端的释放请求释放了一会话中的所有对象后，可进一步地释放该会话。

在步骤414，由客户端的测试用例或测试装具等判断是否继续进行测试。

如果该判断为是，则返回步骤402，继续使用原来的代理或新创建的代理调用服务器端的相应对象，来进行测试，从而迭代执行以上过程，并在测试过程中在必要时动态和递归地创建其他对象的代理。

如果该判断为否，则执行步骤415，在该步骤中，分别在客户端释放所有代理，以及通知中介在服务器端释放所有相应的对象，从而测试过程结束。

以上描述了根据本发明的实施例的一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法，应指出的是，所描述的方法仅为示例，而不是对本发明的限制。本发明的方法可具有更多、更不或不同的步骤，且各步骤之间的顺序可以不同或并行执行。例如，所述判断是否释放代理的步骤411以及所述判断是否继续进行测试的步骤414可以在与图中所示不同的任何其他时刻执行。

下面给出一段示例测试逻辑。图5示出了本发明的***针对该示例测试逻辑在客户端和服务器端所执行的具体步骤。

ServiceManager serM＝ServiceManager.INSTANCE；

//创建ServiceManager

Service orderService＝serM.locateService(＂orderServicePartner＂)；

//通过ServiceManager，查找到orderService。orderService是

server端的一个service.

DataObject order1＝(DataObject)orderService.invoke

(＂createOrder＂，paras)；//调用orderService的createOrder

方法，创建一个order，存入数据库中。返回创建的名为order1

的订单对象。

order1.setString(key，value)；//修改order1中的一个值.

orderService.invoke(＂modifyOrder＂，order1)；//调用orderService的modifyOrder方法，将修改后的order1对象在数据库中进行更新。

下面给出在本发明的一示例性实施例中，以Java实现的本发明的***中的各部件的示例伪码。应当指出的是，以下伪码仅为示例，旨在使本领域的技术人员可更好地理解本发明的基本思想，并可实施本发明，而不是对本发明的限制。例如，所给出的伪码示例中的客户端通讯模块也可被视为包含在所述代理之中。

示例伪码

1.代理的实现

a)由接口列表创建代理

Object newProxyInstance(Class[] interfaces，String keyId){

1.由keyId创建InvocationHandler，所有代理的调用都会归到

InvocationHander的invoke方法处理.

InvocationHander handler＝new InvocationHandler(){

public Object invoke(Object targetobj，Method method，

Object[] args){

1.1 调用客户端通讯模块

String name＝method.getName()；

Class[]types＝method.getParameterTypes()；

Object rtobj＝chat(keyId，name，types，args)；//参见chat

方法伪码

1.2 处理结果

1.2.1 空指针的情况

if(rtobj＝＝null)

return null；

1.2.2返回值需要创建代理或处理异常的情况

if(rtobj instanceof ChinRtObj){

ChinRtObj chinRtObj＝(ChinRtObj)rtobj；

Throwable t＝chinRtObj.getThrowable()；

f(t！＝null)throw t；//处理异常

Class[]interfs＝chinRtObj.getInterfaces()；

String keyId＝chinRtObj.getKeyId()；

return ChinProxy.newProxyInstance(interfs，keyId)；//重新调用生成新的代理。

1.2.3简单类型与字符串

}else if (ChinUtil.isPrimitive(rttype)||

String.class.equals(rttype)){

//return type is primitive class or type or String

return rtobj；

1.2.4数组

}else if(rtobj.getClass().isArray()){

为数组里的每个值生成代理(如果需要的话)

}

2.创建并返回代理

Proxy.newProxy Instance(clasLoader，interfaces，

handler)；}

b)第一个代理的创建

i. 基于接口的第一个代理的创建

1.方法的描述

Object newProxyInstance(Class[] interfaces，String

implClass Name，String name，Class [] types，Object [] args)

interfaces-接口列表

implClassName-实现类名

name-如果name为空指针，用于基于构造方法的创建；

如果name不为空指针而types为空指针，用于基于静态域的创建，name指静态域名；

如果name不为空指针而且types不为空指针，用于基于静态方法的创建；name指静态方法名

types-基于静态方法创建时指方法参数类型列表

args-基于静态方法创建时指方法值列表

这个是一个通用的方法，实际的使用会有一些封装，但最终的调用都会归结到这个方法.

2.方法的实现

{

a)调用客户端通讯模块，得到返回值

Object obj＝chat(implClassName，name，types，args)；

b)处理结果：返回的是代理

if(obj instanceof ChinRtObj){

String keyId＝((ChinRtObj)obj).getKeyId()；

return ChinProxy.newProxyInstance(interfaces，

keyId)；}

c)处理结果：返回的不是代理

return obj；}

ii.基于类的第一个代理的创建

1.方法的描述

Object newProxyInstance(Class implClass，Class[] types，Object[] args)

其中implClass为实现类

types-为实现类构造方法参数类型列表

args-为实现类构造方法参数值

2. 方法的实现

当前的实现使用了ASM的字节码生成工具，ASM相当于Java的汇编码。

如何动态创建类的问题请参见ASM主页http://asm.objectweb.org

这里假设implClass为类A。大体的思路是，由实现类创建两个类，一个是有其所有方法的接口C，一个是其子类B。在其子类B中创建一个域proxyInstance，该proxy Instance使用接口C作为接口列表，使用基于接口的第一个代理的创建方式创建；子类B重载父类A所有方法，并将所有方法调用引向proxyInstance的调用；之后然后返回子类B的相应实例作为代理。由于子类B是父类A的子类，因此可以做一下反射：

Aa＝(A)newProxy Instance(A.class，new Class[]{}，newObject[]{})；

a)创建子类B

i.动态解析类A所有方法，生成Java接口C，C中包含A的所有方法

ii.基于构造方法生成代理(name＝null)：

String implClass Name＝implClass.get Name()；

Class[] interfaces＝new Class[] {C.class}；

proxyInstance＝newProxyInstance(interfaces，

implClassName，null，types，args)；

iii. 由implClass A动态生成其子类B，proxyInstance作为子类B的一个域。子类B实现父类A的所有方法。示例如下：

class B extends A{

C_proxyInstance

...＼

//以下是某个方法的实现

返回类型methodA(参数列表){

return_proxyInstance.methodA(参数列表)；

}

...＼

}

b)返回子类的实例作为代理

i.找到子类的相应构造方法

Constructor constructor＝

subClass.getConstructor(types)

ii.返回子类实例

return constructor.newInstance(args)；

2.客户端通讯模块的实现

a)客户端通讯模块的接口

public Object chat(String target，String name，Class[]types，Object[]args)，其中，

target为真实对象的索引标识或实现类的全名。

name为所调用target上的方法或静态域，如果为空指针，则指构造方法；如果name不为空指针且types为空指针，则是指静态域；如果name和types都不为空指针，则是指非构造方法的一般方法。非构造方法的一般方法有两类：一类是静态的方法(类的方法)，一类是非静态的方法(对象的方法)；当target为实现类时，name和types都不为空指针，name指静态方法；当target为真实对象的索引标识时，name和types都不为空指针，name指非静态方法或静态方法都可以。

types当name指方法(包括一般方法和构造方法)时，types为参数类型列表

args当name指方法(包括一般方法和构造方法)时，args为参数值列表

b)客户端通讯模块接口如何使用

当前有两个用途：

i.调用target上的参数类型为types的方法name，参数值为args，获得返回值，这里方法name有2种：

1.类的方法，类的方法也有两种：

a)构造方法，相当于new A()

b)静态方法，相当与A.methodA()，其中methodA是类A的方法。

2.对象的方法，相当于A a＝new A()；a.methodB()，其中methodB是对象a的方法，使用A.methodB()则调用不到；

target也有两种：

1.实现类的全名

如果name为实现类的全名，客户端通讯模块被用作第一个代理的创建

2.真实对象的索引标识

这时的调用的一般是代理的方法。有些***的调用走的也是这一个分支(比如垃圾回收)。

ii. 获得target上名为name静态域，返回值为静态域

这个分支也是用于第一个代理的创建。

c) 中介的客户端的具体实现伪码：

public Object chat(String target，String name，Class[]types，

Object[]args){

1.创建到中介的连接

URL url＝new

URL(＂http://localhost：9080/vRecoveryTestWeb/...″)；

//中介为一个servlet

HttpURLConnection connection＝(HttpURLConnection)

url.openConnection()；

2.设置发送的cookie(利用cooke和session机制保持会话，结合步骤6)sendCookies(connection)；//设置cookie

3.设置请求方法为POST，发送数据类型为Java序列化数据.

connection.setDoOutput(true)；

connection.setRequestProperty(＂Content-Type＂，

＂application/x-java-serialized-object＂)；

connection.setRequestMethod(＂POST＂)；

4.集结数据，准备往中介写数据

Object[]params＝new Object[]{target，name，types，

args}；

5.往中介写数据

OutputStream outputStream＝

connection.getOutputStream()；

writeObject(outputStream，params)；//代理接受代理，实现于此，详见writeObject的伪码。

6.接受这次的cookie以备下次请求发送

setCookies(connection)；

7.接收数据

InputStream inputStream＝connection.getInputStream()；

Object obj＝readObject(inputStream)；//从服务端加载

客户端没有的类实现于此，详见readObject的伪码

connection.disconnect()；//disconnect

8.返还结果

return obj；}

writeObject(OutputStream outputStream， Serializable

params){

1.创建对象输出流

ObjectOutputStream oos＝new ObjectOutputStream(

outputStream){

//重载replaceObject方法，如果对象为代理，则替换为

KeyId

protected Object replaceObject(Object obj)throws

IOException{

如果obj为代理，从obj得到其KeyId并返回；

否则返回obj；

}

}；

2.写对象

因为使用的是重载的对象输出流，对象params，包括其内所有其他对象的引用，都会调用replaceObject，检查是否需要替换为相应KeyId。

oos.writeObject(params)；

oos.flush()；

oos.close()；}

Object readObject(InputStream inputStream){

1.创建对象输入流

Object InputStream ois＝new

ObjectInputStream(inputStream){

//重载resolveClass以检查所有类是否完备

protected Class resolveClass(ObjectStreamClass desc){

try{

return super.resolveClass(desc)；

}catch(ClassNotFoundException e){

//如果有类不存在则从远程类加载器加载这个类

String className＝desc.getName()；

return classLoader.loadClass(className)；

}

}；

2.读返回值

这一步运行时，返回值依赖的每一个类都会经resolveClass检查，如果发现不存在则远程加载。这里返回值包括正常返回和异常返回。而异常返回经常会有需要远程加载类定义的情况发生

Object obj＝cois.readOb ject()；

cois.close()；

return obj；}

3.中介的实现

a)中介实现为一个servlet，中介有两个任务

i.客户端使用GET请求从中介获得类定义的字节码

ii.客户端使用POST请求通过中介调用真实对象的相应方法

b)中介GET实现伪码

void doGet(HttpServletRequest req，HttpServletResponse

resp){

1.从所请求的URL中得到类的资源名

类的资源名和类名有一个简单映射：className.replace(′.′，

′/′).concat(＂.class＂)；String url＝

req.getRequestURL().toString()；

String resourcename＝getResourceName(url)；

2.从资源名得到字节码并写到输出流

OutputStream out＝resp.getOutputStream()；

loadResourceBytes(resourcename，out)；}

c)中介POST实现伪码

void doPost(HttpServletRequest req，HttpServletResponse

resp){

try{

1.由相应cookie得到相应会话，结合1.c.chat第2步和第6步理解

HttpSession session＝req.getSession(true)

2.从输入流里读参数，由于参数里可能有代理的KeyId，因此在readParams里会做相应替换，将代理的KeyId替换为真实对象，详见readParams方法的伪码实现

InputStream inputStream＝req.getInputStream()；

Object[]params＝readParams(inputStream，session)；

3.调用相应方法并得到结果

Object result＝invoke(session，//session

(String)params[0]，//target

(String)params[1]，//method name or field name

(Class[])params[2]，//types

(Object[])params[3])；//args

4.写结果，详见writeResult的伪码

writeResult(resp.getOutputStream()，result)；

5.处理调用过程中的异常情况并将异常写回客户端

catch(InvocationTargetException e){

Throwable te＝得到异常的根本原因

ChinRtObj rtobj＝new ChinRtObj(null)；

rtobj.setThrowable(te)；

writeResult(resp.getOutputStream()，rtobj)；}

readParams(InputStream inputStream，final HttpSession

session){

1.创建对象输入流，重载resolveObject方法，把KeyId替换为相应真实对象。resolveObject的实现如下：

protected Object resolveOb ject(Object obj){

if(obj instanceof Chin){

return

session.getAttribute(((Chin)obj).getKeyId())；

}

return obj；

}

2.由对象输入流读对象并返回。

}

void writeResult(OutputStream outputStream，Object

result){

1.创建对象输出流

ObjectOutputStream objectOutputStream＝newObjectOutputStream(

outputStream)；

2.写结果

objectOutputStream.writeObject(result)；

objectOutputStream.flush()；

objectOutputStream.close()；

Object invoke(HttpSession session，String target，

String name，Class[]types，Object[]args){

1.找目标对象，

目标对象有三个可能值：session本身，session里注册的值，以及空指针。Session本身和session里注册的对象统一处理，目标对象为空指针按创建新目标对象处理

if(SESSION.equals(target)){//判断target对象是否

为session本身targetObj＝session；

}else{//如果不是，在session找target

targetObj＝session.getAttribute(target)；}

2.如果找不到，创建新的目标对象，将目标对象注册到session注册表里，并返回目标对象KeyId

if(targetobj＝＝null){

Objectobj＝chinchilla(target，name，types，args)；

//chichilla里的逻辑：

//1.if(name！＝null && types＝＝null)，由静态域创建

//2.else if(name！＝null && types！＝null)，由静态方法创建

//3.else由构造方法创建

ChinRtObj initkey＝genRtObject()；//产生一个唯一的KeyId

//注册

session.setAttribute(initkey.getKeyId()，obj)；

//返回

re turn ini tkey；

}

3.否则，调用目标对象上的方法

Method method＝

ChinUtil.getMethod(targetobj.getClass()，name，

types)；

Object result＝method.invoke(targetobj，args)；

4.结果的处理：primitive类型和数组

Class rtType＝method.getReturnType()；

//deal primitive type

if (result＝＝null||ChinUtil.isPrimitive(rtType)

||rtType.equals(String.class)){

return result；

}

//处理数组

if(result.getClass().isArray()){

return arrayResult(session，result)；

}

5.结果的处理：对象

//找返回对象类里的所有接口

Class[] rtypes＝findInterfaces(result)；

//生成有唯一KeyId的返回对象

ChinRtObj rtobj＝genRtObject()；

//注册返回对象

session.setAttribute(rtobj.getKeyId()，result)；

//设接口列表

rtobj.setInterfaces(rtypes)；

返回结果

return rtobj；

}

4.垃圾回收的实现

重载Invoca tionHandler的方法protected void finalize(){调用客户端通讯模块方法，将相应的真实对象从session对象里移去，真实对象的引用数会减一，如果真实对象的引用数为0，会进入服务器端的垃圾回收流程。

chat(SESSION，＂removeAttribute＂，

new Class[]{String.class}，

new Object[]{keyId})

}

需要注意的是，finalize由客户端的垃圾回收器发起，而不是用户主动调用。｀keyId′可以由InvocationHandler得到，因为我们的创建我们自己的InvocationHandler的时候已经提供了keyId。参见InvocationHandler的创建一节。

本发明可以硬件、软件或其结合的方式实现。一种典型的硬件和软件的组合可以是带有计算机程序的通用计算机***，当该计算机程序被加载和执行时，控制该计算机***而使其执行本文中描述的方式。本发明优选地以分布方式实现，在这种分布方式中，不同的部件分布在若干互连的计算机***中。本发明更优选地在客户服务器环境中实现，在这种客户服务器环境中，客户使用某种协议向服务器发送获取信息或执行操作的请求，服务器进行响应，以提供信息或执行操作。适于执行本文中描述的各方法的任何计算机***或其它装置都是合适的。

本发明也可体现在计算机程序产品中，该程序产品包含使能实现本文中描述的方法的所有特征，并且当其被加载到计算机***中时，能够执行这些方法。

尽管已参照优选实施例具体示出和说明了本发明，但是本领域内的那些技术人员应理解，可在形式和细节上对其进行各种改变而不会背离本发明的精神和范围。

Claims

1.一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试方法，该方法包括以下步骤：

在客户端创建服务器端第一对象的代理；

在客户端部署的测试用例使用所述代理调用服务器端的所述第一对象的方法，以进行测试；以及

响应于所述调用服务器端的所述第一对象的方法的步骤产生第二对象，由所述第一对象的代理在客户端自动创建所述第二对象的代理；

其中，上述使用和自动创建步骤是递归执行的。

2.根据权利要求1的方法，其中所述代理具有与其相应对象相同的接口或方法。

3.根据权利要求1的方法，其中所述使用步骤包括以下子步骤：

所述测试用例通过所述代理调用服务器端的所述第一对象的方法；

所述代理将所述测试用例对所述第一对象的方法的调用通过网络传递给服务器端的中介；

所述中介根据所接收到的调用来调用所述第一对象的方法；以及

所述中介将调用所述第一对象的方法的执行结果通过网络传递给客户端的所述代理。

4.根据权利要求3的方法，还包括以下步骤：

在所述代理将对所述第一对象的方法的调用通过网络传递给服务器端的中介之前，将所述调用的参数中的代理替换为相应的索引标识；以及

在所述中介根据所接收到的调用来调用所述第一对象的方法之前，将所述调用中的索引标识替换为相应的服务器端对象。

5.根据权利要求3的方法，其中所述自动创建步骤包括以下子步骤：

当所述中介调用所述第一对象的方法的子步骤产生第二对象时，由所述中介注册该第二对象以及该第二对象的索引标识，且其中，所述传递子步骤包括将所述第二对象的索引标识以及该对象的接口或类通过网络传递给客户端的所述第一对象的代理；以及

所述第一对象的代理根据接收到的所述第二对象的索引标识以及该第二对象的接口或类创建所述第二对象的代理。

6.根据权利要求3的方法，其中所述创建第一对象的代理的步骤包括：

所述测试用例将对所述第一对象的构造方法的调用通过网络传递给服务器端的所述中介；

所述中介根据所接收到的调用来调用所述第一对象的构造方法，从而创建该第一对象；

所述中介注册该第一对象以及该第一对象的索引标识；

所述中介将该第一对象的索引标识以及该第一对象的接口或类通过网络传递给客户端的测试用例；以及

所述测试用例根据接收到的该第一对象的索引标识及接口或类创建该第一对象的代理。

7.根据权利要求5或6的方法，其中所述第一对象和第一对象的索引标识以及所述第二对象和第二对象的索引标识是在一会话中注册的。

8.根据权利要求1的方法，还包括以下步骤：

响应于客户端的一代理被释放，该代理通过网络向服务器端的中介发送释放通知；以及

所述中介根据所述通知释放相应的对象。

9.根据权利要求3、5、6和8中任何一个的方法，其中所述代理和所述中介之间的信息传递是通过HTTP协议进行的。

10.根据权利要求1的方法，其中该方法是在Java编程环境中执行的，所述对象在服务器端的J2EE容器中，所述中介为servlet，且所述创建代理是通过Java的动态代理功能完成的。

11.根据权利要求1的方法，其中该方法是在SOA环境中执行的，且所述对象为服务和/或服务的支持对象。

12.一种客户服务器环境下测试逻辑与服务器端对象的松耦合式测试***，该***包括：

在客户端创建的服务器端第一对象的代理，该代理被配置为：

可由在客户端部署的测试用例使用来调用服务器端的所述第一对象的方法，以进行测试；且

响应于所述调用服务器端的所述第一对象的方法的过程产生第二对象，在客户端自动创建所述第二对象的代理；以及

由上述使用和自动创建过程递归创建且具有上述功能的第二对象及其他对象的代理。

13.根据权利要求12的***，其中所述代理具有与相应对象相同的接口或方法。

14.根据权利要求12的***，该***还包括在服务器端部署的中介，且其中，

所述被配置为可由在客户端部署的测试用例使用来调用服务器端的所述第一对象的方法、以进行测试的代理被进一步配置为：当接收到所述测试用例对服务器端的所述第一对象的方法的调用时，将所述测试用例对所述第一对象的方法的调用通过网络传递给服务器端的所述中介；

所述中介被配置为：根据所接收到的调用来调用所述第一对象的方法，并将调用所述第一对象的方法的执行结果通过网络传递给客户端的所述代理。

15.根据权利要求14的***，其中，所述代理被进一步配置为：在将对所述第一对象的方法的调用通过网络传递给服务器端的中介之前，将所述调用的参数中的代理替换为相应的索引标识；以及

所述中介被进一步配置为：在根据所接收到的调用来调用所述第一对象的方法之前，将所述调用中的索引标识替换为相应的服务器端对象。

16.根据权利要求14的***，其中，所述中介被进一步配置为：当所述调用所述第一对象的方法产生第二对象时，注册该第二对象以及该第二对象的索引标识；以及将所述第二对象的索引标识以及该对象的接口或类通过网络传递给客户端的所述第一对象的代理；且其中，

所述被配置为在客户端自动创建所述第二对象的代理的第一对象的代理被进一步配置为根据接收到的所述第二对象的接口或类创建所述第二对象的代理。

17.根据权利要求14的***，其中，所述中介还被配置为：

当通过网络接收到来自客户端的对所述第一对象的构造方法的调用时，根据所接收到的调用来调用所述第一对象的构造方法，从而创建该第一对象；

注册该第一对象以及该第一对象的索引标识；

将该第一对象的索引标识以及该第一对象的接口或类通过网络传递给客户端，以使得客户端根据接收到的该第一对象的索引标识及接口或类创建该第一对象的代理。

18.根据权利要求16或17的***，其中所述第一对象和第一对象的索引标识以及所述第二对象和第二对象的索引标识是在一会话中注册的。

19.根据权利要求12的***，其中，

客户端的所述代理还被配置为：响应于其被释放，通过网络向服务器端的所述中介发送释放通知；以及

所述中介还被配置为根据所述通知释放相应的对象。

20.根据权利要求14、16、17或19的***，其中所述代理和所述中介之间的信息传递是通过HTTP协议进行的。

21.根据权利要求12的***，其中该***处于Java编程环境中，所述对象在服务器端的J2EE容器中，所述中介为servlet，且所述代理是通过Java的动态代理功能创建的。

22.根据权利要求14的***，其中该***处于SOA环境中，且所述对象为服务和/或服务的支持对象。