﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-【永恒的瞬间】  -文章分类-webotx</title><link>http://www.blogjava.net/19851985lili/category/19285.html</link><description>☜GivE mE HapPy ☞




</description><language>zh-cn</language><lastBuildDate>Wed, 28 Feb 2007 03:43:03 GMT</lastBuildDate><pubDate>Wed, 28 Feb 2007 03:43:03 GMT</pubDate><ttl>60</ttl><item><title>JMS（Java Message Service，Java消息服务）</title><link>http://www.blogjava.net/19851985lili/articles/94635.html</link><dc:creator>☜♥☞MengChuChen</dc:creator><author>☜♥☞MengChuChen</author><pubDate>Thu, 18 Jan 2007 06:38:00 GMT</pubDate><guid>http://www.blogjava.net/19851985lili/articles/94635.html</guid><wfw:comment>http://www.blogjava.net/19851985lili/comments/94635.html</wfw:comment><comments>http://www.blogjava.net/19851985lili/articles/94635.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/19851985lili/comments/commentRss/94635.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/19851985lili/services/trackbacks/94635.html</trackback:ping><description><![CDATA[
		<font face="Verdana">  </font>
		<a href="http://www.itisedu.com/phrase/200604261605045.html" target="_new">
				<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">
						<font face="Verdana">JMS</font>
				</b>
		</a>
		<font face="Verdana">（</font>
		<a href="http://www.itisedu.com/phrase/200604261607125.html" target="_new">
				<font face="Verdana">Java Message Service</font>
		</a>
		<font face="Verdana">，</font>
		<a href="http://www.itisedu.com/phrase/200604261600355.html" target="_new">
				<font face="Verdana">Java消息服务</font>
		</a>
		<font face="Verdana">）是一组Java应用</font>
		<a href="http://www.itisedu.com/phrase/200604232224305.html" target="_new">
				<font face="Verdana">程序</font>
		</a>
		<font face="Verdana">接口(Java </font>
		<a href="http://www.itisedu.com/phrase/200604241228185.html" target="_new">
				<font face="Verdana">API</font>
		</a>
		<font face="Verdana">)，它提供创建、发送、接收、读取</font>
		<a href="http://www.itisedu.com/phrase/200603090938465.html" target="_new">
				<font face="Verdana">消息</font>
		</a>
		<font face="Verdana">的服务。由Sun公司和它的合作伙伴设计的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> API定义了一组公共的应用程序接口和相应语法，使得Java程序能够和其他消息</font>
		<a href="http://www.itisedu.com/phrase/200603302222545.html" target="_new">
				<font face="Verdana">组件</font>
		</a>
		<font face="Verdana">进行通信。 </font>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>是一种与厂商无关的 API，用来访问消息收发系统。它</font>
				<a href="http://www.itisedu.com/phrase/200603090857555.html" target="_new">
						<font face="Verdana">类</font>
				</a>
				<font face="Verdana">似于 </font>
				<a href="http://www.itisedu.com/phrase/200604151904545.html" target="_new">
						<font face="Verdana">JDBC</font>
				</a>
				<font face="Verdana"> (Java </font>
				<a href="http://www.itisedu.com/phrase/200604231244235.html" target="_new">
						<font face="Verdana">Database</font>
				</a>
				<font face="Verdana"> Connectivity)：这里，JDBC 是可以用来访问许多不同关系</font>
				<a href="http://www.itisedu.com/phrase/200602271218062.html" target="_new">
						<font face="Verdana">数据库</font>
				</a>
				<font face="Verdana">的 API，而 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 则提供同样与厂商无关的访问方法，以访问消息收发服务。许多厂商目前都支持 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>，包括 IBM 的 MQSeries、BEA的 Weblogic <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> service和 Progress 的 SonicMQ，这只是几个例子。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从一个 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 客户机向另一个 JML 客户机发送消息。消息是 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 中的一种</font>
				<a href="http://www.itisedu.com/phrase/200603051002565.html" target="_new">
						<font face="Verdana">类型</font>
				</a>
				<a href="http://www.itisedu.com/phrase/200603090845215.html" target="_new">
						<font face="Verdana">对象</font>
				</a>
				<font face="Verdana">，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的</font>
				<a href="http://www.itisedu.com/phrase/200603141328355.html" target="_new">
						<font face="Verdana">元数据</font>
				</a>
				<font face="Verdana">组成。消息主体则携带着应用程序的数据或有效负载。根据有效负载的类型来划分，可以将消息分为几种类型，它们分别携带：简单文本 (TextMessage)、可序列化的对象 (ObjectMessage)、属性集合 (MapMessage)、字节流 (BytesMessage)、原始值流 (StreamMessage)，还有无有效负载的消息 (Message)。 </font>
		</p>
		<p>
				<font face="Verdana">      消息收发系统是异步的，也就是说，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 客户机可以发送消息而不必等待回应。比较可知，这完全不同于基于 RPC 的（基于远程过程的）系统，如 <a href="http://www.itisedu.com/phrase/200604241156485.html" target="_new">EJB</a> 1.1、<a href="http://www.itisedu.com/phrase/200604031336425.html" target="_new">CORBA</a> 和 Java <a href="http://www.itisedu.com/phrase/200604281025035.html" target="_new">RMI</a> 的引用实现。在 RPC 中，客户机调用服务器上某个分布式对象的一个方法。在方法调用返回之前，该客户机被阻塞；该客户机在可以执行下一条指令之前，必须等待方法调用结束。在 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 中，客户机将消息发送给一个虚拟通道（主题或队列），而其它 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 客户机则预订或监听这个虚拟通道。当 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 客户机发送消息时，它并不等待回应。它执行发送操作，然后继续执行下一条指令。消息可能最终转发到一个或许多个客户机，这些客户机都不需要作出回应。 </font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>的通用接口集合以异步方式发送或接收消息。异步方式接收消息显然是使用间断网络连接的客户机，诸如移动电话和PDA的最好的选择。另外， <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>采用一种宽松结合方式整合企业系统的方法，其主要的目的就是创建能够使用跨平台数据信息的、可移植的企业级应用程序，而把开发人力解放出来。</font>
		</p>
		<p>
				<font face="Verdana">　　Java消息服务支持两种消息模型：Point-to-Point消息(<a href="http://www.itisedu.com/phrase/200604022225155.html" target="_new">P2P</a>)和发布订阅消息（Publish Subscribe messaging，简称Pu<a href="http://www.itisedu.com/phrase/200604291152445.html" target="_new">b/S</a>ub）。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>规范并不要求供应商同时支持这两种消息模型，但开发者应该熟悉这两种消息模型的优势与缺点。</font>
		</p>
		<p>
				<font face="Verdana">　　P2P消息模型是在点对点之间传递消息时使用。如果应用程序开发者希望每一条消息都能够被处理，那么应该使用P2P消息模型。与Pub/Sub消息模型不同，P2P消息总是能够被传送到指定的位置。</font>
		</p>
		<p>
				<font face="Verdana">　　Pub/Sub模型在一到多的消息广播时使用。如果一定程度的消息传递的不可靠性可以被接受的话，那么应用程序开发者也可以使用Pub/Sub消息模型。换句话说，它适用于所有的消息消费程序并不要求能够收到所有的信息或者消息消费程序并不想接收到任何消息的情况。</font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>通过允许创建持久订阅来简化时间相关性，即使消息预订者未激活也可以接收到消息。此外，使用持久订阅还可通过队列提供灵活性和可靠性，而仍然允许消息被发给许多的接收者。 Topic Subscriber topic Subscriber = topicSession.createDurableSubscriber(topic, subscriptionName); 　　Connection对象表示了到两种消息模型中的任一种的消息系统的连接。服务器端和客户机端对象要求管理创建的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>连接的状态。连接是由Connection Factory创建的并且通过JNDI查寻定位。 //取得用于 P2P的 QueueConnectionFactory QueueConnectionFactory = queueConnectionFactory( ); Context messaging = new InitialContext( ); QueueConnectionFactory = (QueueConnectionFactory) Messaging.lookup(“QueueConnectionFactory”); //取得用于 pub/sub的 TopicConnectionFactory TopicConnectonFactory topicConnectionFactory; Context messaging = new InitialContext(); topicConnectionFactory = (TopicConnectionFactory) messaging.lookup(“TopicConnectionFactory”); 　　注意：用于P2P的代码和用于PublishSubscribe的代码非常相似。</font>
		</p>
		<p>
				<font face="Verdana">　　如果session被标记为transactional的话，确认消息就通过确认和校正来自动地处理。如果session没有标记为 transactional，你有三个用于消息确认的选项。</font>
		</p>
		<p>
				<font face="Verdana">　　· AUTO_ACKNOWLEDGE session将自动地确认收到一则消息。</font>
		</p>
		<p>
				<font face="Verdana">　　· <a href="http://www.itisedu.com/phrase/200604231337375.html" target="_new">CLIENT</a>_ACKNOWLEDGE <a href="http://www.itisedu.com/phrase/200603082208195.html" target="_new">客户端</a>程序将确认收到一则消息，调用这则消息的确认方法。 　　　· DUPS_OK_ACKNOWLEDGE 这个选项命令session“懒散的”确认消息传递，可以想到，这将导致消息提供者传递的一些复制消息可能会出错。这种确认的方式只应当用于消息消费程序可以容忍潜在的副本消息存在的情况。 queueSession = queueConnection.createQueueSession(false, session.AUTO_ACKNOWLEDGE);//P2P topicSession = topicConnection.createTopicSession(false, session.AUTO_ACKNOWLEDGE); //Pub-Sub</font>
		</p>
		<p>
				<font face="Verdana">　　注意：在本例中，一个session目的从连结中创建，非值指出session是non-transactional的，并且 session将自动地确认收到一则消息。</font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>现在有两种传递消息的方式。标记为NON_PERSISTENT的消息最多投递一次，而标记为PERSISTENT的消息将使用暂存后再转送的机理投递。如果一个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>服务离线，那么持久性消息不会丢失但是得等到这个服务恢复联机时才会被传递。所以默认的消息传递方式是非持久性的。即使使用非持久性消息可能降低内务和需要的存储器，并且这种传递方式只有当你不需要接收所有的消息时才使用。</font>
		</p>
		<p>
				<font face="Verdana">　　虽然 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>规范并不需要<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>供应商实现消息的优先级路线，但是它需要递送加快的消息优先于普通级别的消息。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>定义了从0到9的优先级路线级别，0是最低的优先级而9则是最高的。更特殊的是0到4是正常优先级的变化幅度，而5到9是加快的优先级的变化幅度。举例来说： topicPublisher.publish (message, DeliveryMode.PERSISTENT, 8, 10000); //Pub-Sub 或 queueSender.send(message, DeliveryMode.PERSISTENT, 8, 10000);//P2P 　　这个代码片断，有两种消息模型，映射递送方式是持久的，优先级为加快型，生存周期是10000 (以毫秒<a href="http://www.itisedu.com/phrase/200604231331545.html" target="_new">度量</a> )。如果生存周期设置为零，这则消息将永远不会过期。当消息需要时间限制否则将使其无效时，设置生存周期是有用的。</font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收以一些不同形式的数据，提供现有消息格式的一些级别的兼容性。</font>
		</p>
		<p>
				<font face="Verdana">　　· StreamMessage -- Java原始值的数据流 </font>
		</p>
		<p>
				<font face="Verdana">　　· MapMessage--一套名称-值对</font>
		</p>
		<p>
				<font face="Verdana">　　· TextMessage--一个字符串对象</font>
		</p>
		<p>
				<font face="Verdana">　　· ObjectMessage--一个序列化的 Java对象</font>
		</p>
		<p>
				<font face="Verdana">　　· BytesMessage--一个未解释字节的数据流</font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>应用程序接口提供用于创建每种类型消息和设置荷载的方法例如，为了在一个队列创建并发送一个TextMessage实例，你可以使用下列语句： TextMessage message = queueSession.createTextMessage(); message.setText(textMsg); 　　以异步方式接收消息，需要创建一个消息监听器然后注册一个或多个使用MessageConsumer的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> MessageListener接口。会话(主题或队列)负责产生某些消息，这些消息被传送到使用onMessage方法的监听者那里。 import javax.<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>.*; public <a href="http://www.itisedu.com/phrase/200604231359565.html" target="_new">class</a> ExampleListener implements MessageListener { //把消息强制转化为TextMessage格式 public void onMessage(Message message) { TextMessage textMsg = null; // 打开并处理这段消息 } } 　　当我们创建QueueReceiver和TopicSubscriber时，我们传递消息选择器字符串： //P2P QueueReceiver QueueReceiver receiver; receiver = session.createReceiver(queue, selector); //Pub-Sub TopicSubscriber TopicSubscriber subscriber; subscriber = session.createSubscriber(topic, selector); 　　为了启动消息的交付，不论是Pub/Sub还是P2P，都需要调用start方法。 TopicConnection.start( ); //pub-sub QueueConnection.start( ); //P2P TopicConnection.start ( );// pub-sub QueueConnection.start ( );// P2P</font>
		</p>
		<p>
				<font face="Verdana">　　当一条消息被捕捉时，这条消息做为一条必须被强制转化为适当消息类型的普通Message对象到达。这是一个被用来提取或打开消息内容的getter方法。下列代码片段使用StreamMessage类型。 private void unPackMessage (Message message) { String eName; String position; double rate; StreamMessage message; Message = session.createStreamMessage( ); //注意下面的代码必须按照我给出的顺序书写 message.writeString(eName); message.writeString(position); message.writeDouble(rate); //实现处理消息的必要的程序逻辑 }</font>
		</p>
		<p>
				<font face="Verdana">　　停止消息的传递，无论是Pub/Sub还是P2P，都调用stop方法。 TopicConnection.start( ); //pub-sub QueueConnection.start( ); //P2P TopicConnection.start ( );// pub-sub QueueConnection.start ( );// P2P 　　其他的<a href="http://www.itisedu.com/phrase/200603091447335.html" target="_new">J2EE</a>组件--<a href="http://www.itisedu.com/phrase/200603091005185.html" target="_new">servlet</a>或EJB--可以当作消息生产者；然而，它们可能只能同步操作，这可能是因为它们的请求-应答的性质决定的。虽然<a href="http://www.itisedu.com/phrase/200604231236585.html" target="_new">XML</a>目前还不是被支持的消息类型，发送一个XML<a href="http://www.itisedu.com/phrase/200602282323195.html" target="_new">文件</a>和创建一条文本类型消息以及把XML文件添加到消息的有效负载都一样简单，都是以非专有的方式传送数据。值得注意的是，一些<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>供应厂商已经提供了可用的XML消息类型。但是使用非标准的消息类型可能会出现可移植性问题。 String reportData; //reportData内容为XML 文档 TextMessage message; message = session.createTextMessage(); message.setText (reportData);</font>
		</p>
		<p>
				<font face="Verdana">　　消息驱动组件(MDB)是一个当消息到达时被容器调用的异步消息消费程序。和entity和session EJB不同，MDB没有本地和远程接口并且是匿名的；它们对于客户是不可见的。MDB是<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>系统的一部分，作为消费者实现服务器上的商业逻辑程序。 一个客户程序可能通过使用JNDI定位一个与MDB相关联的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>。 例如： Context initialContext = new InitialContext(); Queue reportInfoQueue = (javax.<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>.Queue)initialContext.lookup (“java:comp/env/<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>/reportInfoQueue”); 　　MDB是由Bean类和相应的XML部署描述符组成。 Bean 类实现MessageDriveBean 接口： import javax.ejb.*; import <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>.Message.*; public interface MessageDriveBean { public void ejbCreate(); public void ejbRemove(); public void setMessageDrivenContext(MessageDrivenContext ctx); } 　　消息监听器接口： import javax.<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>.*; public interface MessageListener { public void onMessage( ); }</font>
		</p>
		<p>
				<font face="Verdana">　　部署描述符 ＜!DOCTYPE ejb-jar PUBLIC "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN" "http://java.sun.com/j2ee/dtds/ejb-jar_2_0.dtd"＞ ＜ejb-jar＞ ＜enterprise-beans＞ ＜message-driven＞ ＜ejb-name＞MDB＜/ejb-name＞ ＜ejb-class＞MDB＜/ejb-class＞ ＜transaction-type＞Container＜/transaction-type＞ ＜message-driven-destination＞ ＜<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>-destination-type＞javax.<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>.Queue＜/<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">jms</b>-destination-type＞ ＜/message-driven-destination＞ ＜security-identity＞ ＜run-as-specified-identity＞ ＜role-name＞everyone＜/role-name＞ ＜/run-as-specified-identity＞ ＜/security-identity＞ ＜/message-driven＞ ＜/enterprise-beans＞ ＜/ejb-jar＞</font>
		</p>
		<p>
				<font face="Verdana"> 　　既然我们现在已经有了一些基本的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>知识，那么我们可以使用<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>做什么呢？任何事情都可以。</font>
		</p>
		<p>
				<font face="Verdana"> 　　例如，分别用于销售、库存、客户服务和账目处理的系统。这些部门之间的系统很可能已经存在了很长时间，这些处理要求把事务移动到系统中去，这并不是一个小的工作。这就是消息服务适用的地点。</font>
		</p>
		<p>
				<font face="Verdana">　　当售货员完成销售的时候，一条消息被发给库存系统；一旦订单消息发送给收发货人员，就可以按照订单出货了。当订单成功地发货，系统将通知顾客服务和会计系统这个订单已经成功的交易了。所有对应的每个<a href="http://www.itisedu.com/phrase/200604161433025.html" target="_new">子系统</a>都自动地根据收到的消息进行更新。</font>
		</p>
		<p>
				<font face="Verdana">　　<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>一般都不是用来整合一个系统，而是整合许多可能参与消息驱动环境的系统。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>是一个用于开发和集成企业应用程序的重要的工具。因为许多公司都有以前遗留下来的系统和新近开发的系统综合起来的系统，消息的使用是整合整个企业的重要的步骤。 </font>
		</p>
		<p>
				<font face="Verdana">　　 </font>
		</p>
		<p>
				<font face="Verdana">
						<strong>
								<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>接口描述</strong>
				</font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 支持两种消息类型PTP 和Pub/Sub，分别称作：PTP Domain 和Pub/Sub Domain，这两种接口都继承统一的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Parent 接口，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 主要接口如下所示：</font>
		</p>
		<font face="Verdana">
				<p align="center">
				</p>
				<table class="table" border="1">
						<tbody>
								<tr>
										<td class="th" width="138">
												<b>
														<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Parent</b>  </td>
										<td class="th" width="210"> <b>PTPDomain</b></td>
										<td class="th" width="214">
												<b>Pub/Sub Domain</b>
										</td>
								</tr>
								<tr>
										<td class="td" width="138">ConnectionFactory</td>
										<td class="td" width="210">QueueConnectionFactory</td>
										<td class="td" width="214">TopicConnectionFactory</td>
								</tr>
								<tr>
										<td class="td" width="138">Connection</td>
										<td class="td" width="210">QueueConnection</td>
										<td class="td" width="214">TopicConnection</td>
								</tr>
								<tr>
										<td class="td" width="138">Destination</td>
										<td class="td" width="210">Queue</td>
										<td class="td" width="214">Topic</td>
								</tr>
								<tr>
										<td class="td" width="138">Session</td>
										<td class="td" width="210">QueueSession</td>
										<td class="td" width="214">TopicSession</td>
								</tr>
								<tr>
										<td class="td" width="138">MessageProducer</td>
										<td class="td" width="210">QueueSender</td>
										<td class="td" width="214">TopicPublisher</td>
								</tr>
								<tr>
										<td class="td" width="138">MessageConsumer</td>
										<td class="td" width="210">QueueReceiver,QueueBrowser</td>
										<td class="td" width="214">TopicSubscriber</td>
								</tr>
						</tbody>
				</table>
		</font>
		<p>
				<font face="Verdana">      以下是对这些接口的简单描述：<br />    ConnectionFactory ：连接工厂，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 用它创建连接<br />    Connection ：<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 客户端到<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider 的连接<br />    Destination ：消息的目的地<br />    Session： 一个发送或接收消息的<a href="http://www.itisedu.com/phrase/200603091754305.html" target="_new">线程</a><br />    MessageProducer： 由Session 对象创建的用来发送消息的对象<br />    MessageConsumer： 由Session 对象创建的用来接收消息的对象</font>
		</p>
		<p>
				<font face="Verdana">
				</font> </p>
		<p>
				<font face="Verdana">
						<strong>
								<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b>消息模型</strong>
				</font>
		</p>
		<p>
				<font face="Verdana">
						<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 消息由以下几部分组成：消息头，属性，消息体。</font>
		</p>
		<p>
				<font face="Verdana">    <strong>消息头(Header)</strong> - 消息头包含消息的识别信息和路由信息，消息头包含一些标准的属性如：JMSDestination,JMSMessageID 等。 </font>
		</p>
		<p align="center">
				<font face="Verdana">
						<table class="table" border="1">
								<tbody>
										<tr>
												<td class="th" width="150">
														<b>
																<i>消息头</i>
														</b>
												</td>
												<td class="th" width="515">
														<b>
																<i>由谁设置</i>
														</b>
												</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSDestination</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSDeliveryMode</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSExpiration</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSPriority</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSMessageID</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSTimestamp</td>
												<td class="td" width="515">send 或 publish 方法</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSCorrelationID</td>
												<td class="td" width="515">客户</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSReplyTo</td>
												<td class="td" width="515">客户</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSType</td>
												<td class="td" width="515">客户</td>
										</tr>
										<tr>
												<td class="td" width="150">JMSRedelivered</td>
												<td class="td" width="515">
														<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider</td>
										</tr>
								</tbody>
						</table>
				</font>
		</p>
		<p>
				<font face="Verdana">
						<br />      <strong>属性(Properties)</strong> - 除了消息头中定义好的标准属性外，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 提供一种机制增加新属性到消息头中，这种新属性包含以下几种：<br />    1. 应用需要用到的属性;<br />    2. 消息头中原有的一些可选属性;<br />    3. <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider 需要用到的属性。<br />    标准的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 消息头包含以下属性： <br />   JMSDestination --消息发送的目的地 <br />   JMSDeliveryMode --传递<a href="http://www.itisedu.com/phrase/200603061709535.html" target="_new">模式</a>， 有两种模式： PERSISTENT 和NON_PERSISTENT，PERSISTENT 表示该消息一定要被送到目的地，否则会导致应用错误。NON_PERSISTENT 表示偶然丢失该消息是被允许的，这两种模式使开发者可以在消息传递的可靠性和吞吐量之间找到平衡点。<br />   JMSMessageID 唯一识别每个消息的标识，由<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider 产生。<br />   JMSTimestamp 一个消息被提交给<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider 到消息被发出的时间。<br />   JMSCorrelationID 用来连接到另外一个消息，典型的应用是在回复消息中连接到原消息。<br />   JMSReplyTo 提供本消息回复消息的目的地址。<br />   JMSRedelivered 如果一个客户端收到一个设置了JMSRedelivered 属性的消息，则表示可能该客户端曾经在早些时候收到过该消息，但并没有签收(acknowledged)。<br />   JMSType 消息类型的识别符。<br />   JMSExpiration 消息过期时间，等于QueueSender 的send 方法中的timeToLive 值或TopicPublisher 的publish 方法中的timeToLive 值加上发送时刻的GMT 时间值。如果timeToLive值等于零，则JMSExpiration 被设为零，表示该消息永不过期。如果发送后，在消息过期时间之后消息还没有被发送到目的地，则该消息被清除。<br />   JMSPriority 消息优先级，从0-9 十个级别，0-4 是普通消息，5-9 是加急消息。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> 不要求<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> Provider 严格按照这十个优先级发送消息，但必须保证加急消息要先于普通消息到达。</font>
		</p>
		<p>    <strong>消息体(Body) </strong>- <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMS</b> API 定义了5种消息体格式，也叫消息类型，你可以使用不同形式发送接收数据并可以兼容现有的消息格式，下面描述这5种类型： </p>
		<p align="center">
		</p>
		<table class="table" border="1">
				<tbody>
						<tr>
								<td class="th" width="150">
										<b>
												<i>消息类型</i>
										</b>
								</td>
								<td class="th" width="515">
										<b>
												<i>消息体</i>
										</b>
								</td>
						</tr>
						<tr>
								<td class="td" width="150">TextMessage</td>
								<td class="td" width="515">java.lang.String对象，如xml文件内容</td>
						</tr>
						<tr>
								<td class="td" width="150">MapMessage</td>
								<td class="td" width="515">名/值对的集合，名是String对象，值类型可以是Java任何基本类型</td>
						</tr>
						<tr>
								<td class="td" width="150">BytesMessage</td>
								<td class="td" width="515">字节流</td>
						</tr>
						<tr>
								<td class="td" width="150">StreamMessage</td>
								<td class="td" width="515">Java中的输入输出流</td>
						</tr>
						<tr>
								<td class="td" width="150">ObjectMessage</td>
								<td class="td" width="515">Java中的可序列化对象</td>
						</tr>
						<tr>
								<td class="td" width="150">Message</td>
								<td class="td" width="515">没有消息体，只有消息头和属性。</td>
						</tr>
				</tbody>
		</table>
		<div class="para">下例演示创建并发送一个TextMessage到一个队列： </div>
		<p align="center"> </p>
		<div class="programlisting" style="WIDTH: 674px; HEIGHT: 29px">
				<blockquote>
						<pre>TextMessage message = queueSession.createTextMessage();
message.setText(msg_text); // msg_text is a String
queueSender.send(message);</pre>
				</blockquote>
		</div>
		<p align="center"> </p>
		<div class="para">下例演示接收消息并转换为合适的消息类型： </div>
		<p align="center"> </p>
		<div class="programlisting" style="WIDTH: 674px; HEIGHT: 29px">
				<blockquote>
						<pre>Message m = queueReceiver.receive();
if (m instanceof TextMessage) {
	TextMessage message = (TextMessage) m;
	System.out.println("Reading message: " + message.getText());
} else {
	// Handle error
}</pre>
				</blockquote>
		</div>
<img src ="http://www.blogjava.net/19851985lili/aggbug/94635.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/19851985lili/" target="_blank">☜♥☞MengChuChen</a> 2007-01-18 14:38 <a href="http://www.blogjava.net/19851985lili/articles/94635.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>JMX</title><link>http://www.blogjava.net/19851985lili/articles/94633.html</link><dc:creator>☜♥☞MengChuChen</dc:creator><author>☜♥☞MengChuChen</author><pubDate>Thu, 18 Jan 2007 06:36:00 GMT</pubDate><guid>http://www.blogjava.net/19851985lili/articles/94633.html</guid><wfw:comment>http://www.blogjava.net/19851985lili/comments/94633.html</wfw:comment><comments>http://www.blogjava.net/19851985lili/articles/94633.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/19851985lili/comments/commentRss/94633.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/19851985lili/services/trackbacks/94633.html</trackback:ping><description><![CDATA[
		<font face="Verdana"> </font>
		<a href="http://www.itisedu.com/phrase/200604261751455.html" target="_new">
				<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">
						<font face="Verdana">JMX</font>
				</b>
		</a>
		<font face="Verdana">（</font>
		<a href="http://www.itisedu.com/phrase/200604262159065.html" target="_new">
				<font face="Verdana">Java Management Extensions</font>
		</a>
		<font face="Verdana">，即</font>
		<a href="http://www.itisedu.com/phrase/200604262146095.html" target="_new">
				<font face="Verdana">Java管理扩展</font>
		</a>
		<font face="Verdana">）是一个为应用</font>
		<a href="http://www.itisedu.com/phrase/200604232224305.html" target="_new">
				<font face="Verdana">程序</font>
		</a>
		<font face="Verdana">、设备、系统等植入管理功能的</font>
		<a href="http://www.itisedu.com/phrase/200603061723295.html" target="_new">
				<font face="Verdana">框架</font>
		</a>
		<font face="Verdana">。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>可以跨越一系列异构</font>
		<a href="http://www.itisedu.com/phrase/200602281634075.html" target="_new">
				<font face="Verdana">操作系统</font>
		</a>
		<font face="Verdana">平台、系统</font>
		<a href="http://www.itisedu.com/phrase/200603122156385.html" target="_new">
				<font face="Verdana">体系结构</font>
		</a>
		<font face="Verdana">和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用。 </font>
		<p>
				<font face="Verdana">      Java管理扩展<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>(Java Management Extensions)是一个为应用程序植入管理功能的框架。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。 </font>
		</p>
		<p>
				<font face="Verdana">      Java管理扩展<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的前身是JMAPI。 </font>
		</p>
		<p>
				<font face="Verdana">      Java管理扩展<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>致力于解决分布式<a href="http://www.itisedu.com/phrase/200604022111095.html" target="_new">系统管理</a>的问题，因此，能够适合于各种不同的环境是非常重要的。为了能够利用功能强大的Java计算环境解决这一的问题，Sun公司扩充了Java基础<a href="http://www.itisedu.com/phrase/200603090857555.html" target="_new">类</a>库，开发了专用的管理类库。 </font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>是一种<a href="http://www.itisedu.com/phrase/200604111116455.html" target="_new">应用编程接口</a>，可扩充<a href="http://www.itisedu.com/phrase/200603090845215.html" target="_new">对象</a>和方法的集合体，可以用于跨越一系列不同的异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用它提供了用户界面指导、Java类和开发集成系统、网络及网络管理应用的规范。 </font>
		</p>
		<p>
				<font face="Verdana">      管理对象是<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>应用程序的核心。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>结构包括：支持Java的Web浏览器用户接口，管理运行模块ARM(Admin Runtime Module)和应用。这三个部件之间通过<a href="http://www.itisedu.com/phrase/200604281025035.html" target="_new">RMI</a>（<a href="http://www.itisedu.com/phrase/200604281036245.html" target="_new">Remote Method Invocation</a>）进行通信。这里需要说明的是，RMI是使得一个<a href="http://www.itisedu.com/phrase/200604261004365.html" target="_new">Java虚拟机</a>（<a href="http://www.itisedu.com/phrase/200604261007235.html" target="_new">JVM</a>）上运行的程序可以调用远程服务器上另一个JVM总的对象。 </font>
		</p>
		<p>
				<font face="Verdana">      用户接口用来发布管理操作，这些操作可以间接的通过浏览器或通过单独的应用程序来激发。管理运行模块用来给应用提供实例化的管理对象。它包括Agent对象接口，通知接口和被管数据接口。应用指的是那些被管设备单元。 </font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>是一个完整的网络管理应用程序开发环境，它同时提供了：厂商需要收集的完整的特性清单，可生成资源清单表格，图形化的用户接口；访问SNMP的网络<a href="http://www.itisedu.com/phrase/200604241228185.html" target="_new">API</a>；主机间<a href="http://www.itisedu.com/phrase/200604241405415.html" target="_new">远程过程调用</a>；<a href="http://www.itisedu.com/phrase/200602271218062.html" target="_new">数据库</a>访问方法。 </font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>这一轻型的管理基础结构，价值在于对被管理资源的服务实现了抽象，提供了低层的基本类集合，开发人员在保证大多数的公共管理类的完整性和一致性的前提下，进行扩展以满足特定网络管理应用的需要。 </font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>注重于构造管理工具的<a href="http://www.itisedu.com/phrase/200604232134205.html" target="_new">软件</a>框架，并尽量采用已成熟的技术。</font>
		</p>
		<p>
				<font face="Verdana">      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>可以用来管理网络，设备，应用程序等资源，当前规范为1.2版。</font>
		</p>
		<p>
				<font face="Verdana">
						<strong>一、Java管理扩展<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的优点</strong>
				</font>
		</p>
		<p>
				<font face="Verdana">      1：可以非常容易的使应用程序具有被管理的功能<br />      2：提供具有高度伸缩性的<a href="http://www.itisedu.com/phrase/200604241328115.html" target="_new">架构</a><br />每个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b> Agent服务可以很容易的放入到Agent中，每个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的实现都提供几个核心的Agent服务，你也可以自己编写服务，服务可以很容易的部署，取消部署。 <br />      3：主要提供接口，允许有不同的实现 </font>
		</p>
		<font face="Verdana">
				<p>
						<br />
						<strong>二、Java管理扩展<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的体系结构</strong>
				</p>
				<p align="center">
						<font face="Verdana">
								<img src="http://www.itisedu.com/manage/Upload/image/2006426212253576.jpg" border="0" />
						</font>
				</p>
				<p align="center">
						<font face="Verdana">
								<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>框架 </font>
				</p>
				<p>      1)设备层（Instrumentation Level）：主要定义了信息模型。在<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>中，各种管理对象以管理<a href="http://www.itisedu.com/phrase/200604161439595.html" target="_new">构件</a>的形式存在，需要管理时，向MBean服务器进行注册。该层还定义了通知机制以及一些辅助<a href="http://www.itisedu.com/phrase/200603141328355.html" target="_new">元数据</a>类。 <br />      2)代理层（Agent Level）：主要定义了各种服务以及通信模型。该层的核心是一个MBean服务器，所有的管理构件都需要向它注册，才能被管理。注册在MBean服务器上管理构件并不直接和远程应用程序进行通信，它们通过协议适配器和连接器进行通信。而协议适配器和连接器也以管理构件的形式向MBean服务器注册才能提供相应的服务。 <br />      3)分布服务层（Distributed Service Level）：主要定义了能对代理层进行操作的管理接口和构件，这样管理者就可以操作代理。然而，当前的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范并没有给出这一层的具体规范。 <br />      4)附加管理协议API：定义的API主要用来支持当前已经存在的网络管理协议，如SNMP、TMN、CIM/WBEM等。 </p>
				<p>
						<br />      1．2 设备层（Instrumentation Level）<br />      该层定义了如何实现<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>管理资源的规范。一个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>管理资源可以是一个Java应用、一个服务或一个设备，它们可以用Java开发，或者至少能用Java进行包装，并且能被置入<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>框架中，从而成为<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的一个管理构件(Managed Bean)，简称MBean。管理构件可以是标准的，也可以是动态的，标准的管理构件遵从JavaBeans构件的<a href="http://www.itisedu.com/phrase/200603061631585.html" target="_new">设计模式</a>；动态的管理构件遵从特定的接口，提供了更大的灵活性。 </p>
				<p>      该层还定义了通知机制以及实现管理构件的辅助元数据类。 </p>
				<p>
						<br />      1．2．1 管理构件（MBean）<br />      在<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范中，管理构件定义如下：它是一个能代表管理资源的Java对象，遵从一定的设计<a href="http://www.itisedu.com/phrase/200603061709535.html" target="_new">模式</a>，还需实现该规范定义的特定的接口。该定义了保证了所有的管理构件以一种标准的方式来表示被管理资源。 </p>
				<p>      管理接口就是被管理资源暴露出的一些信息，通过对这些信息的修改就能控制被管理资源。一个管理构件的管理接口包括： <br />      1)能被接触的属性值； <br />      2)能够执行的操作； <br />      3)能发出的通知事件； <br />      4)管理构件的构建器。 </p>
				<p>      管理构件通过公共的方法以及遵从特定的设计模式封装了属性和操作，以便暴露给管理应用程序。例如，一个只读属性在管理构件中只有Get方法，既有Get又有Set方法表示是一个可读写的属性。 </p>
				<p>      其余的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的构件，例如<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理提供的各种服务，也是作为一个管理构件注册到代理中才能提供相应的服务。 </p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>对管理构件的存储位置没有任何限制，管理构件可以存储在运行<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理的Java虚拟机的类路径的任何位置，也可以从网络上的任何位置导入。 </p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>定义了四种管理构件：标准、动态、开放和模型管理构件。每一种管理构件可以根据不同的环境需要进行制定。 </p>
				<p>      1.标准管理构件 </p>
				<p>      标准管理构件的设计和实现是最简单的，它们的管理接口通过方法名来描述。标准管理构件的实现依靠一组命名规则，称之为设计模式。这些命名规则定义了属性和操作。检查标准管理构件接口和应用设计模式的过程被称为内省（Introspection）[22]。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理通过内省来查看每一个注册在MBean 服务器上的管理构件的方法和超类，看它是否遵从一定设计模式，决定它是否代表了一个管理构件，并辨认出它的属性和操作。 </p>
				<p>      2.动态管理构件 </p>
				<p>      动态管理构件提供了更大的灵活性，它可以在运行期暴露自己的管理接口。它的实现是通过实现一个特定的接口DynamicMBean（如下图）。 </p>
				<p align="center">
						<img src="http://www.itisedu.com/manage/Upload/image/2006426212348613.jpg" border="0" />
						<br /> </p>
				<p>
						<br />      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理通过getMBeanInfo方法来获取该动态管理构件暴露的管理接口，该方法返回的对象是MbeanInfo类的实例，包含了属性和操作的签名。由于该方法的调用是发生在动态管理构件向MBean服务器注册以后，因此管理接口是在运行期获取的。不同于标准管理构件，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理不需要通过内省机制来确定动态管理构件的管理接口。由于DynamicMBean的接口是不变的，因此可以屏蔽实现细节。由于这种在运行期获取管理接口的特性，动态管理构件提供了更大的灵活性。 </p>
				<p>      3.开放管理构件 </p>
				<p>      开放管理构件是一种专门化的动态管理构件，其中所有的与该管理构件相关的参数、返回<a href="http://www.itisedu.com/phrase/200603051002565.html" target="_new">类型</a>和属性都围绕一组预定义的数据类型（String、Integer、Float 等）来建立，并且通过一组特定的接口来进行自我描述。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理通过获得一个OpenMBeanInfo对象来获取开放管理构件的管理接口，OpenMBeanInfo是MbeanInfo的子类。 </p>
				<p>      4.模型管理构件 </p>
				<p>      模型管理构件也是一种专门化的动态管理构件。它是预制的、通用的和动态的 MBean 类，已经包含了所有必要缺省行为的实现，并允许在运行时添加或覆盖需要定制的那些实现。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范规定该类必须实现为javax.management.modelmbean.RequiredModelMBean，管理者要做的就是实例化该类，并配置该构件的默认行为并注册到<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理中，即可实现对资源的管理。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理通过获得一个ModelMBeanInfo对象来获取管理接口。 </p>
				<p>      模型管理构件具有以下新的特点[23]： <br />      1)持久性 <br />      定义了持久机制，可以利用Java的序列化或<a href="http://www.itisedu.com/phrase/200604151904545.html" target="_new">JDBC</a>来存储模型MBean的状态。 <br />      2)通知和日志功能 <br />      能记录每一个发出的通知，并能自动发出属性变化通知。 <br />      3)属性值缓存 <br />      具有缓存属性值的能力。 </p>
				<p>
						<br />      1．2．2 通知模型<br />      一个管理构件提供的管理接口允许代理对其管理资源进行控制和配置。然而，对管理复杂的分布式系统来说，这些接口只是提供了一部分功能。通常，管理应用程序需要对状态变化或者当特别情况发生变化时作出反映。 </p>
				<p>      为此，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>定义了通知模型。通知模型仅仅涉及了在同一个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理中的管理构件之间的事件传播。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>通知模型依靠以下几个部分： <br />      1)Notification，一个通用的事件类型，该类标识事件的类型，可以被直接使用，也可以根据传递的事件的需要而被扩展。 <br />      2)NotificationListener接口，接受通知的对象需实现此接口。 <br />      3)NotificationFilter接口，作为通知过滤器的对象需实现此接口，为通知监听者提供了一个过滤通知的过滤器。 <br />      4)NotificationBroadcaster接口，通知发送者需实现此接口，该接口允许希望得到通知的监听者注册。 </p>
				<p>      发送一个通用类型的通知，任何一个监听者都会得到该通知。因此，监听者需提供过滤器来选择所需要接受的通知。 </p>
				<p>      任何类型的管理构件，标准的或动态的，都可以作为一个通知发送者，也可以作为一个通知监听者，或两者都是。 </p>
				<p>
						<br />      1．2．3 辅助元数据类<br />      辅助元数据类用来描述管理构件。辅助元数据类不仅被用来内省标准管理构件，也被动态管理构件用来进行自我描述。这些类根据属性、操作、构建器和通告描述了管理接口。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理通过这些元数据类管理所有管理构件，而不管这些管理构件的类型。 </p>
				<p>      部分辅助元类如下： <br />      1)MBeanInfo--包含了属性、操作、构建器和通知的信息。 <br />      2)MBeanFeatureInfo--为下面类的超类。 <br />      3)MBeanAttributeInfo--用来描述管理构件中的属性。 <br />      4)MBeanConstructorInfo--用来描述管理构件中的构建器。 <br />      5)MBeanOperationInfo--用来描述管理构件中的操作。 <br />      6)MBeanParameterInfo--用来描述管理构件操作或构建器的参数。 <br />      7)MBeanNotificationInfo--用来描述管理构件发出的通知。 </p>
				<p>
						<br />      1．3 代理层<br />      代理层是一个运行在Java虚拟机上的管理实体，它活跃在管理资源和管理者之间，用来直接管理资源，并使这些资源可以被远程的管理程序所控制。代理层由一个MBean服务器和一系列处理被管理资源的服务所组成。下图表示了代理层的组成： </p>
				<p align="center">
						<img src="http://www.itisedu.com/manage/Upload/image/2006426212444462.jpg" border="0" />
						<br /> </p>
				<p> </p>
				<p>      1．3．1 MBean服务器<br />      Mbean服务器为代理层的核心，设备层的所有管理构件都在其注册，管理者只用通过它才能访问管理构件。 <br />      管理构件可以通过以下三种方法实例化和注册： <br />      1)通过另一个管理构件 <br />      2)管理代理本身 <br />      3)远程应用程序 <br />      注册一个管理构件时，必须提供一个唯一的对象名。管理应用程序用这个对象名进行标识管理构件并对其操作。这些操作包括： <br />      1)发现管理构件的管理接口 <br />      2)读写属性值 <br />      3)执行管理构件中定义的操作 <br />      4)获得管理构件发出的通告 <br />      5)基于对象名和属性值来查询管理构件 </p>
				<p>
						<br />      1．3．2 协议适配器和连接器<br />      MBean服务器依赖于协议适配器和连接器来和运行该代理的Java虚拟机之外的管理应用程序进行通信。协议适配器通过特定的协议提供了一张注册在MBean服务器的管理构件的<a href="http://www.itisedu.com/phrase/200603141659315.html" target="_new">视图</a>。例如，一个HTML适配器可以将所有注册过的管理构件显示在Web 页面上。不同的协议，提供不同的视图。 </p>
				<p>      连接器还必须提供管理应用一方的接口以使代理和管理应用程序进行通信，即针对不同的协议，连接器必须提供同样的远程接口来封装通信过程。当远程应用程序使用这个接口时，就可以通过网络透明的和代理进行交互，而忽略协议本身。 </p>
				<p>      适配器和连接器使MBean服务器与管理应用程序能进行通信。因此，一个代理要被管理，它必须提供至少一个协议适配器或者连接器。面临多种管理应用时，代理可以包含各种不同的协议适配器和连接器。 </p>
				<p>      当前已经实现和将要实现的协议适配器和连接器包括： <br />      1)RMI连接器 <br />      2)SNMP协议适配器 <br />      3)IIOP协议适配器 <br />      4)HTML协议适配器 <br />      5)HTTP连接器 </p>
				<p>
						<br />      1．3．3 代理服务<br />      代理服务可以对注册的管理构件执行管理功能。通过引入智能管理，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>可以帮助我们建立强有力的管理解决方案。代理服务本身也是作为管理构件而存在，也可以被MBean服务器控制。 </p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范定义了代理服务有： <br />      1)动态类装载--通过管理小程序服务可以获得并实例化新的类，还可以使位于网络上的类库本地化。 <br />      2)监视服务--监视管理构件的属性值变化，并将这些变化通知给所有的监听者。 <br />      3)时间服务--定时发送一个<a href="http://www.itisedu.com/phrase/200603090938465.html" target="_new">消息</a>或作为一个调度器使用。 <br />      4)关系服务--定义并维持管理构件之间的相互关系。 </p>
				<p>      1.动态类装载 </p>
				<p>      动态类装载是通过m-let（management <a href="http://www.itisedu.com/phrase/200604201518585.html" target="_new">applet</a>）服务来实现的，它可以从网络上的任何URL处下载并实例化管理构件，然后向MBean服务器注册。在一个M-let服务过程中，首先是下载一个m-let文本<a href="http://www.itisedu.com/phrase/200602282323195.html" target="_new">文件</a>，该文件是<a href="http://www.itisedu.com/phrase/200604231236585.html" target="_new">XML</a>格式的文件，文件的内容标识了管理构件的所有信息，比如构件名称、在MBean服务器中唯一标识该构件的对象名等。然后根据这个文件的内容，m-let服务完成剩余的任务。下图例示这一过程： </p>
				<p align="center">
						<img src="http://www.itisedu.com/manage/Upload/image/200642621268763.jpg" border="0" />
						<br /> </p>
				<p>
						<br />      2.监视服务 </p>
				<p>      通过使用监视服务，管理构件的属性值就会被定期监视，从而保证始终处于一个特定的范围。当监视的属性值的变化超出了预期定义的范围，一个特定的通告就会发出。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范当前规定了三种监视器： </p>
				<p>      1)计数器监视器，监视计数器类型的属性值，通常为整型，且只能按一定规律递增。 <br />      2)<a href="http://www.itisedu.com/phrase/200604231331545.html" target="_new">度量</a>监视器，监视度量类型的属性值，通常为实数，值能增能减。 <br />      3)字符串监视器，监视字符串类型的属性值。 </p>
				<p>      每一个监视器都是作为一个标准管理构件存在的，需要提供服务时，可以由相应的管理构件或远程管理应用程序动态创建并配置注册使用。 </p>
				<p>      下图例示了计数器监视器的使用情况： </p>
				<p align="center">
						<img src="http://www.itisedu.com/manage/Upload/image/2006426212636207.jpg" border="0" />
						<br /> </p>
				<p>
						<br />      3.时间服务 </p>
				<p>      时间服务可以在制定的时间和日期发出通告，也可以定期的周期性的发出通告，依赖于管理应用程序的配置。时间服务也是一个管理构件，它能帮助管理应用程序建立一个可配置的备忘录，从而实现智能管理服务。 </p>
				<p>      4.关系服务 </p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范定义了管理构件之间的关系模型。一个关系是用户定义的管理构件之间的N维联系。 </p>
				<p>      关系模型定义如下一些术语： </p>
				<p>      1)角色：就是是一个关系中的一类成员身份，它含有一个角色值。 <br />      2)角色信息：描述一个关系中的一个角色。 <br />      3)关系类型：由角色信息组成，作为创建和维持关系的模板。 <br />      4)关系：管理构件之间的当前联系，且必须满足一个关系类型的要求。 <br />      5)角色值：在一个关系中当前能满足给定角色的管理构件的列表。 <br />      6)关系服务：是一个管理构件，能接触和维持所有关系类型和关系实例之间的一致性。 </p>
				<p>      在关系服务中，管理构件之间的关系由通过关系类型确定的关系实例来维护。仅仅只有注册到MBean服务器上并且能被对象名标识的管理构件才能成为一个关系的成员。关系服务从来就不直接操作它的成员--管理构件，为了方便查找它仅仅提供了对象名。 </p>
				<p>      关系服务能锁定不合理关系类型的创建，同样，不合理的关系的创建也会被锁定。角色值的修正也要遵守一致性检查。 </p>
				<p>      由于关系是定义在注册的管理构件之间的联系，所以当其中的管理构件卸载时，就会更改关系。关系服务会自动更改角色值。所有对关系实例的操作比如创建、更新、删除等都会使关系服务发出通告，通告会提供有关这次操作的信息。 </p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>关系模型只能保证所有的管理构件满足它的设计角色，也就是说，不允许一个管理构件同时出现在许多关系中。 </p>
				<p>
						<br />      1．4 分布服务层<br />      当前，SUN并没有给出这一层的具体规范，下面给出的只是一个简要描述。 </p>
				<p>      该层规定了实现<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>应用管理平台的接口。这一层定义了能对代理层进行操作的管理接口和<a href="http://www.itisedu.com/phrase/200603302222545.html" target="_new">组件</a>。这些组件能： <br />      1)为管理应用程序提供一个接口，以便它通过一个连接器能透明和代理层或者<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>管理资源进行交互。 <br />      2)通过各种协议的映射（如SNMP、HTML等），提供了一个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理和所有可管理组件的视图。 <br />      3)分布管理信息，以便构造一个分布式系统，也就是将高层管理平台的管理信息向其下众多的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理发布。 <br />      4)收集多个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b> 代理端的管理信息并根据管理终端用户的需要筛选用户感兴趣的信息并形成<a href="http://www.itisedu.com/phrase/200604161231275.html" target="_new">逻辑视图</a>送给相应的终端用户。 <br />      5)提供了安全保证。 </p>
				<p>      通过管理应用层和另一管理代理和以及他的设备层的联合，就可以为我们提供一个完整的网络管理的解决方案。这个解决方案为我们带来了独一无二的一些优点：轻便、根据需要部署、动态服务、还有安全性。 </p>
				<p>
						<br />      1．5 附加管理协议API<br />      该层提供了一些API来支持当前已经存在的一些管理协议。 </p>
				<p>      这些附加的协议API并没有定义管理应用的功能，或者管理平台的体系结构，他们仅仅定义了标准的Java API和现存的网络管理技术通信，例如SNMP。 </p>
				<p>      网络管理平台和应用的开发者可以用这些API来和他们的管理环境进行交互，并将这个交互过程封装在一个<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>管理资源中。例如，通过SNMP可以对一个运行有SNMP代理的交换机进行管理，并将这些管理接口封装成为一个管理构件。在动态网络管理中，可以随时更换这些管理构件以适应<a href="http://www.itisedu.com/phrase/200603101518295.html" target="_new">需求</a>。 </p>
				<p>      这些API可以帮组开发者根据最通常的工业标准来部署他们的管理平台和应用。新的网路管理的解决方案可以和现存的基础结构合为一体，这样，现存的网络管理也能很好的利用基于Java技术的网络管理应用。 </p>
				<p>      这些API目前在<a href="http://www.itisedu.com/phrase/200604241437025.html" target="_new">JCP</a>（<a href="http://www.itisedu.com/phrase/200604241454455.html" target="_new">Java Community Process</a>）内作为独立的JSR（Java Specification Request）开发。 </p>
				<p>      他们包括： <br />      1)SNMP Manager API <br />      2)CIM/WBEM manager and protocol API </p>
				<p>
						<br />      1．6 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的当前实现及应用<br />      自从SUN发布了<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范，许多大公司纷纷行动起来，实现规范或者实现相应的基于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的网络管理系统，下面列出了当前的主要实现及应用情况： </p>
				<p>      1)SUN为<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范了作出了相应的参考实现，并在此基础上开发了一个全新的用于网络管理的产品JDMK（Java动态管理工具集），其中定义了资源的开发过程和方法、动态<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>代理的实现、远程管理应用的实现。同时，JDMK也提供了一个完整的体系结构用来构造分布式的网络管理系统，并提供了多种协议适配器和连接器，如SNMP协议适配器、HTML协议适配器、HTTP连接器、RMI连接器。 <br />      2)IBM Tivoli实现了<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规范的产品为TivoliJMX，它为JAVA管理应用程序和网络提供了架构、设计模式、一些API集和一些服务。 <br />      3)Adventnet开发的关于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的产品为AdventNet Agent Toolkit，它使得定义新的SNMP MIB、开发<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>和Java SNMP Agent的过程自动化。 <br />      4)<a href="http://www.itisedu.com/phrase/200605111343075.html" target="_new">JBoss</a>实现的<a href="http://www.itisedu.com/phrase/200606221217315.html" target="_new">J2EE应用服务器</a>以<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>为微内核，各个模块以管理构件的形式提供相应的服务。 <br />      5)BEA的Weblogic应用服务器也将<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>技术作为自己的管理基础。 <br />      6)金蝶的Apusic也是一个以<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>为内核开发出的<a href="http://www.itisedu.com/phrase/200603091447335.html" target="_new">J2EE</a>应用服务器。 </p>
				<p>
						<br />
						<strong>三、<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的好处</strong>
				</p>
				<p>      。可减少对JAVA应用实施管理的投资 <br />      。提供了一个可伸缩的管理框架 <br />      。集成现有的管理方案：如：WBEM，SNMP，TMN <br />      。使用现有的标准JAVA技术 <br />      。能使用未来的一些管理概念：如<a href="http://www.itisedu.com/phrase/200604271106225.html" target="_new">Jini</a>连接技术、通用即插即用、服务定位协议(Service Location Protocol) <br />      。只定义了一些可以访问的接口 </p>
				<p>
						<strong>四、<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>架构的了解</strong>
				</p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>应该说是关于网络应用管理的的框架，如果你开发了一个比较复杂的系统，无疑你要提供这个系统的自身管理 系统，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>更多应用是体现在Server上，如果你要使用java开发一个自己Server或复杂的应用系统，那么推荐你基于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>架构来开发， JBoss 3.0 weblogic等就是基于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>开发的符合J2EE规范的服务器软件。 </p>
				<p>      了解<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>可以使你深入了解J2EE服务器， 为什么我们平时说 "<a href="http://www.itisedu.com/phrase/200604241156485.html" target="_new">EJB</a>"是个比较"Weight"的方案选择，其中一个原因是J2EE服务器软件本身 也是你的系统中一部分，它作为你系统的容器，对你的系统有至关重要的作用，如果无法直接介入 管理或“调教”它，那么无疑你的系统本身存在着隐含的危险， 现在，通过<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>，你现在可以深入到你J2EE容器内部的管理了。 (好像国内出现了第一个自己J2ee服务器，不知道那是不是基于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>开发的?) </p>
				<p>      J2EE并不能概括所有的应用领域，比如对速度和性能要求极高的游戏或股票行情等系统就需要自己直接来开发Server， 如果是能够基于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>开发，那么可以说就大大提高编写管理程序的效率，可以将你的模块变成<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的MBean，可以通过Agent在程序内部或者通过 WEB管理页面对你的MBean模块进行初始化 重启 以及参数设置。</p>
				<p>      <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的好处还有：可以方便整合连接现有的Java技术，如JNDI JDBC JTS及其它。特别是能够使用Jini的查询 发现机制以及协议，我们知道,Jini提供了一种服务的查询和发现机制，这些services都可以通过<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b> 来实现管理。</p>
				<p>      现在我们开始<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的了解：</p>
				<p>      1.到java.sun.com首页的<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>页面，下载<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的规定说明和Samples程序。<br />      2.按照<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的说明进行一次Tutorial，了解如何加入 删除 配置一个MBean，Tutorial中是以SimpleMBean为例，那么我们能否建立一个自己的MBean?</p>
				<p>      我们来做一个Hello 的MBean，这里有一个小关键点，你的<a href="http://www.itisedu.com/phrase/200604231359565.html" target="_new">class</a>取名有个规则， 需要以MBean为结尾，如这里我们取名为HelloMbean:</p>
				<p>
						<br />public interface HelloMBean {</p>
				<p>　　// management attributes<br />　　public String getName();<br />　　public void setName(String name);</p>
				<p>　　// management operations<br />　　public void print();</p>
				<p>}</p>
				<p>      在这个Class里，有一个隐含attributes: name, 提供了set和get的方法，同时有一个操作方法print()：</p>
				<p>      再定义一个concrete类:</p>
				<p>public class Hello implements HelloMBean {</p>
				<p>　　private String name = "";</p>
				<p>　　public String getName() {<br />　　return name;<br />　　}</p>
				<p>　　public void setName(String name) {<br />　　this.name = name;<br />　　}</p>
				<p>　　public void print() {<br />　　System.out.println("Hello, " + name + "!!" );<br />　　}<br />}</p>
				<p>
						<br />      这样一个简单的MBean就做好了，我们可以通过admin界面加入这个Hello，</p>
				<p>      再按 Tutorial启动BaseAgent，在Agent Administration中参考Simple填入：<br />Domain: Standard_Hello_MBeans</p>
				<p>Keys : name=Hello,number=1</p>
				<p>Java Class: Hello</p>
				<p>      将出现Create Successful信息。进入MBean View 给Name赋值，点按Apply ，然后再按print，这是你的Hello中的方法，在控制台你会看到输出。</p>
				<p>      是不是很惊奇Hello中的 attributes 和operations能被动态的访问和控制？ 已经隐约感到<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的架构原理了吧？</p>
				<p>      下面再深入明确一些概念：<br />      上面HelloMBean资源是通过admin这样的HTTP WEB界面管理，这种管理资源方式是属于<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>的Distributed服务层， <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b> 通过Distributed层能够部署和管理MBean资源。就象上面的例子，是通过HtmlAdaptor提供的HTTP WEB界面来方面的维护管理HelloMBean.</p>
				<p>      那么我们能否在程序中自动管理和部署我的MBean？当然可以，这是通过Agent层来完成，现在我们已经有了这个层次，MBean所在的资源层，<br />最外面的Distributed服务层，Distributed服务层是通过Agent层来访问MBean资源的，看看下面来自Sun公司<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>规定的架构图：</p>
				<p align="center">
						<img src="http://www.itisedu.com/manage/Upload/image/2006426212837411.jpg" border="0" />
				</p>
				<p>      从图中看出，Agent Level(Agent层)包括MBean Server和Agent Services,那么我们来做一个上面例子HelloMBean的Agent：</p>
				<p>// CREATE the MBeanServer<br />//<br />System.out.println("\n\tCREATE the MBeanServer.");<br />MBeanServer server = MBeanServerFactory.createMBeanServer();</p>
				<p>// CREATE Registe HelloMBean<br />//<br />System.out.println("\n\tCREATE, REGISTER a new Hello Standard_MBean:");<br />HelloMBean helloMBean = new Hello();</p>
				<p>ObjectName hello_name = null;<br />try {<br />hello_name = new ObjectName("Standard_Hello_MBeans:name=Hello,number=1");<br />System.out.println("\tOBJECT NAME = " + hello_name);</p>
				<p>//将HelloMBean注册到MBeanServer中去<br />server.registerMBean(helloMBean, hello_name);<br />}<br />catch (Exception e) {<br />e.printStackTrace();<br />return;<br />}</p>
				<p>      向MBeanServer注册后，以后<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">JMX</b>就知道有了这个HelloMBean资源。</p>
				<p>      管理一个agent的MBean资源或使用它提供的服务必须通过一个protocol adaptor 或者connector,adaptor 或者connector属于Distributed layer level(Distributed服务层)，我们上面例子中通过HTTP WEB界面管理HelloMBean就是浏览器通过HtmlAdaptor这个adaptor来实现的。</p>
		</font>
<img src ="http://www.blogjava.net/19851985lili/aggbug/94633.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/19851985lili/" target="_blank">☜♥☞MengChuChen</a> 2007-01-18 14:36 <a href="http://www.blogjava.net/19851985lili/articles/94633.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>BPEL编辑器</title><link>http://www.blogjava.net/19851985lili/articles/94381.html</link><dc:creator>☜♥☞MengChuChen</dc:creator><author>☜♥☞MengChuChen</author><pubDate>Wed, 17 Jan 2007 03:06:00 GMT</pubDate><guid>http://www.blogjava.net/19851985lili/articles/94381.html</guid><wfw:comment>http://www.blogjava.net/19851985lili/comments/94381.html</wfw:comment><comments>http://www.blogjava.net/19851985lili/articles/94381.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/19851985lili/comments/commentRss/94381.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/19851985lili/services/trackbacks/94381.html</trackback:ping><description><![CDATA[
		<table cellspacing="0" cellpadding="0" width="760" align="center" border="0">
				<tbody>
						<tr>
								<td class="title" valign="center" align="middle" height="56">
										<b>
												<font color="#ff0000" size="3">
														<span class="atitle">从UML到BPEL</span>
														<!-- #EndEditable -->
												</font>
										</b>
								</td>
						</tr>
						<tr>
								<td class="formtitle" align="middle" height="40">
										<!-- #BeginEditable "2" -->来自: IBM  Keith Mantell  IBM IT Architect<!-- #EndEditable --></td>
						</tr>
				</tbody>
		</table>
		<table height="65" cellspacing="0" cellpadding="0" width="760" align="center" border="0">
				<tbody>
						<tr>
								<td class="content" height="65">
										<!-- #BeginEditable "3" -->
										<table width="85%" align="center" border="0">
												<tbody>
														<tr>
																<td class="content"> <span class="atitle2">Web服务世界中的模型驱动体系结构</span><table class="content"><tbody><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#0">如此多的XML ...</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#1">BPEL是什么？</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#2">UML为什么？</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#3">自动化业务流程的UML配置文件（Profile）</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#4">映射到BPEL4WS</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#5">UML到BPEL映射验证器</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#6">反射</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#7">鸣谢</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#8">参考资源</a></td></tr><tr><td class="content"><a class="content_a" href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#authorname">关于作者</a></td></tr></tbody></table><blockquote>本文描述了一种新工具，该工具是在alphaWorks网站上发布的Emerging Technologies Toolkit version 1.1 （ETTK），它采取用统一建模语言（Unified Modeling Language，UML）定义的流程并生成相应的BPEL和WSDL文档来实现该流程。这种性能用于突出对象管理组（OMGs）模型驱动体系结构（MDA）创始的一些优点：提高开发过程中的抽象水平，因此获得更高的生产率， 更好的质量，能够隔离于技术的根本改变。 </blockquote><p><a name="0"><span class="atitle2">如此多的XML ...</span></a></p><p>随着面向服务的体系结构（SOA）的出现，应用程序开发经历了一次彻底改变。这种架构合并了基于XML的标准，例如WSDL、简单对象访问协议（SOAP）、统一描述、发现和集成协议（UDDI）和现在的BPEL。然而，当您能做更多的事情时，开发任务的大小和复杂性已经提高，并且开发者会发现他们沉迷于文档和语法中，而迷失了他们工作的主要目标。另外，开发人员的目标在发生变化，标准本身也处在发展之中。因而，为了能快速的采用Web服务，开发者正在寻找解决复杂、高效和技术改变问题的答案。</p><p>UML到BPEL的映射工具能够获得用UML工具（例如：IBM Rational的XDE或Rose）开发的流程模型，并且能将它们转换为正确的BPEL和WSDL文档来实现该流程。 Emerging Technologies Toolkit version 1.1 （ETTK）是测试有趣的新技术的环境，并且现在具有两种格式：autonomic和webservices。本文重点介绍后者——webservices。</p><p><a name="1"><span class="atitle2">BPEL是什么？</span></a></p><p>BPEL提供了一种X<span class="content_a">ML注释和语义，用于指定基于Web服务的业务流程行为。使用合作伙伴的交互方式，定义了该BPEL4WS流程。合作伙伴可以将服务提供给流程，也可以向流程请求服务，或者参与到流程的双向交互中。BPEL通过指定顺序来编排Web服务，这对服务集合的调用来说意义深远。BPEL还针对每个服务分配了合作伙伴的责任。您可以使用它来指定合作伙伴的公共接口和可执行流程的描述。</span></p><p>BPEL 1.1是该规范的最新版本。它除了澄清术语之外，还允许较好的变量范围和附加的事件处理程序。有关该规范的最新版本和BPEL介绍，请参阅最前面的两篇相关内容链接。</p><p><a name="2"><span class="atitle2">为什么使用UML？</span></a></p><p>UML是一种OMG标准，该标准提供了一种可视化的建模表示法，这对设计和了解复杂的系统很有效。</p><p>UML具有下列几种通用优点：它是众所周知的面向对象（Object-Oriented ，oo）建模表示法，具有非常容易理解的图形表示法以及一套丰富的语义集来捕获OO系统的关键特征。 UML广泛地应用于面向对象的软件开发，还常用于定制的、基于组件的软件开发、业务流程建模和系统设计。这使大部分UML经验能被应用到成熟的Web服务技术中。</p><p><a name="IDAQCQBB"><span class="atitle3">扩展UML</span></a><br />扩展或定制UML的特性对MDA来说是很必要的；可以通过定制UML来支持系统建模，这种系统是需要完全或部分的部署到Web服务基础架构上。本文主要介绍模板（stereotypes）。模板（stereotypes）是一种对模型的元素进行分类的方法。例如，如果您有一个表示顾客的类，那么您可以附加<code>&lt;&lt;entity&gt;&gt;</code> 模板（stereotypes）来表示它代表一个数据对象（或许是Entity Bean）。这种信息有助于人们对模型的可读性，甚至可以用来改变表示CASE工具（例如Rational Rose）中类的图标。然而，在这种情况下您可以使用它来指导模型的翻译。要记住，您可以将模板（stereotypes）添加到UML模型中的更多元素上。还可以在配置文件（Profile）中结合这些模板（stereotypes）。为了表示特定的兴趣域，UML配置文件（Profiles）用于定义对基本UML的扩展集合。例如那些为CORBA和数据建模（Data Modeling）定义的配置文件（Profiles）。配置文件定义了要使用的UML元素，如何对其进行扩展，以及约束元素集合的良好性规则（<i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">well-formedness rules</i>）。</p><p>下面部分，我将介绍一种UML配置文件（Profile），可以通过构建与BPEL4WS（Web服务业务流程执行语言）相对应的一套语义结构来支持建模。同时还将描述BPEL4WS映射，BPEL4WS映射可以从适合配置文件的UML模型自动生成Web服务制品（BPEL、WSDL、XSD）。</p><p>下面部分将展示实际的BPEL例子以及UML配置文件（Profile），并重点讲述关键概念。</p><p><a name="3"><span class="atitle2">自动化业务流程的UML配置文件（Profile）</span></a></p><p>这部分通过一个例子介绍了UML配置文件子集，该例子定义了一个简单本的贷款批准流程。在本例中您将会在ETTK的README文档中发现转换器。它可以被总结为如下所示：</p><blockquote xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">“在收到贷款请求时，将请求的数值与数值（10000）比较。如果请求的数值比较少，那么将调用Assessor服务，否则将将调用Approver服务。如果Accessor认为该请求的风险比较高，它也将被传递给Approver。当Approver完成或者Accessor接受时，将会返回批准信息。” </blockquote><p>BPEL流程是有状态的并包含实例，所以在BPEL中，这种情况都会被作为一个LoanApproval流程而实现，对于被处理的每个实际贷款申请，LoanApproval流程都会有一个实例。每个实例都用BPEL变量来捕获它自己的状态。在UML配置文件中，流程被表示为<code>&lt;&lt;Process&gt;&gt;</code>模板类。类的属性与流程的状态相对应（在BPEL4WS 1.0术语中的容器，或者BPEL 1.1中的变量）<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图1</a>显示了表示贷款批准流程的UML类 。</p><p><a name="figure1"><b>图 1.用于BPEL流程建模的UML类</b></a><br /><img height="101" alt="Process" src="http://www.uml.org.cn/UMLApplication/images/a_process.gif" width="228" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>通过活动图可以清楚的描述类的行为。<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图2</a>显示了贷款批准流程的活动图。例如，<code>invokeAssessor</code>活动显示为带有圆角的长方形。执行的操作显示为活动的入口条件；例如，<code>riskAssessment</code>（一个变量）被设置为检查服务的结果。通过UML分区（也作为泳道）来表示流程中通信的合作伙伴：customer、assessor以及approver。每个分区中显示了往合作伙伴发送或者接收信息的活动。箭头表示流程执行活动的顺序。注意分派（assingment）活动没有放到一个分区中；它描绘了发生在它自身流程内的活动，该流程不需要外部服务。</p><p><a name="figure2"><b>图 2贷款批准流程的活动图</b></a><br /><img height="438" alt="Activity graph" src="http://www.uml.org.cn/UMLApplication/images/process.gif" width="590" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>应答（reply）活动向顾客返回响应，完成流程的处理。每个活动都有一个描述性的名称和输入活动来细化活动执行的工作。</p><p><a name="4"><span class="atitle2">映射到BPEL4WS</span></a></p><p>自动化业务流程的UML配置文件表示可以从UML模型生成完整的可执行BPEL制品。<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#table1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">表1</a> 概要的展示了从配置文件到BPEL的映射，覆盖到了本文介绍的配置文件子集。</p><p><a name="table1"><span class="atitle3">表 1. UML到BPEL4WS映射概述</span></a><br /></p><table class="content" cellspacing="0" cellpadding="3" width="100%" border="1"><tbody><tr><td><b xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">配置文件构件</b></td><td><b xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">BPEL4WS概念</b></td></tr><tr><td>&lt;&lt;process&gt;&gt;类</td><td>BPEL流程定义</td></tr><tr><td>&lt;&lt;process&gt;&gt; 类的活动图</td><td>BPEL活动级别</td></tr><tr><td>&lt;&lt;process&gt;&gt;类属性</td><td>BPEL变量</td></tr><tr><td>分层结构和控制流</td><td>BPEL顺序和流程活动</td></tr><tr><td>&lt;&lt;receive&gt;&gt;、 &lt;&lt;reply&gt;&gt;、&lt;&lt;invoke&gt;&gt;活动</td><td>BPEL活动</td></tr></tbody></table><p><a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#code1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">清单1</a>（由于版面空间原因，这里省略了很多细节代码）显示了BPEL文档的缩减版本，该文档是由本文介绍的贷款批准例子生成的。</p><a name="code1"><b>清单 1.BPEL清单摘录</b></a><br /><table cellspacing="0" cellpadding="5" width="100%" bgcolor="#cccccc" border="1"><tbody><tr><td><pre><code class="content">
&lt;process name="loanApprovalProcess" ...&gt;

  &lt;variables&gt;
    &lt;variable name="request" 
               messageType="loandef:creditInformationMessage"/&gt;
    &lt;variable name="riskAssessment" 
               messageType="asns:riskAssessmentMessage"/&gt;
    ...
  &lt;/variables&gt;
  ...
 
  &lt;flow&gt;
  
    &lt;receive name="receive1" partner="customer" 
             portType="apns:loanApprovalPT" 
             operation="approve" variable="request"
             createInstance="yes"&gt;
      &lt;source linkName="receive-to-assess"
              transitionCondition=
              "bpws:getVariableData('request', 'amount')&lt;10000"/&gt;
      &lt;source linkName="receive-to-approval"
              transitionCondition=
              "bpws:getVariableData('request', 'amount')&gt;=10000"/&gt;
    &lt;/receive&gt;

    &lt;invoke name="invokeAssessor" partner="assessor" 
            portType="asns:riskAssessmentPT" 
            operation="check"
            inputVariable="request"  
            outputVariable="riskAssessment"&gt;
      &lt;target linkName="receive-to-assess"/&gt;
      &lt;source linkName="assess-to-setMessage" 
              transitionCondition=
              "bpws:getVariableData('riskAssessment', 'risk')='low'"/&gt;
      &lt;source linkName="assess-to-approval" 
              transitionCondition=
              "bpws:getVariableData('riskAssessment', 'risk')!='low'"/&gt;
    &lt;/invoke&gt;

    &lt;assign name="assign"&gt;
      &lt;target linkName="assess-to-setMessage"/&gt;
      &lt;source linkName="setMessage-to-reply"/&gt;
      &lt;copy&gt;
        &lt;from expression="'yes'"/&gt;
        &lt;to variable="approvalInfo" part="accept"/&gt;
      &lt;/copy&gt;
    &lt;/assign&gt;

    ...

    &lt;reply name="reply" partner="customer" portType="apns:loanApprovalPT" 
           operation="approve" variable="approvalInfo"&gt;
      &lt;target linkName="setMessage-to-reply"/&gt;
      &lt;target linkName="approval-to-reply"/&gt;
    &lt;/reply&gt;
  &lt;/flow&gt;
&lt;/process&gt;</code></pre></td></tr></tbody></table><p>在<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#8" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">参考资料</a>中可以找到完整的配置文件链接。</p><p><a name="5"><span class="atitle2">UML到BPEL映射验证器</span></a></p><p>从IBM alphaWorks可以获得作为ETTK的一部分的技术验证器，它支持从UML工具（例如Rational XDE）到BPEL4WS运行时间（BPWS4J）的端到端情景。映射实现被构建为Eclipse插件，它采取了UML模型（XMI）交换的工业标准文件格式作为输入。BPEL4WS制品（artifact）同需要的WSDL和XSD制品是一起生成的。</p><p>让我们看一下验证器。首先要根据您的需要安装一些先决条件。ETTK页面显示了相关详细信息（参阅<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#8" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">参考资料</a>下载链接）。概括起来，您需要下列资源：</p><ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/"><li>Rose或XDE（本文采用的是XDE v2003） 
</li><li>Eclipse 2.0+或WebSphere Studio Application Developer（WSAD）5.0+ 
</li><li>WebSphere Application Server (WAS) 5.0+或Apache Tomcat 4.1.24+ 
</li><li>The ETTK本身（其中包含了BPWS4J）。 </li></ul><p>假设您已经具有下面需要的合适环境。</p><p>验证器随着不同情景的一套样例文档而产生，例如贷款批准或购买订单流程。样例文档将是两种类型：一种是可以由Rose或XDEUML打开和修改的模型文档，另一种是包含UML模型的XMI版本的XML文档，该文档可以通过Rose或XDE进行输出。在<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图3</a>中可以看到Rose或XDE中相应的模型，或者这些工具的XMI输出的模型。</p><p><a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图3</a>使用一个UML活动图显示了转换文档的全部流程；UML没有用吗？方框表示制品（通常是文档），而椭圆表示一个操作或活动。主要阶段是：</p><ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/"><li>构建UML模型并将其导出到XMI（使用Rose或XDE) 
</li><li>生成BPEL、WSDL和XSD文档 
</li><li>在BPWS4J运行时间部署并运行这些文档—— 测试。 </li></ul><p><a name="figure3"><b>图3. 开发一个流程</b></a><br /><img height="323" alt="Development Process" src="http://www.uml.org.cn/UMLApplication/images/devt_process.gif" width="378" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p><a name="IDASQQBB"><span class="atitle3">构建并输出UML模型</span></a><br />如果具有Rose而不没有XDE，则可以打开其中一个UML文档（.mdl或.mdx）；在本文中您已经通过贷款批准的例子看到了这些例子。</p><p><a name="figure4"><b>图 4.使用XDE建模并输出</b></a><br /><img height="415" alt="XDE" src="http://www.uml.org.cn/UMLApplication/images/xde_export.gif" width="549" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>在<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图4</a>UML模型被输出到XMI——您需要使用XDE v2003或更新版本。注意这种方法的好处是您正在使用的是一般性用途，而不需要修改UML工具和UML的标准扩展机制来构建和输出流程定义。</p><p>一旦模型执行完毕，则可以点击File --&gt;Export菜单，选择XMI Export将其输出，如<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图4</a>所示。</p><p><a name="IDATRQBB"><span class="atitle3">生成BPEL和WSDL文档</span></a><br />在Eclipse（或WebSphere Application Developer (IE)）中创建Java Project，然后导入您在前面创建的XMI文档（或使用ETTK提供的XMI样例文档）。最后选择XMI文件并通过右击鼠标菜单选择“Generate BPEL from UML”，如<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure5" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图5</a>所示。</p><p><a name="figure5"><b>图 5.转换XMI文件</b></a><br /><img height="461" alt="XDE Conversion" src="http://www.uml.org.cn/UMLApplication/images/xde_convert.gif" width="223" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>下面为您提供了更改不同前缀的机会；需要对其进行改进来与您的设置相匹配，如果您恰好使用的是ETTK安装，则默认值不需要修改，如<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure6" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图6</a>所示。</p><p><a name="figure6"><b>图6.设置前缀</b></a><br /><img height="320" alt="Prefixes" src="http://www.uml.org.cn/UMLApplication/images/prefices.gif" width="440" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>单击“Finish”按钮后，许多文档将显示在工程中，其中包括主要的BPEL和WSDL文档，LoanAssessor和LoanApprover服务以及数据定义的WSDL文档。</p><p><a name="IDABTQBB"><span class="atitle3">测试</span></a><br />这时，生成的文档应该准备进行部署。本文中可以部署到Apache Tomcat，但是也同样可以使用WebSphere Application Server。</p><p>导航到BPEL4WS部署面板（地址是http://localhost:8080/bpws4j/admin/index.html)），接着在各自的字段输入与主要服务相应的WSDL文档（即 Loan ApprovalProcess.wsdl）和BPEL文档，（即ProcessOrder.bpel），如<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure7" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">图 7</a>所示。</p><p><a name="figure7"><b>图7.部署流程</b></a><br /><img height="217" alt="Deploying process" src="http://www.uml.org.cn/UMLApplication/images/deployment1.jpg" width="600" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>单击“Continue Deployment”按钮之后，在流程插入不同角色需要的所有文档。在本例中有两个特别的任务：LoanAssessor和LoanApprover。</p><p><a name="figure8"><b>图 8.部署服务</b></a><br /><img height="268" alt="Deploying services" src="http://www.uml.org.cn/UMLApplication/images/deployment2.jpg" width="600" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/" /></p><p>一旦部署完流程（参阅<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204001.htm#figure8" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">Figure 8</a>所示），然后运行的例子与BPWS4J例子是相同的：调用与您的操作系统相应的LoanApprovalSample脚本：</p><p><code>LoanApprovalSample [soap-address] first-name last-name amount</code></p><p>例如，</p><p><code>LoanApprovalSample http://localhost:80/bpws4j/soaprpcrouter John Doe 10</code></p><p>根据UML活动图，可以知道数值10000是重要的！</p><p><a name="6"><span class="atitle2">反射</span></a></p><p>本文介绍了带有UML到BPEL转换器的自动化业务流程UML配置文件。配置文件允许开发者使用常规的UML技巧和工具，开发基于BPEL4WS的Web服务业务流程。这种方法使面向服务的的BPEL4WS组件合并到全面的系统设计，该系统设计利用了现存的软件工程方法。另外，从UML到BPEL4WS的映射容许使用模型驱动开发方法，从UML模型自动生成BPEL4WS可执行的流程。</p><p>这种方法着重于了MDA的概念如何能被运用到其它领域以及抽象的更高级别，该方法使得开发者可以隔离于技术的改变。</p><p>这里有几种不同的情况，每种情况下这种方法都是有益的：</p><ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/"><li>第一种情况，屏蔽在项目使用的技术版本的更改。BPEL可以（并且已经）更改了版本。如果流程所使用的语义没有发生根本的变化，可以重新生成实现而无需开发人员的干预。这种转换技术也能用来保护开发者在最初开发UML模型的投入：当有UML新版本可用的时候（例如将版本从1.4升级到2版本)，UML模型本身也能进行转换。 
</li><li>第二种情况，可以产生UML配置表，使用它能生成其它过程实现，诸如BPML。 
</li><li>第三种方法，可以从单个模型生成多种技术的制品（artifact）。在本例中包括BPEL和WSDL，但不能能生成non-XML输出，诸如Java输出。 
</li><li>最后，转变是双向的--在本例中有一个反向映射来支持现有的BPEL4WS和WSDL制品（artifact）的导入，以及支持BPEL4WS和WSDL制品（artifact）的同步，一方发生的改变能够反映到另一方。 </li></ul><p><a name="7"><span class="atitle2">致谢</span></a></p><p>感谢Gary Flood、Catherine Griffin和Tracy Gardner对本文进行输入和注释工作。</p><p><a name="8"><span class="atitle2">参考资料</span></a></p><ul><li>从IBM alphaWorks下载ETTK。<br /><br /></li><li>请参阅IBM alphaWorks 上的live running install of the ETTK on <i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">developerWorks</i>。<br /><br /></li><li>阅读James Snell编写的“Implementing Web services with the ETTK”教程。 （<i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">developerWorks</i>，2003年4月）<br /><br /></li><li>查看OMG上的MDA参考资料页面，那里有很多文章，可以链接到会议和更多信息。<br /><br /></li><li>浏览OMG上的UML参考资料，那里有很多文章，可以链接到会议和更多信息。<br /><br /></li><li>在&lt;ettk install directory&gt;\\wstk\\services\\demos\\uml2bpel\\docs\\UMLProfileForBusinessProcess1.1.pdf文档中查找UML Profile。<br /><br /></li><li>阅读<a href="http://www-106.ibm.com/developerworks/webservices/library/ws-bpel/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">BPEL 1.1规范</a> （<i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">developerWorks</i>，2003年3月）。<br /><br /></li><li>通过阅读Frank Leymann和Dieter Roller编写的“<a href="http://www.uml.org.cn/UMLApplication/UMLApplication04204002.htm" target="_blank">Web服务世界中的业务流程</a>”，，获取优秀的关于BPEL4WS的概述（<i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dw="http://www.ibm.com/developerWorks/">developerWorks</i>，2002年8月）。<br /></li></ul></td>
														</tr>
												</tbody>
										</table>
								</td>
						</tr>
				</tbody>
		</table>
<img src ="http://www.blogjava.net/19851985lili/aggbug/94381.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/19851985lili/" target="_blank">☜♥☞MengChuChen</a> 2007-01-17 11:06 <a href="http://www.blogjava.net/19851985lili/articles/94381.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Eclipse Test and Performance Tools Platform 简介</title><link>http://www.blogjava.net/19851985lili/articles/94377.html</link><dc:creator>☜♥☞MengChuChen</dc:creator><author>☜♥☞MengChuChen</author><pubDate>Wed, 17 Jan 2007 02:53:00 GMT</pubDate><guid>http://www.blogjava.net/19851985lili/articles/94377.html</guid><wfw:comment>http://www.blogjava.net/19851985lili/comments/94377.html</wfw:comment><comments>http://www.blogjava.net/19851985lili/articles/94377.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/19851985lili/comments/commentRss/94377.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/19851985lili/services/trackbacks/94377.html</trackback:ping><description><![CDATA[
		<br />Eclipse Test and Performance Tools Platform 简介<br />用一种高级的可扩展平台来测试、分析和监视应用程序<br /><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 简介<br /><br />在交付健壮的产品质量的程序所需的过程中，编写应用程序或 servlet 的 Java 代码只是第一个阶段。必须对代码进行测试，检验它的操作和正确性。往往还必须对代码进行分析，以便消除性能瓶颈和资源浪费（尤其是内存）。还必须对代码进行监视，以便对故障进行定位、识别使用模式、寻找进一步增强和优化的机会以及探测入侵尝试和实际的入侵。<br /><br />Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是什么？<br /><br />虽然存在许多对代码进行测试、分析和监视的工具，但是很少能够集成为一个大型的工具包。另外，这类工具通常是由不同的厂商提供的，这使您不得不花费宝贵的时间和精力来学习和掌握许多不同的用户界面（UI）、编译器和诊断技术。在时间和资金两方面，专有的开发工具都需要很大的投资。<br /><br />但是，如果测试工具、分析器和监视器是开放源码的，那么会怎么样？而且，如果这些工具是可扩展的，任何厂商或开发人员都可以创建新工具或者对现有工具进行改进，那么会怎么样？如果这些工具能够很好地集成到一种现有的流行的开发环境中，那么会怎么样？这恐怕是白日做梦吧？不，这已经是现实了。<br /><br />Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是一种软件体系结构以及几个扩展了 Eclipse 平台的组件（到目前为止），它在 Eclipse 平台上提供了测试、性能和监视工具。一些 Java、C 和 C++ 开发人员使用 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 为其他开发人员构建独特的工具，还有一些开发人员将 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供的工具和 Eclipse 的其他特性组合起来，构建和部署供用户使用的应用程序。<br /><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供了什么<br /><br />简单地说，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是一个 Eclipse Foundation 顶级项目，它的目标是：“构建一个通用的可扩展的基于标准的工具平台，软件开发人员可以在这个平台上创建专用的可互操作的...测试和性能工具。” 换句话说，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 在本质上是一个工具，用来构建对软件质量控制进行自动化的工具。<br /><br />实际上，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 的当前版本包括核心工具和三种核心衍生工具：<br /><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 为 UI 开发、数据收集、基于规则的数据查询以及应用程序的控制提供了基础代码。例如，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供了其他工具可以重用和扩展的许多向导。它还提供了编程接口和一个守护进程，以便帮助从正在运行的本地或远程进程中收集数据。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Testing Tools<br />这个项目是在 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 之上构建的，提供了对应用程序进行各种自动化测试所需的其他服务。当前版本支持 JUnit 自动测试、一种指向和点击脚本编程系统（用于进行手工测试并记录结果）和一个用于测试 Web 应用程序的自动化系统，包括一个可以记录和回放 Web 浏览会话并对结果进行验证的记录器。Eclipse V4.1 还包括一个图形用户界面（GUI）记录器的早期版本，它可以记录和回放基于 SWT 的界面中的鼠标和键盘事件。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Monitoring Tools<br />这个项目对来自日志文件或来自应用程序收集的统计数据的数据进行收集、分析和图形显示。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Tracing and Profiling Tools<br />这个项目也扩展了 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>，用来收集和分析正在运行的应用程序中的资源使用数据，包括 CPU 和内存。这个跟踪工具还允许与正在运行的进程进行交互。例如，可以手工地实施垃圾收集并检查剩余的对象池，从而寻找和修复内存 “泄漏”。<br />另外，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 包括一个称为 Agent Controller 的守护进程。Agent Controller 是 Eclipse 工作台和被测试的应用程序之间的 “联络人”。它代表 Eclipse 启动本地或远程 Java 应用程序并转发应用程序度量（包括应用程序日志文件）给 Eclipse。<br /><table class="i_table" cellspacing="1" cellpadding="1" width="100%" align="center"><tbody><tr><td><table cellspacing="0" cellpadding="3" width="100%"><tbody><tr class="head"><td><b>sofieh</b></td><td class="smalltxt" align="right">2006年03月30日 10:54</td></tr><tr bgcolor="#ffffff"><td class="tpc_content" colspan="2">好文章，顶！<br />毕竟是权威。</td></tr></tbody></table></td></tr></tbody></table><br /><table class="i_table" cellspacing="1" cellpadding="1" width="100%" align="center"><tbody><tr><td><table cellspacing="0" cellpadding="3" width="100%"><tbody><tr class="head"><td><b>snappyboy</b></td><td class="smalltxt" align="right">2006年04月05日 09:42</td></tr><tr bgcolor="#ffffff"><td class="tpc_content" colspan="2">Eclipse Test and Performance Tools Platform 简介<br />用一种高级的可扩展平台来测试、分析和监视应用程序<br /><br />级别: 中级<br />Martin Streicher, 主编, Linux Magazine<br />2006 年 3 月 23 日<br />学习如何使用 Eclipse Test and Performance Tools Platform（<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>）分析 Java™ 应用程序，并研究如何测量内存使用量、识别内存泄漏并隔离性能瓶颈。<br />开始之前<br />在本教程中可以学到什么？如何从本教程获得最大的收益？<br />关于本教程<br />本教程介绍 Eclipse Test and Performance Tools Platform（<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>），逐步说明了如何安装 Eclipse 和 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 工具，并演示如何分析正在运行的 Java 应用程序。<br /><br />前提条件<br />为了从本教程中获益，您应该具备 Java 软件开发经验并了解整个软件开发生命周期，包括测试和分析。还应该熟悉从命令行安装软件，以及设置和管理 shell 和系统环境变量，比如 Java CLASSPATH。了解 Eclipse 和 Standard Widget Toolkit（SWT）也是有帮助的。<br />在开始之前，必须在 UNIX®、Linux®、Mac OS X 或 Microsoft® Windows® 系统上安装几个软件包。需要 Java 虚拟机（Java Virtual Machine，JVM）、Eclipse 平台、Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 运行时以及 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 所依赖的几个软件。还需要 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 的 Agent Controller，它允许启动并分析应用程序。下面是所需的所有软件：<br />•    Java 2 Platform, Standard Edition（J2SE） V1.4 Software Development Kit（SDK） <br />•    J2SE V1.4 Java Runtime Environment （J2RE） <br />•    Eclipse V3.1 SDK <br />•    Eclipse Modeling Framework（EMF） SDK V2.1 <br />•    XML Schema Infoset Model（XSD） SDK V2.1 <br />•    V1.1.1 of UML2 <br />•    <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 运行时 <br />•    Agent Controller 运行时 （适合您系统的版本） <br />•    Eclipse Update Manager（可选） <br /><br />系统需求<br />如果系统上没有安装 JVM 和 Eclipse，那么所有软件至少需要 300 MB 的空闲磁盘空间。还需要有足够的空闲物理内存来运行 JVM。一般来说，建议使用 64 MB 或更多的空闲物理内存。<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 简介<br />在交付健壮的产品质量的程序所需的过程中，编写应用程序或 servlet 的 Java 代码只是第一个阶段。必须对代码进行测试，检验它的操作和正确性。往往还必须对代码进行分析，以便消除性能瓶颈和资源浪费（尤其是内存）。还必须对代码进行监视，以便对故障进行定位、识别使用模式、寻找进一步增强和优化的机会以及探测入侵尝试和实际的入侵。<br />Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是什么？<br />虽然存在许多对代码进行测试、分析和监视的工具，但是很少能够集成为一个大型的工具包。另外，这类工具通常是由不同的厂商提供的，这使您不得不花费宝贵的时间和精力来学习和掌握许多不同的用户界面（UI）、编译器和诊断技术。在时间和资金两方面，专有的开发工具都需要很大的投资。<br />但是，如果测试工具、分析器和监视器是开放源码的，那么会怎么样？而且，如果这些工具是可扩展的，任何厂商或开发人员都可以创建新工具或者对现有工具进行改进，那么会怎么样？如果这些工具能够很好地集成到一种现有的流行的开发环境中，那么会怎么样？这恐怕是白日做梦吧？不，这已经是现实了。<br />Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是一种软件体系结构以及几个扩展了 Eclipse 平台的组件（到目前为止），它在 Eclipse 平台上提供了测试、性能和监视工具。一些 Java、C 和 C++ 开发人员使用 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 为其他开发人员构建独特的工具，还有一些开发人员将 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供的工具和 Eclipse 的其他特性组合起来，构建和部署供用户使用的应用程序。<br /><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供了什么<br />简单地说，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 是一个 Eclipse Foundation 顶级项目，它的目标是：“构建一个通用的可扩展的基于标准的工具平台，软件开发人员可以在这个平台上创建专用的可互操作的...测试和性能工具。” 换句话说，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 在本质上是一个工具，用来构建对软件质量控制进行自动化的工具。<br />实际上，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 的当前版本包括核心工具和三种核心衍生工具：<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b><br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 为 UI 开发、数据收集、基于规则的数据查询以及应用程序的控制提供了基础代码。例如，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供了其他工具可以重用和扩展的许多向导。它还提供了编程接口和一个守护进程，以便帮助从正在运行的本地或远程进程中收集数据。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Testing Tools <br />这个项目是在 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 之上构建的，提供了对应用程序进行各种自动化测试所需的其他服务。当前版本支持 JUnit 自动测试、一种指向和点击脚本编程系统（用于进行手工测试并记录结果）和一个用于测试 Web 应用程序的自动化系统，包括一个可以记录和回放 Web 浏览会话并对结果进行验证的记录器。Eclipse V4.1 还包括一个图形用户界面（GUI）记录器的早期版本，它可以记录和回放基于 SWT 的界面中的鼠标和键盘事件。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Monitoring Tools <br />这个项目对来自日志文件或来自应用程序收集的统计数据的数据进行收集、分析和图形显示。 <br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Tracing and Profiling Tools <br />这个项目也扩展了 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>，用来收集和分析正在运行的应用程序中的资源使用数据，包括 CPU 和内存。这个跟踪工具还允许与正在运行的进程进行交互。例如，可以手工地实施垃圾收集并检查剩余的对象池，从而寻找和修复内存 “泄漏”。<br />另外，<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 包括一个称为 Agent Controller 的守护进程。Agent Controller 是 Eclipse 工作台和被测试的应用程序之间的 “联络人”。它代表 Eclipse 启动本地或远程 Java 应用程序并转发应用程序度量（包括应用程序日志文件）给 Eclipse。<br />本教程的剩余部分演示针对 Java 技术的几种 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 分析工具。<br />安装必需的软件和组件<br />在开始学习本教程之前，必须安装和设置 “前提条件” 小节中列出的软件和组件。<br /><br />安装 J2SE 和 J2RE<br />下载并安装 J2SE V1.4 SDK 和 V1.4 J2RE。（如果系统上已经有 J2SE V1.4.2_10 或更高版本，那么可以跳过这一步。）<br /><br />通常，J2SE SDK 和 Java Runtime Environment（JRE）是以自解压的二进制文件形式发布的。Linux 上的安装通常只需执行以下命令：<br /><br />清单 1. J2SE SDK 和 Java Runtime Environment 安装<br /><br /><br />% cd ~<br />% mkdir ~/java<br />% cd ~/java<br />% mv ~/j2sdk-1_4_2_10-linux-i586.bin . <br />% mv ~/j2re-1_4_2_10-linux-i586.bin . <br />% chmod +x j2sdk-1_4_2_10-linux-i586.bin j2re-1_4_2_10-linux-i586.bin<br />% ./j2sdk-1_4_2_10-linux-i586.bin<br />.<br />% ./j2re-1_4_2_10-linux-i586.bin<br />.<br />% ls -F<br />j2re1.4.2_10/   j2sdk1.4.2_10/<br /><br />使用 Eclipse Update Manager 安装 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>（可选）<br />如果已经安装了 Eclipse，那么可以使用 Eclipse Update Manager 安装 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>。步骤如下：<br />1.    点击 Help &gt; Software Updates &gt; Find and Install。 <br />2.    选择 Search for new features to install 选项，然后点击 Next。 <br />3.    点击 New Remote Site，然后分别输入 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Update Site 和 <a href="http://eclipse.org/tptp/updates/site.xml" target="_blank">http://eclipse.org/<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">tptp</b>/updates/site.xml</a> 作为名称和 URL。点击 Finish。 <br />4.    选择要安装的特性，然后点击 Next。 <br />5.    接受许可协议，点击 Next，然后点击 Finish。 <br />6.    在确认提示中，点击 Install All。当安装完成时，重新启动 Eclipse。 <br />现在，可以跳过后面 “安装 Agent Controller” 小节中描述的安装 Agent Controller（它必须手工安装）的步骤。如果还没有安装 Eclipse，请继续阅读下文。<br /><br />安装 Eclipse V3.1 SDK<br />下载适合自己平台的 Eclipse 3.1 SDK。可以在 Eclipse Downloads 上找到这个 SDK。通常，安装时只需将 Eclipse .tar.gz 文件释放到您选择的目录中。例如，如果使用 Linux，那么下载 Eclipse V3.1 SDK tarball，然后使用以下命令将它释放到一个目录中，比如 ~/java/：<br /><br />% cd ~/java<br />% mv ~/eclipse-SDK-3.1.1-linux-gtk.tar.gz . <br />% tar zxvf eclipse-SDK-3.1.1-linux-gtk.tar.gz<br /><br />如果想检验 Eclipse 是否已经成功安装了，那么留在释放 Eclipse 的目录中，确保 java 可执行文件在 PATH 中并运行 java -jar eclipse/startup.jar。例如：<br /><br />清单 2. 检验 Eclipse 是否已经成功安装了<br /><br /><br />% export JAVA_DIR=$HOME/java<br />% export JAVA_HOME=$JAVA_DIR/j2sdk1.4.2_08/sdk<br />% export PATH=$JAVA_HOME/bin<br />% export CLASSPATH=$JAVA_HOME<br />% cd $JAVA_DIR<br />% java -jar eclipse/startup.jar<br /><br />如果提示您为工作空间选择目录，那么输入 $HOME/java/workspace。这个目录将保存您在 Eclipse 中创建的所有项目。（当然，如果有许多项目，以后可以选择其他目录，让一个工作空间只包含一个项目。）<br /><br />安装 EMF SDK V2.1<br />如果 Eclipse 正在运行，就退出它并下载 EMF SDK V2.1。（根据 EMF Web 站点所说，“EMF 是一种建模框架和代码生成设施，用于根据结构化数据模型构建工具和其他应用程序。”）在下载文件之后，进入包含 Eclipse 文件夹的目录并运行 unzip emf-sdo-SDK-2.1.0.zip。例如：<br /><br />清单 3. 运行 unzip emf-sdo-SDK-2.1.0.zip<br /><br /><br />% cd $JAVA_DIR<br />% ls<br />eclipse j2sdk1.4.2_08<br />% mv ~/emf-sdo-SDK-2.1.0.zip . <br />% unzip emf-sdo-SDK-2.1.0.zip<br />creating: eclipse/features/<br />creating: eclipse/features/org.eclipse.emf.ecore.sdo_2.1.0/<br />creating: eclipse/features/org.eclipse.emf_2.1.0/<br />inflating: ...<br /><br />安装 XSD SDK V2.1<br />下载 XSD SDK V2.1。（根据项目 Web 站点所说，“XSD 是一个库，它提供了一个应用编程接口（API），用于按照 World Wide Web Consortium（W3C）XML Schema 规范的描述操作 XML 模式的组件。”）在下载文件之后，进入包含 Eclipse 目录的目录并运行 unzip xsd-SDK-2.1.0.zip。下面是一个例子：<br /><br />% cd $JAVA_DIR<br />% mv ~/xsd-SDK-2.1.0.zip .<br />% unzip xsd-SDK-2.1.0.zip<br /><br />如果提示您确认覆盖任何文件，那么只需按 y（小写）对每个问题回答 Yes。<br /><br />安装 UML V2.0 Metamodel Implementation<br />要使用 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 的 Unified Modeling Language（UML）特性，就需要安装 UML V2.0 Metamodel Implementation。如果正在使用 Eclipse V3.1.1，那么下载 V1.1.1 of UML2，然后在包含 Eclipse 的目录中释放它的存档文件：<br /><br />% cd $JAVA_DIR<br />% mv ~/uml2-1.1.1.zip . <br />% unzip uml2-1.1.1.zip<br /><br />安装 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 运行时<br />对于下一步，下载 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 运行时，这包含所有 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 特性和集成两个系统所需的 Eclipse 插件。要安装 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>，进入包含 Eclipse 的目录并运行 unzip <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">tptp</b>.runtime-<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>-4.1.0.zip。下面是一个例子：<br /><br />% cd $JAVA_DIR<br />% mv ~/<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">tptp</b>.runtime-<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>-4.1.0.zip .<br />% unzip <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">tptp</b>.runtime-<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>-4.1.0.zip       <br /><br />安装 Agent Controller<br />Agent Controller 是 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 的一个重要组件，它使 Eclipse 能够启动应用程序并与这些应用程序进行交互，从而提取分析数据。下载适合您的操作系统的 Agent Controller 运行时。接下来，在包含 Eclipse 的目录中创建一个称为 tptpd 的目录，并将 Agent Controller 存档文件释放到这个目录中。要运行的命令是：<br /><br />% mkdir $JAVA_DIR/tptpd<br />% cd $JAVA_DIR/tptpd<br />% mv ~/tptpdc.linux_ia32-<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>-4.1.0.zip . <br />% unzip tptpdc.linux_ia32-<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>-4.1.0.zip<br /><br />如果看到两个下面这样的错误：<br /><br />linking: lib/libxerces-c.so     <br />warning: symbolic link (lib/libxerces-c.so) failed<br /><br />linking: lib/libxerces-c.so.24   <br />warning: symbolic link (lib/libxerces-c.so.24) failed<br /><br />那么必须通过输入以下命令来手工重新创建这两个链接：<br /><br />% cd $JAVA_DIR/tptpd/lib<br />% rm libxerces-c.so libxerces-c.so.24<br />% ln -s libxerces-c.so.24.0 libxerces-c.so<br />% ln -s libxerces-c.so.24.0 libxerces-c.so.24<br /><br />添加 Agent Controller 目录<br />要使用 Agent Controller，必须将它的 lib 目录添加到 LD_LIBRARY_PATH 中。例如，如果正在运行 Linux 并采用以上步骤中给出的目录结构，那么用以下命令添加 $JAVA_DIR/tptpd/lib：<br /><br />% export LD_LIBRARY_PATH=$JAVA_DIR/tptpd/lib:$LD_LIBRARY_PATH<br /><br />还必须确保 Controller 的 lib 和 bin 目录的内容是可执行的。为此，运行：<br /><br />% chmod +x $JAVA_DIR/tptpd/{bin,lib}/*<br /><br />现在将配置和启动 Agent Controller 的脚本添加到 PATH：<br /><br />% export PATH=$JAVA_DIR/tptpd/bin:$PATH<br /><br />针对环境配置 Agent Controller<br />最后，要配置 Agent Controller 以便匹配环境。进入 Agent Controller 的 bin 目录，然后运行 SetConfig.sh。<br /><br />% cd $JAVA_DIR/tptpd/bin<br />% ./SetConfig.sh<br /><br />当配置脚本提示您进行选择时，接受默认设置。运行配置脚本会在 Agent Controller 的文件层次结构中创建文件 config/serviceconfig.xml。<br /><br />测试 Agent Controller<br />为了测试 Agent Controller，运行 RAStart.sh。为了停止 Agent Controller，运行 RAStop.sh：<br /><br />清单 4. 停止 Agent Controller<br />db% RAStart.sh <br />Starting Agent Controller<br />RAServer started successfully<br />% RAStop.sh <br />RAServer stopped, pid = 5891<br />RAServer stopped, pid = 5892<br />RAServer stopped, pid = 5893<br />RAServer stopped, pid = 5894<br />RAServer stopped, pid = 5895<br />RAServer stopped, pid = 5896<br />RAServer stopped, pid = 5897<br />RAServer stopped, pid = 5898<br />RAServer stopped, pid = 5899<br />RAServer stopped, pid = 5900<br />RAServer stopped, pid = 5901<br />RAServer stopped, pid = 5902<br />RAServer stopped, pid = 5904<br />RAServer stopped, pid = 5905<br />RAServer stopped, pid = 5906<br /><br />现在完成了！重新启动 Eclipse。在 Eclipse 工具栏上应该会看到一个新按钮，如图 1 所示。这是 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profile 按钮。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 已经安装了，您可以继续学习本教程了。<br />图 1. <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profile 按钮<br /><br /><br />对 Java 应用程序进行分析<br />既然已经安装了 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 和底层软件，现在就运行 Eclipse。<br /><br />示例应用程序<br /><br />要分析的 Java 应用程序见清单 5。<br /><br />清单 5. 由少量对象组成的简单 Java 应用程序<br /><br /><br />import java.io.BufferedReader;<br />import java.io.IOException;<br />import java.io.InputStreamReader;<br /><br />public class SpaceShipToy {<br />  /* <br />  * To build a spaceship, you need a capsule, a booster,<br />  * three stages, and two monkeys (borrowed<br />  * from a Barrel of Monkeys).<br />  */ <br />  public Capsule capsule = new Capsule();<br />  public Booster booster = new Booster();<br />  public Stage[] stage = new Stage[3];<br />  <br />  public SpaceShipToy()<br />  {<br />    for (int i = 0; i &lt; 3; i++)<br />    stage<i> = new Stage();<br />  }<br /><br />  private void _killTime(int seconds) <br />  {<br />    if (seconds &lt;= 0)<br />      return;<br />      <br />    for (int i = 0; i &lt; seconds; i++);<br />  }<br />  <br />static final int MINUTE = 60;<br />  static final int CAPSULE = 2 * MINUTE;<br />  static final int BOOSTER = 5 * MINUTE;<br />  static final int STAGE = 3 * MINUTE;<br />  static final int MONKEY = 10 * MINUTE;<br />  <br />  class Capsule { <br />    public Monkey chimp1 = new Monkey(), chimp2 = new Monkey();<br /><br />    public Capsule() {<br />      System.out.println("Start building the capsule...");<br />      _killTime(CAPSULE);<br />      chimp1.build();<br />      chimp2.build();<br />      System.out.println("Capsule complete.");<br />    }<br />  }<br />  <br />  class Booster   { <br />    public Booster() {<br />    System.out.println("Start booster...");<br />    _killTime(BOOSTER);<br />    System.out.println("Blast off.");<br />    }   <br />  }<br />  <br />  class Stage { <br />    public Stage() {<br />    System.out.println("start stage...");<br />    _killTime(STAGE);<br />    System.out.println("Stage complete.");<br />    }   <br />  }<br />  <br />  class Monkey {<br />    public void start() {<br />    System.out.println("Start the monkey business...");<br />    }<br />    <br />    public void build() {<br />    start();<br />    _killTime(MONKEY);<br />    finish();<br />    }<br />    <br />    public void finish() {<br />    System.out.println("Monkey business complete.");<br />    }<br />  }<br /><br /><br />  public static void main(String[] args) throws java.io.IOException<br />  {<br />    final int NUMBERTOYS = 9;<br />    <br />    BufferedReader in = new <br />      BufferedReader(new InputStreamReader(System.in));<br />    SpaceShipToy[] toys = new SpaceShipToy[NUMBERTOYS];<br />    String input = in.readLine().trim();<br />    <br />    System.out.println("Toy factory is up and running...");<br />    System.out.flush();<br /><br />    for (int i = 0; i &lt; NUMBERTOYS; i++) <br />      toys<i> = null;<br />      <br />    while (!input.equalsIgnoreCase("q")) {<br />    if (input == null || input.length() != 1 <br />      || !Character.isDigit(input.charAt(0))) {<br />      System.err.println ("Unknown option. Try 0-9, q");<br />      input = in.readLine().trim();<br />      continue;<br />    }<br />    <br />    int number = Integer.valueOf(input).intValue();<br />    if (number == 9) {<br />      new SpaceShipToy();<br />      System.out.println("Whoops... Lost one...");<br />    }<br />    else {<br />      if (toys[number] != null) { <br />        System.out.println("Shipping toy # " + number);<br />        toys[number] = null;<br />      }<br />      else {<br />        System.out.println("Building toy # " + number);<br />        toys[number] = new SpaceShipToy();<br />      }<br />    }<br />    <br />    input = in.readLine().trim();<br />  }<br />} <br />}<br /><br />这个 Java 应用程序很简单：它 “构建” 玩具飞船并将它们 “发射” 到商店。每个玩具由一个 Java 对象代表，这个对象包含几个其他对象，这些对象各自代表玩具的一个部件。每个玩具部件都要花一定的时间来构建。<br />为了使用这个应用程序，按 0 到 8 数字键来构建玩具。如果再次按同一个键，构建的玩具就被 “发射”，相关联的对象被取消引用，从而可以被垃圾收集。因此，在任何时候在内存中最多可以有 9 个玩具（如果构建了所有 9 个玩具，而且都没有发射）。<br />按 9 键会创建一个未被引用的对象，这模拟了内存泄漏。按 q（小写）可以退出应用程序。<br /><br />运行分析会话<br />使用 Eclipse 和 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 来运行并分析 “玩具工厂”。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 可以显示活动对象的数量、执行时间等等。要使用 Eclipse 和 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>：<br />1.    启动 Agent Controller。 <br />2.    进入 Agent Controller bin 目录，然后运行 RAStart.sh:<br />% cd $JAVA_DIR/tptpd/bin<br />% ./RAStart.sh<br />3.    在 Eclipse 中，进入工作台并通过点击 File &gt; New &gt; Project 创建一个新的 Java 项目。从选项列表中选择 Java Project，然后点击 Next。 <br />4.    在下一个窗口中，输入 Toy Maker 作为 Project Name，然后点击 Finish。标题为 “Toy Maker” 的新项目应该会出现在 Package Explorer 面板中。 <br />5.    在这个项目中，在 example 包中创建一个称为 SpaceShipToy 的 Java 类。点击 File &gt; New &gt; Class。 <br />6.    在弹出的窗口中，在 Package 域中输入 example 并在 Name 域中输入 SpaceShipToy。窗口中的其他设置保持不变。 <br />7.    点击 Finish。现在应该会看到新类的骨架。 <br />8.    将清单 1 中的代码复制到 Eclipse 类编辑器中，一定要留下 package example 声明，但是要替换空的类定义。保存代码以使修改持久化，这还会使 Eclipse 自动地重新编译类的新版本。 <br />9.    如果要运行这个应用程序，点击 Run &gt; Run...，双击 Java Application，选择 SpaceShipToy，然后点击 Run。要与这个应用程序进行交互，点击 Windows &gt; Show View...，然后选择 Console。 <br />10.    输入 1（数字一）并按 Return。屏幕应该与图 2 相似。<br /><br />图 2. 在 Eclipse 下运行的玩具工厂<br /><br /><br />对同一个应用程序进行分析<br />要对同一个应用程序进行分析：<br />1.    点击 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profile，然后选择 Profile...。 <br />2.    展开 Java Application 以显示 SpaceShipToy。注意，Profile 窗口与点击 Run 时出现的 Run 窗口相似，但是多了一个称为 Profile 的选项卡。 <br />3.    点击 Profile 在分析器下启动这个应用程序。如果透视图没有自动切换，那么点击 Window &gt; Open Perspective &gt; Other...，然后选择 Profiling and Logging。 <br />4.    当 Profiling and Logging 透视图出现时，展开 Profiling Monitor 视图的内容，然后选择以 &lt;monitoring&gt; 开头的行。在选择这一行时，出现一个控制台视图。 <br />5.    输入 0、1、2 和 9。屏幕应该与图 3 相似。<br /><br />图 3. Profiling and Logging 透视图与正在运行的应用程序<br /><br />6.    点击 Memory Statistics 视图，然后展开与 example 包相关联的行。这个视图应该与图 4 相似。这里有 4 个对象实例：三个代表 “构建的” 玩具，一个代表未被引用的玩具。<br /><br />图 4. 在构建三个玩具对象和一个未被引用的玩具之后的内存消耗<br /><br />Memory Statistics 视图中的列记录了实例和内存使用统计数据：<br />•    Total Instances 反映一个类的实例总数。 <br />•    Live Instances 显示有多少个实例仍然被引用，还没有被垃圾收集器收集。 <br />•    Collected 统计垃圾收集器已经收集了多少个类实例。 <br />•    Total Size (bytes) 和 Active Size (bytes) 分别显示所有实例使用的累积内存总量（一种高水位标志）和活动实例当前使用的内存量。 <br />结束试运行<br />要结束这一次试运行，切换回控制台视图，然后再次按 0、1 和 2 数字键。点击 Monitoring 视图中的 trash can 图标强迫实施垃圾收集。好的垃圾收集器会收集所有未被引用的对象。在任何时候，都可以通过点击 Refresh 刷新当前透视图中的所有视图，见图 5。<br />图 5. Refresh 按钮<br /><br />寻找需要的数据<br />Profiling and Logging 透视图提供了许多视图，其中提供关于应用程序状态的大量数据。要查看视图列表，点击 Window &gt; Show View &gt; Other...，然后展开 Profiling and Logging 下面的列表。这个列表应该与图 6 相似。<br /><br />图 6. Profiling and Logging 视图的列表<br /><br /><br />收集数据来填充视图<br />根据您的目标和面对的问题，可以收集数据来填充所有这些视图或者其中一个视图。在前一节中，收集的惟一数据是内存统计数据，这些数据填充在 Memory Statistics 视图中。Monitoring 视图与图 7 相似。<br /><br />图 7. Monitoring 视图中的基本统计数据<br /><br />最下面的展开的列表表明，当前的分析配置只包含内存使用情况的统计数据。我们来创建一个收集尽可能多信息的新的分析配置，这样您就能够看到分析和性能工具提供的所有度量：<br />1.    点击 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profile 按钮中的小箭头，然后选择 Profile...。 <br />2.    在 Profile 窗口中，选择 SpaceShipToy，然后点击窗口底部左边的 New。 <br />3.    在最右边面板的顶部，在 Name 域中输入 Lots of Data ，然后点击 Apply。 <br />4.    点击 Profiling 选项卡，然后点击 Add...。 <br />5.    在下一个窗口中，输入 All 作为 Profile set name 并在 Description 域中输入 All of the data that's available。点击 Next。 <br />6.    下一个面板让您选择要收集的数据。展开所有选择，然后选中所有复选框，如图 8 所示。<br /><br />图 8. 要选择的度量<br /><br />7.    点击 Execution Time Analysis。 <br />8.    选择 Collect method CPU time information 复选框，然后选择 Show execution flow graphical details 选项。再次点击 Next。下一个窗口（见图 9）允许过滤掉您不感兴趣的类。<br /><br />图 9. 从分析中排除无关的类<br /><br />9.    出于这个例子的目的，点击面板顶部的 Add... 来添加一个新的过滤器集。将这个过滤器集命名为 No Monkey Business 并点击 OK。 <br />10.    点击规则列表右边的 Add... 在过滤器集中添加一个新规则。在 Class name 域中输入 example.SpaceShipToy 并在 Method name 域中输入 main（星号），选择 EXCLUDE 作为 Rule（见图 10），然后点击 OK。<br /><br />图 10. 编辑过滤器规则<br /><br />11.    在更大的窗口中，点击 Apply。 <br />12.    现在已经定义了要分析的应用程序和要收集的度量。点击 Profile。 <br />13.    在 Profiling and Logging 透视图中，点击 Memory Statistics 视图。应该会看到，根据刚才创建的规则，没有对方法 example.SpaceShipToy.main() 执行度量。 <br />提示和技巧<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 工具提供了丰富的特性，可以帮助您深入地了解应用程序。另外，因为 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 与 Eclipse 的其余部分很好地集成在一起，您会发现许多方便之处。<br />为了帮助您，下面提供一些提示和技巧。<br /><br />快速建立数据过滤器<br />启动一个分析会话并打开 Execution Statistics 视图。这个视图显示一个应用程序中的所有类和方法（至少是还没有在过滤器集中过滤掉的那些）。在这个视图中右击，打开图 11 所示的快捷菜单。<br /><br />图 11. 快捷菜单<br /><br />点击 Filter out...，选择 Profiling，然后点击 OK。在下一个窗口（见图 12）中，输入 Monkey Business 作为过滤器名并输入 build 作为过滤器字符串，然后选择 Filter by 下面的 Method name 选项。点击 OK 并再次点击 OK。<br />图 12. Edit Filter 窗口<br /><br />视图应该会改为只显示 example.SpaceShipToy$Monkey.build() 方法的统计数据。<br />要想恢复视图，再次看到所有方法，可以点击 Filter（见图 13）并选择 No filter。要想编辑任何过滤器，可以点击同一个按钮并选择 Manage filters...。<br />图 13. Filter 按钮<br /><br /><br /><br />跳到源代码<br />仍然留在 Execution Statistics 视图中。双击 SpaceShipToy$Booster 类。这时就会切换到 Java 透视图并直接跳到内部类 Booster 的定义。内存分析视图和 Eclipse 代码编辑器之间的这种连接是非常有价值的特性。<br /><br />高级的复杂过滤器<br />可以使用 Edit Filter 窗口的 Advanced 选项卡来构建任意复杂的过滤器。高级过滤器 是一系列规则，其中每个规则列出一个属性、一个条件（比如 “equal”、“not equal” 和 “like”）和一个值。您想知道一个实例消耗了多少内存吗？这可以用高级过滤器来表达。<br /><br />组织和排序<br />大多数数据视图可以按照包、类和方法对数据进行组织。通过点击大多数数据视图顶部的三个按钮之一（见图 14），可以快速地改变数据的组织方式。<br />图 14. 用于组织数据的三个按钮<br /><br />从左到右，分别是按照包、类和方法进行组织的按钮。<br />还可以通过点击任何列标题，对所有数据进行排序。点击列标题一次，就对这个列按照升序进行排序；再次点击同一个列标题，就按照降序显示数据。<br /><br />使用 UML2 序列图深入了解代码<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 提供了另一个对了解正在运行的应用程序有帮助的特性：UML2 序列图。这个图不但显示类和方法之间的调用序列，还可以突出显示热点，也就是消耗了大部分应用程序执行时间的代码部分。<br /><br />在序列图中查看代码<br />要使用 UML2 序列图查看代码：<br />1.    退出正在分析的所有玩具工厂应用程序实例。 <br />2.    点击 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profiling 按钮中的小箭头。选择 Profile...，选择 SpaceShipToy，点击 Profiling 选项，然后选择 All。 <br />3.    点击 Apply（如果需要的话），然后点击 Profile。 <br />4.    当应用程序在 Profiling Monitor 视图中启动时，右击刚启动的进程并选择 Open With... &gt; UML2 Thread Interactions 来打开 UML2 class Interactions 视图。因为这个应用程序刚刚启动，所以这个图只显示了对 main() 的调用，如图 15 所示。<br /><br />图 15. 只显示 main() 调用的简单 UML 图<br /><br />5.    切换到控制台视图并与应用程序进行交互，从而产生更多的方法调用。然后切换回 UML2 Trace Interactions 视图。UML 图应该已经增大了，可能与图 16 相似。<br /><br />图 16. 示例应用程序的 UML2 视图<br /><br />6.    将鼠标指针放在左边空白处中的红色条上，就会显示一个表示 CPU 时间消耗的刻度条（见图 17）。<br /><br />图 17. CPU 消耗刻度条<br /><br />7.    深红色表示最大。在这个应用程序中，SpaceShipToy 类的构造过程显然是瓶颈。<br />对对象引用进行编目<br />另一个对正在运行的应用程序进行分析的有用特性是 Object References 视图，这个视图显示应用程序中每种对象的引用数量。如果您的 Java 代码看起来消耗了过多的内存，那么收集并查看对象引用可以帮助您找到出问题的代码。<br /><br />使用 Object References 视图<br />使用 Object References 视图与使用其他 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 视图一样容易：<br />1.    终止正在分析的所有进程。 <br />2.    在 Profiling Monitor 中右击并选择 Unload Profiling Data。按照提示删除到目前为止收集的所有数据。 <br />3.    选择以前监视的所有进程并按 Delete。出现提示窗口时，选择 Do not delete contents，然后点击 Yes。 <br />4.    对玩具工厂应用程序启动一个新的分析会话。切换到控制台视图，然后按 1 2 9 来创建两个玩具和未被引用的第三个 “玩具”。 <br />5.    通过在 Profiling Monitor 视图中点击 Collect object references，收集正在使用的对象（见图 18）。<br /><br />图 18. Collect Object References 按钮<br /><br />6.    在 Eclipse 工具栏上，点击 Open Object References（见图 19）来打开 Object References 视图。Object References 视图列出应用程序中使用的每个对象和对应的引用数量。<br /><br />图 19. Object References 按钮<br /><br />7.    展开 SpaceShipToy。引用表应该与图 20 相似。已经创建了三个玩具，所以这个表是准确的，因为每个玩具包含一个推进器、一个太空仓（其中有两只猴子）和三级火箭。<br /><br />图 20. 示例应用程序在某一时刻的 Object References 视图<br /><br /><br />对本地 Java 应用程序使用 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b><br />除了对通过 Eclipse 工作台构建和启动的 Java 应用程序进行分析之外，还可以分析本地计算机上已经在运行的 Java 应用程序（应用程序也可以在远程计算机上，但是这里不讨论分析远程应用程序的过程）。可以通过 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 附着 到进程上。附着之后，就可以使用前面学习过的所有工具来探索和观察内存分配。<br /><br />附着到本地 Java 应用程序<br />要附着到本地 Java 应用程序：<br />1.    退出和删除 Profiling Monitor 视图中所有正在运行的进程。 <br />2.    打开一个命令窗口并确认 PATH 和 JAVA_HOME 环境变量指向 JRE。 <br />3.    确保 LD_LIBRARY_PATH 包含 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 库。在测试系统上，这些变量如下所示（根据您的系统配置，路径名和目录名可能不一样）：<br /><br />% printenv<br />.<br />PATH=/bin:/usr/bin:/usr/X11R6/bin:/home/mstreicher/java/jdk/bin<br />JAVA_HOME=/home/mstreicher/java/jdk<br />JAVA_DIR=/home/mstreicher/java<br />LD_LIBRARY_PATH=/home/mstreicher/java/tptpd/lib:<br /><br />4.    确保 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Agent Controller 正在运行。进入包含 Agent Controller 的目录，然后停止并重新启动这个守护进程：<br /><br />% cd $JAVA_DIR/tptpd/bin<br />% ./RAStop.sh<br />RAServer stopped, pid = 3163<br />RAServer stopped, pid = 3164<br />.<br />RAServer stopped, pid = 18108<br />% ./RAStart.sh<br />Starting Agent Controller<br />RAServer started successfully<br /><br />5.    将玩具工厂应用程序作为单独的独立 Java 应用程序运行：<br />o    进入包含示例应用程序的工作空间目录，可能是 $HOME/workspace/Toy Maker。在这个目录中，应该会看到一个称为 example 的目录，其中包含 SpaceShipToy.java 的代码和相关联的 .class 文件。 <br />o    将当前工作目录（.（点号））添加到 CLASSPATH：<br /><br />% cd $HOME/workspace/Toy Maker<br />% ls -F<br />example<br />% export CLASSPATH=.:$CLASSPATH<br /><br />6.    用 -XrunpiAgent:server=enabled 选项通过 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Agent Controller 启动应用程序。enabled 模式以普通方式启动 Java 应用程序并在后台运行控制器。（如果在附着到应用程序之前不想执行它，那么使用 controlled 模式。）<br /><br />% java -XrunpiAgent:server=enabled example/SpaceShipToy<br /><br />7.    返回到 Eclipse，然后点击 <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> Profile 按钮中的小箭头。选择 Profile...。在左边的列表中，双击 Attach - Java Process。 <br />8.    在下一个窗口中，在 Name 域中输入 Toys，然后选择 localhost 作为主机。点击 Apply。 <br />9.    通过点击 Agents 选项卡选择一个代理，如图 21 所示。<br /><br />图 21. 选择要附着的代理<br /><br />点击显示的代理（如果当前没有在分析其他应用程序或进程，那么应该有一个代理），然后点击 &gt;。为了保存这一修改，再次点击 Apply。<br />10.    通过点击 Profiling 选项卡并选择一个分析集，从而选择要收集什么数据。可以选择 All，就会采用前面创建的分析集。 <br />11.    点击 Apply，然后点击 Profile。Eclipse 应该会切换到 Profiling and Logging 透视图。 <br />12.    在大多数系统上，这时会出现与图 22 相似的窗口。<br /><br />图 22. Profiling 提示<br /><br />这个警告是正常的，它提醒您尽管已经附着到了这个进程，但是必须手工启动监视。为了启动监视，右击刚启动的分析进程，然后选择 Start monitoring。<br />13.    切换回命令窗口，与应用程序进行交互。再返回 Eclipse 查看正在运行的应用程序的分析数据。完成之后，点击 Terminate Process 按钮（见图 23）。<br /><br />图 23. Terminate Process 按钮<br /><br />将在命令窗口中杀死进程：<br /><br />% java -XrunpiAgent:server=enabled example/SpaceShipToy<br />.<br />Stage complete.<br />Start stage...<br />Stage complete.<br />Start stage...<br />Stage complete.<br />zsh: killed   java -XrunpiAgent:server=enabled example/SpaceShipToy<br />%<br /><br />结束语<br />本教程演示了如何通过分析代码来调整和改进 Java 应用程序。通过使用 Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b>，可以运行代码并探测哪些代码段浪费了内存并导致性能降低。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 还提供了其他工具，可以从大型日志文件中提取信息，以及自动地获取和分析测试结果。<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">TPTP</b> 中的其他工具包括一个记录-回放设施（可以测试在 Eclipse 下运行的应用程序的 GUI）和一个称为 XRay 的特殊分析器（专门用于分析源自 Eclipse 平台的应用程序）。</i></i></td></tr></tbody></table></td></tr></tbody></table><br /><img src ="http://www.blogjava.net/19851985lili/aggbug/94377.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/19851985lili/" target="_blank">☜♥☞MengChuChen</a> 2007-01-17 10:53 <a href="http://www.blogjava.net/19851985lili/articles/94377.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Eclipse WTP</title><link>http://www.blogjava.net/19851985lili/articles/94375.html</link><dc:creator>☜♥☞MengChuChen</dc:creator><author>☜♥☞MengChuChen</author><pubDate>Wed, 17 Jan 2007 02:44:00 GMT</pubDate><guid>http://www.blogjava.net/19851985lili/articles/94375.html</guid><wfw:comment>http://www.blogjava.net/19851985lili/comments/94375.html</wfw:comment><comments>http://www.blogjava.net/19851985lili/articles/94375.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/19851985lili/comments/commentRss/94375.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/19851985lili/services/trackbacks/94375.html</trackback:ping><description><![CDATA[
		<h2>Eclipse <b style="COLOR: black; BACKGROUND-COLOR: #ffff66">WTP</b></h2>
		<br />
		<span class="style7">
				<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">WTP</b>(Web Tools Platform )项目在eclipse平台上进行扩展，是一个开发J2EE Web应用程序的工具集。<b style="COLOR: black; BACKGROUND-COLOR: #ffff66">WTP</b>包含以下工具：<br />* 一个源码编辑器可以用来编辑HTML, Javascript, CSS, JSP, SQL, XML, DTD, XSD, 和WSDL。<br />* 一个图形编辑器用来编辑XSD与WSDL。<br />* J2EE项目构建器和一个J2EE向导工具。<br />* 一个Web服务创建向导和管理器，和WS-I 测试工具。<br />* 一个数据库访问，查询工具等。<br /><b style="COLOR: black; BACKGROUND-COLOR: #ffff66">WTP</b>由两个子项目构成:WST(Web标准工具集) 与JST(J2EE标准工具集) </span>
<img src ="http://www.blogjava.net/19851985lili/aggbug/94375.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/19851985lili/" target="_blank">☜♥☞MengChuChen</a> 2007-01-17 10:44 <a href="http://www.blogjava.net/19851985lili/articles/94375.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>