WEBLOGIC的安装、配置和启动

WEBLOGIC的安装、配置和启动

一、软件安装
1. 安装前的准备工作

1.1 首先请确认您要安装的WebLogic版本所在的平台已通过了BEA的认证，
完整的认证平台列表请参考 http://e-docs.bea.com/platform/suppconfigs/index.html

1.2 确定一个安装目录，建议该目录下至少有1个G的空间，可单独创建个逻辑卷和文件系统

1.3 创建一个BEA用户组帐号

1.4 创建一个weblogic用户帐号

2. 安装步骤

WebLogic在AIX平台下的安装方法一般有三种:图形窗口模式，控制台模式，无人守护安装模式。

由于控制台模式的使用最为广泛且不受任何其它硬件条件的限制（所以我们这里只介绍控制台安装模式。

2.1 安装JRE环境
WebLogic安装程序需要JRE的支持，根据安装平台的不同，
WebLogic的安装介质也分为两类，
一种自带了JRE（后缀名为.bin）,
一种需要下载平台厂商所提供的JRE环境(后缀名为.jar)，
以WebLogic Server 8.1 with SP2为例，目前所支持的UNIX/LINUX平台如下所示(截止2004.2.23)
WebLogic Server 8.1 with SP2

支持平台 是否自带JDK

HP-UX (11.0,11.i, PA-RISC) YES
Sun Solaris (8, 9, SPARC) YES
Red Hat Enterprise Linux (2.1, Pentium) YES
Red Hat Enterprise Linux (2.1, Itanium) YES
SuSE SLES (8, Pentium) YES
United Linux (1.0, Pentium) YES
IBM AIX (5.1, 5.2) NO

首先要下载和操作系统以及WEBLOGIC相匹配JDK版本，
最好是经过BEA认证的版本。
可查询以下链接http://e-docs.bea.com/platform/suppconfigs/index.html；

在AIX上安装JDK要注意以下步骤：

安装后要修改环境变量/etc/environment文件，

将PATH中Java部分更改为新安装的Java版本（Java131或Java14）,

并重新Login后生效！
否则系统会使用原有的Java130环境，在安装weblogic7.0以上版本时会自动退回到提示符下。

2.2 获取并上传weblogic安装介质到一个临时目录
如果手头没有安装介质，我们可以到http://commerce.bea.com上下载一个WebLogic试用版，
然后通过FTP上传到主机上的一个临时目录，该临时目录建议至少有1个G的剩余空间

2.3 开始安装

2.3.1 .bin的安装方法

首先赋予.bin可执行权限
chmod a+x filename.bin

然后执行

./filename.bin -mode=console

2.3.2 .jar的安装方法

然后执行
java -jar filename.jar -mode=console(字符)
java -jar filename.jar -mode=graphics(图形)

2.4 控制台安装

2.4.1 完成2.3的步骤后，进入控制台安装的欢迎界面，键入[Next]继续

2.4.2 此时出现授权许可协议，读完后键入[Yes]继续

2.4.3 提示选择一个BEA主目录，如下所示

Choose BEA Home Directory:"BEA Home" = [/home/weblogic/bea]

Input new BEA Home OR [Exit][Previous][Next]>

如果想更改默认的BEA主目录，重新输入完整的目录路径即可，否则键入[Next]继续

2.4.4 确认BEA主目录

Choose BEA Home Directory: 　
->1| Yes, Use this BEA home directory [/home/bea]　　

2| No, return to BEA home directory selectionEnter index number to select OR [Exit][Previous][Next]>
键入[1]继续

2.4.5 选择安装类型

Choose Install Type:　

->1|Complete Installation　　　|Install the complete BEA WebLogic Platform.　
2|Custom Installation　　|Choose software components to install and optionally create custom　
　|application domains. Recommended for advanced users.
键入[1]继续

2.4.6 选择安装路径

Choose Product Directory:Product Installation Directory = [/home/bea/weblogicXX]

Input new Product Installation Directory OR [Exit][Previous][Next]>

如果想更改默认的安装目录，重新输入完整的目录路径即可，否则键入[Next]继续

2.4.7 确认安装路径
Choose Product Directory:　　
->1| Yes, use this product directory [/home3/weblogicXX]　　
2| No, select another product directoryEnter index numbers to select OR [Exit][Previous][Next]>
键入[1]继续

2.4.8 现在开始安装，此时会出现一个模拟的进度条，耐心等待，直到100%安装顺利结束。

二、配置Configuration Wizard
软件安装完毕后，下一步配置Domain域，进入weblogic安装目录

（例如：/wls/weblogic700/common/bin），找到文件dmwiz.sh，执行它

#./dmwiz.sh；选择WLS Domain,NEXT下一步；

此界面有四个选项，
单一服务选择第一项Single server;

第二项管理服务，

第三项集群管理服务；

第四项管理服务设置；

我们选择第一项，NEXT下一步；

确认Domain域路径，我们选择默认路径；NEXT下一步；
该界面要输入

Server Name(服务名称)-------myserver
Server Listen Adress一栏为服务器地址，此项为默认，可不填！
Server Listen Por交互端口---7001
Server Listen SSL Por监听端口------7002

NEXT下一步

创建Administrative User用户名和密码（密码不少于8位），NEXT下一步；

该界面是所有配置信息的汇总确认，如果没问题，点击Create,开始创建DOMAIN域.

三、启动Weblogic
在启动Weblogic之前，可将服务用户名和密码写入启动脚本。
进入刚刚配置完成的域目录
（例如：/wls/user_projects/mydomain），
编辑startWebLogic.sh启动脚本，

执行$ vi startWebLogic.sh

在“WLS_USER= WLS_PW=”输入用户名和密码，保存退出；

最后执行$ ./startWebLogic.sh，启动Weblogic..

四、停止Weblogic服务
停止Weblogic服务有多种：
1、 KILL掉进程
2、 通过”http://服务地址：7001/console”,shutdownserver

3、 利用脚本停止服务：
在＃/wls/weblogic700/samples/workshop路径下，
有一个stopWebLogic.sh文件，对他进行稍微编辑，
COPY到/wls/user_projects/mydomain目录下，执行即可。

来自http://blog.163.com/sun-_-rain/blog/static/55604374200710304131823/
......(准备工作略)
一.具体安装过程
启动控制台安装向导：
（1）进入Welcome界面，键入[Next]继续
（2）在BEA Systems License Agreement界面，键入[1]继续
（3）在Choose BEA Home Directory界面，键入[1]选择创建新的BEA Home目录，输入新的BEA Home Directory：/opt/weblogic，继续
（4）在BEA Home Directory设置的确认界面，键入[1]，确定（3）中输入的目录
（5）在Choose Install Type界面，键入[1]，采用Complete安装模式
（6）在Choose Product Directory界面，键入[Next]，用默认的目录即可
（7）在Choose Product Directory的确认界面，键入[1]，确定（6）中的选择
（8）现在开始安装，此处出现一个模拟的进度条，当到达100%安装就结束了。

二、配置
1、新建一个weblogic用户，用来管理weblogic服务器。
2、把/opt/weblogic的所有权赋给weblogic用户
#chown -R weblogic:weblogic /opt/weblogic

3、转到weblogic用户
# su - weblogic

4、设置与java相关的内容
$ cd /opt/weblogic
$ rm -r jdk142_05 # 删除这个目录，因为安装时未带jdk，所以这个目录空的
$ ln -s /opt/java1.4 jdk142_05

5、执行Domain的配置
$ cd /opt/weblogic/weblogic81/common/bin
$ ./config.sh -mode=console
启动BEA Weblogic Configuration Wizard
（1）在Create or Extend a Configuration界面，键入[1]，继续
（2）在Select a Domain Template界面，键入[1]，继续
（3）在Choose Configuration Option界面，键入[1]，继续
（4）在Configure Administrative Username and Password界面，键入[2]，进入密码修改界面，输入新密码为weblogic后，返回前一个界面，键入[3]，进入确认密码修改界面，输入新的确认密码为weblogic后，返回前一个界面，键入[Next]，继续
（5）在Domain Mode Configuration界面，键入[1]，继续
（6）在Java SDK Selection界面，键入[1]，继续
（7）在Select the target domain directory for this configuration界面 ，键入[Next]，继续
（8）在Select the applications directory for this configuration界面，键入[/opt/weblogic/user_projects/domains/applications]，继续
（9）在Edit Domain Information界面，键入[flashdragon]之后，在后续界面中，键入[Next]，继续
（10）进入配置执行界面，当提示Domain Create Successfully时，配置成功完成。

三、启动
$ cd /opt/weblogic/user_projects/domains/flashdragon
$ ./startWebLogic.sh

来自：
http://blog.csdn.net/nilxin/archive/2006/05/09/713961.aspx
十二、配置WebLogic数据源
（1）、创建部署链接池
1、 在控制台左边的树形目录中打开Services->JDBC->Connection Pools节点.
2、 在右边的主界面中点击"Configure a new JDBC Connection Pool... "连接,
在打开的页面中选择数据库的类型和数据库驱动的类型(数据库JDBC驱动要在classpath指定的路径中),点击"continue"按钮.

3、根据提示输入所需的信息,最后创建和部署数据连接池.

（2）、创建部署数据源
1、在控制台左边的树形目录中打开Services->JDBC->Data Sources节点.
2、 在右边的主界面中输入数据源名称和jndi名,然后点击"continue"按钮
3、 选择数据源所使用的数据连接池.
4、勾选数据源要部署到的服务器,然后点击"create"按钮创建数据源.

可能存在的问题：更改链接池的大小，缓冲内存占用的大小。

来自;
http://blog.163.com/ceip2183/blog/static/293636120069172731689/

对WebLogic Workshop 8.1应用程序进行单元测试--BEA WebLogic Workshop的示例扩展
对WebLogic Workshop 8.1应用程序进行单元测试--BEA WebLogic Workshop的示例扩展
作者： Joshua Eckels，BEA软件工程师∣来源：BEA dev2dev∣原文地址∣2005-1-7
在本文中，我将描述如何使用JUnit对在WebLogic Platform 8.1上开发的应用程序进行单元测试。
我将说明如何在应用程序开发期间为一般WebLogic Platform应用程序的所有组件编写和运行单元测试。
本文面向那些计划把JUnit集成到WebLogic Platform中去的开发人员和架构师精英。

简介
　　单元测试是迭代开发过程中的关键实践。
．软件工程师通过单元测试在代码级别上测试代码。
单元测试的运行频率通常很高，因此特别适合于自动化运行。

在本文中，我将讨论如何使用WebLogic Platform 8.1编写和运行单元测试。

我将说明如何使用JUnit测试所有的WebLogic Platform组件，

不论这些组件是位于服务器容器内部还是外部。

　　我将假定您对单元测试的原理有一些基本的了解，并熟悉JUnit框架。

您可以在JUnit的Web站点 http://www.JUnit.org/上找到关于这两个主题的更多信息。

　　在本文中，我将首先讨论关于如何集成JUnit和WebLogic Workshop的一些基本集成问题。

特别地，我将指出JUnit测试用例在WebLogic Platform应用程序中的位置，并

讨论在WebLogic Workshop中运行这些JUnit测试的各种方式。

接下来，我将讨论如何测试特殊类型的组件。

文件布局
　　因为JUnit测试用例只是标准的Java类，您可以把它们放在您应用程序中几乎所有类型的项目中。

当对没有直接从服务器的虚拟机中公开给外部的组件进行测试时，您的测试类需要在服务器中是可访问的，

这意味着它们应该是构建在您的APP-INF/lib目录中的web项目或Java项目的一部分。

　　注意，有一点很重要，即将您的应用程序部署用于生产时，您很可能不想把您的测试类包括在内。

如果您在单独的测试项目中保留您所有的测试，您可以在编译时把这些项目排除在外。

在WebLogic Workshop中运行JUnit
　　在Workshop中启动JUnit进程有多种不同的方法。

尽管根据您应用程序的设置和使用情况，有一些方法可能多少有些不方便，

但是这与您使用的实际方法没有特别的关系。当然，如果您愿意，您还可以从命令行单独启动JUnit。

　　不论用于启动JUnit的方法如何，它都将在您的主目录中创建一个.Junitsession文件，

以记住您先前已经运行过的测试。

尽管直接运行测试要比首先启动JUnit

然后从组合框选择测试仍然要更加方便一些，

但是因为您不必在首次运行测试类之后重新输入它的名称，

在启动时将测试类名称传递给JUnit就显得没那么重要了。

使用main() 方法和Start 按钮
　　如果在Java项目中保存JUnit测试，

您可以配置WebLogic Workshop以使用Start按钮来运行您的测试。

您必须给测试类一个main()方法，

它负责启动您选择的JUnit运行器。

如果您尚未为项目配置调试器设置，点击Start按钮，

然后Workshop将询问您是否想要把当前类设置为主类。

您也可以转到Tool-->roject Properties…-->[Test project]，

然后从列表中选择Debugger。确保Create new process单选按钮被选中，然后填入您的测试类名称。

　　
假定您想要关闭JUnit的重载类装载器，您的main()方法可能是这个样子：

String[] JUnitArgs = new String[] { "-noloading", TestCase.class.getName() };JUnit.swingui.TestRunner.main( JUnitArgs );

　　假定您让您的类路径设置包括所有的运行时依赖，就可以运行了。这还允许您调试运行在JUnit进程中的代码，所以当测试失败时，进行跟踪是很方便的。

使用外部工具
　　Workshop为通过IDE运行第三方程序提供了一种方法。转到Tools-->IDE Preferences… ，

并在列表中选择Tools 节点。您可以创建一种新的工具配置来运行JUnit。

只要设置用于启动JUnit的完整命令行即可，其中包括一个-classpath参数,

并给它一个可在其中启动进程的可用目录。例如，如果您的应用程序位于c:wlw_app中，

而且您已经在c:ea 目录中安装了WebLogic Workshop，您可以使用c:wlw_app 作为该目录。

假定您要测试的代码位于一个名叫JavaProject的Java项目中，

而您的测试代码位于一个叫做UnitTestProject的单独Java项目中，

而且您已经在叫做somePackage.MainTestSuite的类中定义了一个TestSuite，那么命令格式应该像下面这样：

c:eajdk141_05java.exe -classpath c:wlw_appAPP-INFlibJUnit-3.8.1.jar; c:wlw_appAPP-INFlibUnitTestProject.jar; c:wlw_appAPP-INFlibUnitTestProject.jar; JUnit.swingui.TestRunner -noloading somePackage.MainTestSuite

　　通过在IDE中选择菜单Tools-->External Tools-->[JUnit Tool Name]，您可以很容易地运行JUnit。

使用Ant
　　Ant 为运行JUnit测试提供了另一个可选任务。对Ant的调用可能像下面这样：

<target >
<JUnit haltonerror="yes" fork="true">
　<test />
　<classpath>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/JUnit-3.8.1.jar"/>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/JPFTestProject.jar"/>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/htmlunit-1.2.3.jar"/>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/nekohtml-0.7.7.jar"/>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/commons-logging-1.0.3.jar"/>
　　<pathelement location="＄{app.local.directory}/APP-INF/lib/commons-httpclient-2.0.jar"/> 　　</classpath>
</JUnit>
</target>

　　如果您通过External Tools或者Ant方法来运行JUnit，您仍然可以从 IDE 连接到 JUnit 进程以便调试它。首先，在您的Workshop应用程序中创建或选择一个Java项目。它并不一定需要包含用于您的测试的代码。来到它的Project Properties，并配置调试器设置为连接到一个您选择用于运行JUnit测试的机器端口。然后，启动JUnit进程，将正确的参数传递给它的Java Virtual Machine，以开始监听调试器的连接进程，一般的格式如下（这里的SELECTED_PORT应该用在其上监听调试器的端口来替代）：

-Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,address=SELECTED_PORT,suspend=y,server=y

　　尽管虚拟机将会启动，它不会开始运行测试，直到调试器连接上为止。在IDE中，打开您已经为其配置调试器设置的Java项目中的一份文档，然后点击Start按钮。调试器应该快速连接到该进程，而JUnit应该开始执行测试。

　　您还可以使用Ant生成基于您的测试结果的报告。要想了解关于如何集成Ant和JUnit的更多信息，请查看Ant手册(http://ant.apache.org/manual/index.html)中Ant Tasks主题的Optional Tasks 部分。

禁用 JUnit 重载
　　默认情况下，JUnit的Swing接口使用类装载器在运行测试之前自动重新装载类。这很方便，因为您不需要在重新编译您的类之后重新启动JUnit。然而，我过去曾在某些情况下遇到过有关类装载器的工作方式的问题，它们引起了假的ClassCastExceptions异常和其他我不愿意看到的问题。从脚本、通过Ant或从External Tools运行JUnit时，您可以禁用特殊的类装载器，具体方法是传入-noloading参数。如果您在测试类中使用了main()方法，您可以使用下面的代码达到同样的目的（这里的YourTestClass应该用测试类的名称来替代）：

public static void main( String[] args ) { String[] JUnitArgs = new String[] { "-noloading", YourTestClass.class.getName() }; JUnit.swingui.TestRunner.main( JUnitArgs );}

对外部可测试组件进行单元测试
　　现在，让我们转而讨论如何对WebLogic Platform组件进行单元测试。在讨论中，我将指出内部可测试组件和外部可测试组件的差别，这是我要讨论的第一个话题。对于此处的讨论来说，外部可测试组件是指那些可以从J2EE容器外部（通常是通过HTTP）调用的组件。编写测试时，您的测试用例可以初始化一个到服务器的网络连接，把相应的请求发送给它，然后验证服务器的响应是否正确。

　　Java Page Flows（JPF）、Java Server Pages(JSP）和Servlet
测试Web站点时，您的测试本质上是模拟浏览器从服务器请求一个或一系列页面。根据所涉及的站点，您需要创建正确的HTTP请求，包括相关的URL、头、参数、cookie，等等。一旦服务器做出响应，您将需要检查响应的内容，包括头、HTML本身、客户端的JavaScript和cookie。有两种一般的方法可以完成这项工作。

使用代理
　　首先，您可以使用代理来记录普通web浏览器和服务器之间的交互。在仔细检查页面的正确顺序和手动验证结果的正确性之后，您可以使用上述记录自动回放同样的请求序列，并验证结果是否相同。有许多使用这种方法的包，包括MaxQ (http://maxq.tigris.org/) 和QuickTest (http://www.mercury.com/us/produc ... test-professional/)。

　　这种方法可以非常快速地生成一组测试，但是很不幸它非常脆弱。一旦您修改页面的布局方式，那么测试中断的风险就很高。对于布局不断变化的站点来说，这意味着您很可能不得不定期重新记录您的测试。

对象模型
　　第二种方法是使用一种更加有计划性的技术，即编写测试来构建对象，该对象用于请求HTTP请求、到达服务器并取回代表HTTP响应的对象。尽管这种方法的工作量比使用代理记录会话要大，但是受到HTML布局影响而中断的可能性更小。包括HTTPUnit (http://httpunit.sourceforge.net/)、HTMLUnit (http://htmlunit.sourceforge.net/)和jWebUnit (http://jwebunit.sourceforge.net/A 在内的几个库都提供用于模拟浏览器交互的API。

页面流示例
　　为了举例说明对象模型方法，让我们看一看HTMLUnit。它的API为服务器返回的HTML页面提供一个对象模型。每个请求返回一个HtmlPage，然后您可以查询它的内容。找出页面中的链接之后，您可以模拟一个用户在浏览器中点击它，然后它会返回另一个HtmlPage。类似地，您可以定位页面中的表单、找出特定的字段、设置值，然后提交给服务器。

　　HTMLUnit 使用Rhino JavaScript引擎，让您可以测试页面中的脚本。然而，要注意有一点很重要，即它只支持大多数浏览器支持的JavaScript的一个子集，而且JavaScript的行为总是至少有些依赖于浏览器。

　　为了演示如何测试一个web站点，我使用了WebLogic Workshop 8.1 SP2 SamplesApp中的multipleForms页面流。在下载的代码中，您可以在JPFWebProject项目中找到它。测试包括的流部分有两个文本字段。在其中输入值并点击提交按钮之后，这些值就会显示在后续的页面中。

　　用于这个例子的JUnit 测试用例是{JPFTestProject}/JPFTest.java。如上所述，它有一个main()方法，这样您就可以通过点击IDE中的Start按钮来运行它。测试方法的相关代码如下：

public void testPageFlow() throws Exception {
   WebClient webClient = new WebClient();
   HtmlPage page = (HtmlPage)webClient.getPage(
       new URL( "http://localhost:7001/JPFWebProject/multipleForms/multipleFormsController.jpf" ) );
   HtmlAnchor anchor = page.getFirstAnchorByText( "Show the JSP with blank form fields." );
   HtmlPage page2 = (HtmlPage)anchor.click();
   HtmlForm form = (HtmlForm)page2.getFormByName( "form1" );
   Iterator elements = form.getAllSubmittableElements().iterator();
   int count = 1;
   while( elements.hasNext() ) {
       HtmlElement element = (HtmlElement)elements.next();
       assertTrue( element instanceof HtmlTextInput );
       HtmlTextInput textInput = (HtmlTextInput)element;
       textInput.setValueAttribute( "Value" + count++ );
   }
   HtmlPage page3 = (HtmlPage)form.submit();
   String pageText = page3.asText();
   assertTrue( pageText.indexOf( "Field A = "Value1"" ) != -1 );
   assertTrue( pageText.indexOf( "Field B = "Value2"" ) != -1 );
}

　　测试本身是相当直观的。它首先创建了一个WebClient对象，该对象负责响应Web浏览器。然后，它发出一个请求给页面流的URL所代表的服务器。测试查找带有文本“Show the JSP with blank form fields”的链接。它点击链接，然后在结果页面中定位表单。在通过表单元素进行迭代和给它们赋值之后，测试提交了表单，并在结果页面中查找这些值。

　　如果您要在您的站点上使用NetUI，要小心标签库通常不会为表单元素生成非常简单的名称。通常这没有关系，因为无论是作为开发人员的你，还是最终用户都不需要关心名称，但是当编写测试时，您通常需要给特定元素设置特殊值。通过在浏览器中查看页面的HTML源代码，您总是能够找出一个元素的名称。

Java Web Services（JWS）
　　像基于HTML的组件那样，可以通过HTTP从服务器外部访问Java Web Services。尽管JWS通过其WSDL提供一个更加稳定的API，但它可以使测试变得更加容易，因为输入和输出XML的形状变化的可能性比代表JSP输出的实际HTML要小。从web服务返回的XML没有包含格式信息，而格式信息可以使HTML由于布局影响而发生变化的可能性更大。

　　您可能想考虑从同一个客户端生产平台测试您的web服务。例如，如果您使用WebLogic Workshop在服务器上实现您的web服务，而且始终从在Microsoft .NET中编写的客户端调用它们，您可能会想在.NET中至少编写一些测试，以测试跨平台的交互。

　　假定您想要使用Java编写和运行您的测试，您愿意使用强类型Java对象编写测试，而不是构造一个HTTP请求，然后解析作为结果生成的XML。在8.1中，有两种方法可以创建这类符合JAX-RPC规范的接口。

使用<clientgen>
　　WebLogic Server提供一个<clientgen> Ant 任务。您在描述Web服务的WSDL上指向这个任务，然后告诉它在哪里放置作为结果的Java类。在http://e-docs.bea.com/wls/docs81/webserv/anttasks.html#1080160上可以找到关于如何使用该任务的文档。

使用Test Client
　　您还可以使用WebLogic Workshop Test Client来生成代理JAR。只要点击您的JWS文件上的Start按钮，转到Test Client中的Overview选项卡，然后点击Java Proxy按钮即可。如果您愿意，您可以指定用于在其中放入代理类的包，否则使用默认的weblogic.jws.proxies。

Web服务示例
　　下面给出一个JWS的例子，您可以在{UnitTestingWeb}/jws/JWSToTest.jws中找到它。它定义了两个非常简单的操作。虽然不是很有意思，但是它们对我们要达到的目的来说已然足够。您还可以看到，我们已经从JWS生成了一个WSDL，Workshop将自动使其在接口变化时与JWS保持同步。

public class JWSToTest implements com.bea.jws.WebService {
   static final long serialVersionUID = 1L;
   /** @commonperation */
   public int square( int i ) {
       return i * i;
   }
   /** @commonperation */
   public String hello() {
       return "Hello";
   }
}

　　用于我们的JWS的测试是{JWSTestProject}/JWSTest.java，下面给出它的一部分：

private JWSToTest _proxy;
public void setUp() throws IOException {
_proxy = new JWSToTest_Impl();
}
public void testJWS() throws Exception {
assertEquals( 25, _proxy.getJWSToTestSoap().square( 5 ) );
}

　　就像页面流测试一样，它有一个main()方法，使您可以通过点击Start按钮来运行它。在setUp() 方法（在运行每个单独的测试之前已经调用）中，我们创建了JAX-RPC代理的一个实例。然后，在我们的测试中，我们可以简单地把相关参数传递给方法，然后验证结果是否正确。

　　因为代理是从WSDL生成的，它已经知道用于访问web服务的URL。您可以测试一台运行相同web服务的不同服务器，像阶段测试服务器，具体做法是传递一个不同的URL给代理。在http://java.sun.com/xml/jaxrpc/index.jsp上可以找到关于JAX-RPC代理的更多信息。

Enterprise Java Beans（EJB）
　　把EJB当作外部组件进行测试非常类似于从任何其他客户端调用它。（您还可以把EJB当作内部组件进行测试。更多信息请参见下面的内容。）您需要使用过去习惯用于EJB的基本步骤： (1) 在JNDI中查找home接口， (2)创建一个bean实例，然后 (3) 调用它的方法。

EJB示例
　　我们将测试在{EJBProject}/ejbpackage/SampleSessionBean.ejb找到的无状态会话bean。它定义了一个bean方法doSomethingBoring(), 该方法名副其实，功能是简单地返回一个5：

public class SampleSessionBean extends GenericSessionBean implements SessionBean
{
public void ejbCreate()
　 {
　 }
/** @ejbgen:remote-method */ public int doSomethingBoring()
　 {
　　 return 5;
　　}
}

　　对于这个例子来说，测试用例是{UnitTestProject}/EJBTest.java，下面是它的一小段代码：

private SampleSessionHome lookupHome() throws NamingException {
   Context ctx = getInitialContext();
   // Lookup the bean's home using JNDI
   Object home = ctx.lookup("ejb.SampleSessionRemoteHome");
   return (SampleSessionHome) narrow(home, SampleSessionHome.class);
}
private Object narrow(Object ref, Class c) {
   return PortableRemoteObject.narrow(ref, c);
}
private Context getInitialContext() throws NamingException {
   // Set up the environment properties
   Hashtable h = new Hashtable();
   h.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
   h.put(Context.PROVIDER_URL, "t3://localhost:7001");
   return new InitialContext(h);
}
public void testEJB() throws Exception {
   assertEquals( 5, lookupHome().create().doSomethingBoring() );
}

　　在我们的测试方法中，我们获得了服务器的初始环境，在JNDI中查找home接口，缩小它，调用创建方法，然后调用bean方法。也可以使用Start按钮来运行该测试。

对内部可测试组件进行单元测试
　　一些WebLogic Workshop组件只能从服务器容器内部访问。最明显的例子是控件，只能由框架初始化它，而且只能被包含其他控件、JWS、JPF和JPD类在内的组件使用。因此，为了高效地对这些种类的组件进行单元测试，您的测试需要运行在服务器进程内部。

Cactus
　　针对外部可测试组件运行时，需要把JUnit测试运行为发送HTTP请求给组件的客户端进程。为了在服务器容器内部运行JUnit测试，您需要使用Cactus框架，它是一个免费的开源框架，是Apache Jakarta项目的一部分。Cactus Web站点http://jakarta.apache.org/cactus/index.html 包含了关于JUnit客户端如何连接到服务器，然后使测试运行的详细信息。下面，我将对该机制做一些总结。

　　当编写您想要使用Cactus运行在服务器内部的JUnit测试时，您通常想要扩展ServletTestCase，而非扩展TestCase。另外，您可以让您的suite()方法返回一个ServletTestSuite的实例。当您在您的测试上运行客户端JUnit进程时，它将检测到这是一个服务器端的测试，并发送HTTP请求给您指定的URL。在服务器上，Cactus接收到请求，创建您的测试类的一个实例，然后运行测试。接着，它把结果返回给JUnit客户端进程，该进程显示它们的时候就好像是运行标准的JUnit测试一样。

　　为了使用Cactus，您需要配置您的web应用程序，使其把进入的请求正确地路由给Cactus，编辑web.xml部署描述符可以做到这一点，如下面的代码片断所示：

<servlet>
　 <servlet-name>ServletRedirector</servlet-name>
<servlet-class>org.apache.cactus.server.ServletTestRedirector</servlet-class></servlet>
<servlet-mapping>
　 <servlet-name>ServletRedirector</servlet-name>
　 <url-pattern>/ServletRedirector</url-pattern>
</servlet-mapping>

　　此外，服务器和客户端都需要在它们的运行时类路径中包含JUnit、Cactus和测试类。一般说来，您要把Cactus和JUnit JAR添加到您的应用程序的APP-INF/lib目录。您还可以使用Ant任务把运行您的测试所需的所有类都打包成一个EAR文件。启动JUnit客户端进程时，您需要使用-Dcactus.contextURL=SomeURL来指定Cactus在连接到服务器时应该使用的URL。想要了解更多信息，请参见http://jakarta.apache.org/cactus/integration/ant/task_cactus.html。

Enterprise Java Bean（EJB）
　　如果您调用EJB的生产代码作为EJB实例运行在同一个虚拟机内部，您可以通过使用Cactus使您的测试环境更加近似地匹配您的生产环境。这正如下面的例子所示。

EJB示例
　　在这个例子中，上面用于外部组件测试的EJB测试已经被转换成在服务器内部运行。您可以在{UnitTestingWeb}/ejb/CactusEJBTest.java 上找到演示Cactus的EJB测试。它位于一个web项目内，以便可以部署给服务器，尽管将JAR文件构建到APP-INF/lib目录中的Java项目也将被部署给服务器。这次测试的一个代码片断如下所示：

public class CactusEJBTest extends ServletTestCase
{
   private SampleSessionHome lookupHome() throws NamingException {
       Context ctx = getInitialContext();
       // Lookup the bean's home using JNDI
       Object home = ctx.lookup("ejb.SampleSessionRemoteHome");
       return (SampleSessionHome) narrow(home, SampleSessionHome.class);
   }
   private Object narrow(Object ref, Class c) {
       return PortableRemoteObject.narrow(ref, c);
   }     
   private Context getInitialContext() throws NamingException {
       System.out.println( "getInitialContext()" );
       // Set up the environment properties
       Hashtable h = new Hashtable();
       h.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
       h.put(Context.PROVIDER_URL, "t3://localhost:7001");
      return new InitialContext(h);
   }  
   public void testEJB() throws Exception {
       assertEquals( 5, lookupHome().create().doSomethingBoring() );
   }
...

　　如果您查看该测试的源代码，您会注意到，它实际上与非Cactus的版本完全相同。它扩展的是ServletTestCase ，而非TestCase ，而且有一个不同的类和包名。它还在它的getInitialContext()方法中打印出一些调试输出，这样您就可以了解到，它的确是运行在服务器VM内部，但是没有其他方面的变化。一定要在试着运行测试之前构建和部署应用程序，以确保测试类被真正地部署到服务器。

Java控件（JCS、JCX）
　　控件或许是WebLogic Workshop 8.1中最难测试的组件，因为用户代码不会直接实例化它们。相反，您必须允许框架让支持控件的组件类型（比如JPF）使用控件实例。下面的例子说明了如何做到这一点。

Java控件示例
　　在这个例子中，为了能够接收Cactus请求的Java Page Flow，我把一个抽象基类AbstractUnitTestController包含在内。为了测试控件，您需要使用JUnit测试方法创建一个子类。因为您的测试用例扩展了AbstractUnitTestController，它实际上是一个页面流控制器，所以服务器框架将给您的类一个控件实例来使用。此外，您可以在IDE中使用您已经熟悉的设计工具编写您的测试，这可以简化测试的创建过程。注意，您可以轻松地把这个页面流改编成测试任何为WebLogic Platform应用程序而开发的Java控件。

　　我们将要测试的控件是一个在前面的web服务例子中自动生成的服务控件。该例子还演示了一种测试不需要构建Java客户端代理的web服务的不同方法。Workshop将自动使服务控件与web服务保持同步。这个UnitTestingWeb}/jws/JWSToTestControl.jcx 控件的一个代码片断如下所示：

public interface JWSToTestControl extends com.bea.control.ControlExtension, com.bea.control.ServiceControl {  
   public int square (int i);
   public java.lang.String hello ();
   static final long serialVersionUID = 1L;
}
...

　　测试{UnitTestingWeb}/jws/newpageflow1/ ServiceControlTest.jpf的代码如下所示：

public class ServiceControlTest extends AbstractUnitTestController {
   /** @common:control */
   private jws.JWSToTestControl jwsToTestControl;
/** @jpf:action */
   protected Forward begin() throws ServletException {
       return super.begin();
   }
   public static Test suite() {
       return new ServletTestSuite( ServiceControlTest.class );
   }  
   public void testMethod() {
       Assert.assertEquals( jwsToTestControl.square( 2 ), 4 );
   }
}

　　在这段代码中，有两个元素是使测试在Cactus中正确工作所必需的（余下的部分是标准的JUnit测试代码）。首先，测试需要有一个委托给超类的protected 的begin()方法。因为在WebLogic Workshop 8.1 中，子类不能继承注释，每个测试类需要定义一个jpf:action，以便能够接收HTTP请求。超类可在{UnitTestingWeb}/jwsTestPageFlow/ AbstractUnitTestController.jpf上找到，它将负责处理请求本身和调用相关的测试方法。

　　接下来，测试需要一个suite()方法，用于把类添加给ServletTestSuite。因为类需要是Controller子类，以从框架获得控件实例，这个标签告诉Cactus在服务器上，而不是在客户端JUnit VM内部运行测试。

　　要运行测试，确保您已经构建了应用程序并将其部署到WebLogic Server。然后，使用controlCactus.bat文件启动客户端进程，并使Cactus在服务器中运行测试。和EJB Cactus例子一样，您可能需要在文件中编辑路径，使其指向您机器上的正确目录。

　　要为您自己的控件编写测试，您只需把AbstractUnitTestController.jpf 类添加到您的项目中，然后创建您自己的子类即可。帮助您编辑页面流文档的常规设计工具还可以辅助创建使用控件的测试。

结束语
　　尽管WebLogic Workshop 8.1没有将测试的编写和维护自动化，它没有禁止您编写您的自己的测试。在某些情况下，您可以直接在IDE中轻松地运行您的测试。使用本文中提及的信息，您应该能够快速而轻松地测试您自己的WebLogic Workshop组件。

辅助阅读

JUnit: http://www.JUnit.org/
阅读Ant手册（http://ant.apache.org/manual/index.html）中Ant Tasks主题的Optional Tasks 部分中有关Ant和JUnit集成的信息。
MaxQ: http://maxq.tigris.org/
QuickTest: http://www.mercury.com/us/produc ... ktest-professional/
HTTPUnit: http://httpunit.sourceforge.net/
HTMLUnit: http://htmlunit.sourceforge.net/
jWebUnit: http://jwebunit.sourceforge.net/
JAX-RPC: http://java.sun.com/xml/jaxrpc/index.jsp
Cactus: http://jakarta.apache.org/cactus/index.html
原文出处
http://dev2dev.bea.com/products/ ... icles/eckels_BP.jsp