CN1761943A - 通过使用图形用户界面控件来组合Web服务的程序创建 - Google Patents
通过使用图形用户界面控件来组合Web服务的程序创建 Download PDFInfo
- Publication number
- CN1761943A CN1761943A CNA2004800074692A CN200480007469A CN1761943A CN 1761943 A CN1761943 A CN 1761943A CN A2004800074692 A CNA2004800074692 A CN A2004800074692A CN 200480007469 A CN200480007469 A CN 200480007469A CN 1761943 A CN1761943 A CN 1761943A
- Authority
- CN
- China
- Prior art keywords
- expression
- web service
- program
- packaging body
- computer
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/34—Graphical or visual programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Abstract
本发明提供了一种用于从Web服务建立程序的图形用户界面(GUI)接口。该与Web服务的接口在用户菜单中优选地由图标和文本表示。用户将代表Web服务的图标从菜单拖放到显示区域，并将该图标与代表其他程序实体(优选地为其他Web服务)的其他图标互连。优选地，在拖放之后在该显示区域内创建一更详细的图标。将在该显示区域内完成的互连图标的集合保存为一个新的程序实体。本发明还包括在测试模式下使通过模型的信息流可视化。
Description
技术领域
本发明涉及在万维网上编程。本发明尤其涉及使用GUI控件来组合网络程序对象(Web服务)以创建新的程序对象。
背景技术
万维网(Web)是目前流行的计算机连网平台，每天有数百万的人将万维网用于多种应用，从个人电子邮件和研究目的的“网上冲浪”到很复杂的商业和科学使用。发展出Web是为了使因特网的使用简单和容易。其概念是在用户(客户端)个人计算机(PC)处提供浏览器程序，以解释来自使用HTML和图形文件的主机服务器的信息。因特网提供通信手段以使Web客户机和服务器互连。
Web服务是可被服务器访问并且为客户群体实现功能的程序。在一个示例中，Web服务提供证券报价机信息。已知一Web服务可用的客户可访问该Web服务以实现一个操作，否则客户必须为此创建一个程序。由于Web服务可用，因此客户仅需知道如何与Web服务接口，并且客户可将Web服务的功能并入自己的本地应用。
为了知道如何与Web服务接口，程序员需要理解接口语言。一种这样的语言是Web服务描述语言(WSDL)(根据存在于Web上www.w3.org/TR/wsdl处的W3C标准)，其是一种基于XML的语言，用于描述与Web服务的接口。作为服务器的内容提供者运行的Web服务向客户程序提供WSDL文档。该WSDL文档定义了接口模式，从而客户可知道Web服务接口所需的格式、协议等。客户需要理解Web服务的功能(例如其提供证券报价，并且数据被加密)。每个Web服务还定义了自身的术语。
Web服务接口语言使得程序员更容易编写代码以将Web服务的功能并入定制的程序，但是，需要编程知识(WSDL、XML、HTML等)来实现这一点。
发明内容
本发明的目标是简化使用Web服务的程序创建。本发明提供了用户可用的Web服务(或可选地其他程序)的列表(菜单)。程序员使用一创建器程序，该程序为本发明将支持的每个Web服务创建图标支持。一菜单放置器功能将创建的图标放置在菜单内。还为非Web服务的定制程序创建图标。这种图标可用于提供例如音频、视频、机械接口。通过授权代理或从内容提供者获取图标，使图标对于用户可用。优选地，每个图标均由标题以及支持性描述文本来表示。该标题以及可选的描述文本在用户的客户计算机与相关联的通用图标图像一起显示。该图标包括对程序代码的访问、Web服务接口控件、以及可视特性。
用户选择图标标题并(使用UBI移动器)将其拖入框架(画布)。然后，用户可在该框架内执行该图标以检测其功能。用户可将该图标与该框架内的其他对象互连(使用互连器GUI 1506)，以创建新的功能。当将图标拖到框架内时，优选地创建更详细的图标，该图标可见地显示了接口选择(如果适用的话)，从而当用户互连该对象时，用户可通过选择(使用GUI选择器)合适的可视表示来选择(例如)英语或西班牙语语言转换。用户可使用参数设置器GUI来设定合适的参数以定制所选择的图标的功能。在一个实施例中，用户使用显示启动器GUI来显示图标的参数选项；然后，使用在参数显示上操作的操作器，用户设定合适的参数；最后，用户使用退出器GUI来退出参数显示。
在一个实施例中，用户可检测定制的图标的功能。用户使用启动器GUI来启动该检测。执行该检测，并导致GUI修改器修改显示的视觉表示以便根据检测功能来指示该图标的功能状态。该显示可改变颜色、亮度、文本消息显示，可进行形状改变或实现声音表示。
在一个实施例中，由表示保存器将互连的图标保存为封装体(capsule)表示。被保存的封装体表示进一步由封装体图标表示，从而可将其添加到用户的可用图标列表内。
当用户满意框架内的互连图标的功能时，用户将该框架结构保存为命名的程序实体。将来，用户可将该命名的程序实体作为单个对象来执行。
在一个实施例中，可给该命名的程序实体本身分配一个图标，从而在新框架的拖放创建中可使用该命名的程序实体。
因此，本发明的一个目的是为Web服务提供具有可选的可视属性的拖放图标。
本发明的另一个目的是提供一种用于互连拖放图标以创建新功能的机制。
附图说明
从下面结合附图对本发明的详细说明，本领域内的技术人员可清楚地了解本发明的这些以及其他目的，在该些附图中：
图1是用于执行程序应用的计算机系统的高层描述。
图2是使用大量互连的计算机系统的计算机网络的高层描述。
图3是使用本发明的GUI显示的示例性视图；
图4放大了图3的一部分以描述一图标列表；
图5放大了图3的一部分以描述从图4的列表中拖出的互连图标；
图6示出启动和保存图标的流程；
图7示出创建互连的一组图标的流程；
图8示出执行互连的一组图标的流程；
图9示出访问SOAP封装体的流程；
图10示出封装体的WSDL生成的流程；
图11示出SOAP桥的流程；
图12示出IDS请求的流程；
图13示出服务器流程的一个示例；
图14示出一直线流；
图15示出一单记录流，其中任务在不同的计算机上并行执行；
图16示出一多记录流，其中任务在不同的计算机上并行执行；
图17示出一并行流；以及
图18示出具有开关操作器的流。
具体实施方式
图1示出一可用于Web或因特网对等网络通信以及执行面向对象的程序例如本发明的那些程序的示例性计算机系统。该系统包括处理器106，该处理器用于执行从存储器105取得的程序指令。存储媒体107(磁的或光的)用于保存当前没有被处理器106操作的程序和数据。基计算机(basecomputer)可选地具有外围设备，该些外围设备连接在该基计算机上以提供用户接口。通常，外围设备包括显示器102、键盘104和网络连接108。可选地，鼠标103、打印机/扫描仪110也连接到该示例性计算机系统上。存储媒体107中保存的程序111被页入(page into)到存储器105内以便处理器进行处理。程序111包括操作系统和包括例如本发明的应用的应用。面向对象的程序是在运行期间生成程序对象的程序。这些对象被保存在存储器105中以便由处理器执行。图2示出多个通过本发明可使用的本地网络和因特网网络互连的不同设计的计算机系统。客户计算机201-205直接与用户交互，并提供了用于请求信息的装置。服务器206-207接收客户请求，并作为响应执行操作。该操作可以是仅检索信息(例如构成网页的HTML、GIF文件)，提供到因特网网络的路径，或触发在服务器上运行的定制程序(CGI脚本)或在客户计算机上运行的JAVA小应用程序。
还存在对等网络，其中一计算机可作为客户机和服务器运行，从而使得计算机可直接通信。
术语表
UDDI(通用描述、发现和集成)是Web服务和Web上的企业名称、产品以及位置的基于XML的注册库。
WSFL(Web服务流语言)是由IBM设计的用于描述Web服务组合的基于XML的语言。其依赖于并补充其他规范例如SOAP、WSDL、XMLP和UDDI等。
SOAP(简单对象访问协议)是用于交换信息的基于XML的协议。SOAP包括一包封(envelope)，该包封定义了一个用于描述消息以及如何处理消息的框架、编码规则以及用于代表远程过程的约定。
XMLP是一组控制XML消息的格式和处理以及应用交互的正式约定。
IDS(智能决策服务器)，也称DIS(分布式综合解决方案)，见转让给IBM的美国专利6094655(Roger等人)“Method of creating and usingNotes decision capsules”。IDS执行所选择的身为串在一起的封装体元件的程序封装体。
Web服务是通常可利用万维网从远程服务器得到的应用。Web服务优选地使用WSDL(描述Web服务的接口的基于XML的文档)对自身进行描述。提供目录(在概念上，其相当于电话号码簿)，从而可用户可发现可用的服务，优选地为UDDI。还提供了用于在Web服务和其客户之间通信的工具，优选地为SOAP。
本发明是在Web服务环境以及以下文献中说明的现有技术上发展而来的：
美国专利6094655“Method of creating and using Notes decisioncapsules”(Roger等人)；
美国专利5710918“A method for distributed task fulfillment of Webbrowser requests”；
美国专利5701451“A Method for fulfilling requests of a webBrowser”；
美国专利5721908“Computer network for WWW server data accessover Internet”；
美国专利5752246“A service agent for fulfilling requests of a Webbrowser”；
美国专利5745754“A sub-agent for fulfilling req uests of a Webbrowser using an intelligent agent and providing a report”；以及
美国专利5974441“WWW client server interactive system methodwith Java”。
所有这些专利都转让给了美国国际商业机器公司(IBM)，并且被并入本文中作为参考文献。
随着Web服务在因特网上的出现，使用这些服务建立新应用成为一种新的开发应用的方法。通常，Web服务由独立的组开发，而以有意义的方式将这些服务组合在一起并不容易实现。本发明允许非开发人员在一个“封装的”过程流(process flow)中创建、组合、包装并一起使用这些服务。本发明提供了一种用于组合和封装可能从未打算合作的Web服务的方法。
本发明提供了一种定义Web服务之间的连接，并建立(Web)服务工作流的组合的方法。这些通过连接而组合的服务被成为封装体(在一过程流中连接在一起的Web服务序列)。在我们的方法中，一Web服务的输出被原样获得，并用作另一个Web服务(或一组并行的Web服务)的输入。或者，可选地，一Web服务的输出在被用作另一个Web服务的输入之前被转换和变换。变换器是本地服务的功能(成套工具的一部分)，或者在另一实施例中，变换是由变换器Web服务实现的。这些Web服务的组合或封装的过程流(封装体)均可由不需要具有程序员的技能的用户(使用我们提供的工具)使用“可视流构造器”(用于Web服务的封装体)构建。在一个实施例中，该工具具有UDDI集成，从而用户可访问因特网上的任何Web服务，并将该服务并入它们的封装体内。然后保存该封装体以及其所有属性以便以后使用。该保存的封装体或者在工具内被检索并执行，或者作为一Web服务被导出以便可被其他应用使用(例如经由UDDI)。在该工具内执行还可用于调试目的。该工具在执行一个流时向用户提供信息反馈。例如，在封装体执行时，通过突出显示当前执行的Web服务来描述从Web服务到变换器到Web服务的事件的流。在一个实施例中，当Web服务执行时，代表该Web服务的可视图标是绿色的，当Web服务空闲时图标是白色的，而在Web服务检测到错误时图标是红色的。
本发明提供了一种非编程装置，用于将Web服务组合(封装)起来，以开发可以是部分或全部应用、或者“超级”服务(然后可作为一个Web服务被提供的Web服务组合)的过程工作流。
本发明提供了一种用于定义这些服务组合(封装体)的方法，从而可创建、查看和修改这些组合。(可视流构造器)。
本发明提供了一种用于保存和检索这些封装体以便进行修改、分发(例如，分发给UDDI注册库或Web应用或产品)和/或执行(带有调试能力)的方法。
本发明提供了一种用于在因特网(或互联网)或环境组合上执行具有可视反馈的过程工作流(封装体)的方法。
系统以下面的方式创建Web服务图标。根据对Web服务的WSDL的分析，系统了解Web服务的(一个或多个)方法的签名和返回类型。然后，系统创建该方法的文字/图标表示。在一个实施例中，每个方法都是一多行的框。第一行是Web服务的名称，第二行是方法的名称和返回类型，第三行和余下的行(如果存在的话)代表输入参数的类型。
创建本地Web服务目录：
Web服务封装体构造器提供了三种用于将可用的Web服务编目的方法。第一种方法是查询UDDI服务器(Web服务的事实上的目录)。第二种方法是借助于使用基于XML的文档的文件系统。第三种方法是通过在可视WSDL创建器中输入一服务的所有方面，来将该服务添加到本地目录中。不管使用什么方法，构建服务封装体是通过首先收集建立希望的流所需的所有服务来完成的。服务封装体构造器301的左边面板302是WSDL浏览器，其提供用于查看服务和可从这些服务得到的方法/功能的一般界面。
可利用本技术领域中已知的方法来创建可用Web服务的本地列表302。例如，可通过从可从一网站得到的中心列表中选择来手动地创建该列表。该列表可以层级分组的形式提供，以便易于导航。
在一个实施例中，参照图4，定制的Web服务封装体浏览器工具从本地文件目录或经由HTTP或FTP或UDDI远程站点查询可用的WSDL文档，根据用户输入的标准来分析该些文档，并创建代表Web服务401-406的Web服务图标的列表302。每个Web服务(例如BlueMail 402)可具有一个或一个以上暴露的方法，该方法由显示为该Web服务的子节点的方法图标(对于BlueMail 402，为“*xsd：string send...”)表示。例如，用户从该定制的Web服务浏览器中的菜单中选择File/Import WSDL，浏览到一文档目录并选择Number2Text.wsdl。然后，系统读取该WSDL，对其进行分析，并创建一个具有getNumber2Text方法作为其子节点的Number2Text Web服务节点。Number2Text Web服务节点由一Web服务图标(铃铛)表示，而getNumber2Text方法由Web服务方法图标(球或*)302表示。
构建封装体：
给定一填充了的服务列表302，则可开始封装体的构造。创建一新的Web服务封装体303完成了两方面的工作。首先，其提供了这样的空间(称为封装体画布)，在该空间内可安排、链接。查看或测试单个服务，其次，该封装体用作该服务的命名的容器。即使可使用多个Web服务来定义一个封装体，但是封装体本身303代表了单个服务。因此，通过创建封装体303，就创建了一个Web服务，该Web服务的功能是其包含的服务501-503的流。
参照图5，在将一Web服务图标拖放到新的封装体303的流构造区内之后，优选地创建一更详细的图标，该图标优选地包括两行或更多行。每行均提供一用于选择用于该Web服务的选项的GUI手段。选项可包括参数选择、文本个性化，或用于使一个以上的输入或输出与该Web服务图标互连的可选择的互连接触点。例如，“翻译器”Web服务502具有5行。第一行505是该Web服务的名称，在此情况下是“翻译器”。第二行506是方法的名称和返回类型，在此情况下，该名称为“翻译”，而该返回类型为“xsd：string”。第三行507到第五行509是方法签名，在此情况下为“xsd：string mtlang”507、“xsd：string text”508、“xsd：string option”509。“xsd：string”是输入参数的类型。Mtlang 507是将要翻译成的语言。Text 508是将翻译的文本。选项509是输出的格式，文本或HTML。例如，为了调用此Web服务以便将文本从英语翻译成西班牙语，用户需要右键点击第三行507，其生成一弹出窗口(未示出)。然后用户在该弹出窗口中将mtlang设定为Spanish。接下来，用户右键点击第四行508，并将文本设定为希望的词/句。最后，用户右键点击第五行509，将选项设定为“text”、“HTML”或让其空白。
应理解，XSD是一XML前缀，其指示XML模式名称空间“www.w3.org/2001/XMLSchema”，并符合XML模式约定。“xsd：item”，例如xsd：string，用于标识输入参数的类型或返回方法的类型。
在用户将Web服务拖放到流面板(画布)内、连接这些Web服务并设定所需的输入参数之后，就创建了一封装体。在后台，还创建一代表Web服务对象以及Web服务之间的交互的图形数据结构。当用户从File菜单选择Save或Save as时，使用Java对象串行化将该图形数据结构作为WSFL保存到硬盘中。在一个实施例中，保存的封装体可被添加到用户的Web服务菜单302中。
将Web服务401-406从服务列表302拖放入封装体画布303会可视地实例化资源，并且在一优选实施例中为Web服务创建详细的图标。其由该服务的名称、从该服务504-517使用的功能、以及该服务运行所需的输入和输出表示。在此示例中，将“Number2Text”服务501拖入封装体画布303。此服务取得一个数字并用英语拼出该数字(例如，输入“1”变为输出“one”)。使用一个数字—在此情况下为号码1-来初始化Number2Text501。如果该封装体作为一个Web服务被调用(见调用/使用封装体)，则也可指定此数字。
然后，将翻译服务“翻译器”502拖入封装体画布303。将Number2Text501的输出连接到该翻译器的输入。手动地将该翻译器设置成将英语翻译成西班牙语。如果运行此封装体或服务流，则它会调用该Number2Text服务501并返回“one”。它会将该结果传给翻译器服务502并将“one”翻译成“uno”。在该流执行时，突出显示当前的服务，并且连接箭头用红色和绿色可视地指示成功和失败。可以可视地检查和分析从一个服务到另一个服务的流。随着封装体复杂性的增加，这被证明是非常有教益的。可利用多种本技术领域内的技术人员熟悉的方法来实现执行可视化。可添加动画来显示在测试中的功能。可利用声音来扩充该可视表示，以进一步提高功能的可视化。例如在当前的示例中，动画人物例如行走的人形可将消息从图标传送到图标，同时被突出显示的图标或互连表现了正被可视化的项目。然后，计算机用话音消息如同动画人物在评论那样指示，例如当可行时指示“看起来很好”，当怀疑存在问题时指示“唔-哦”，或甚至指示描述可能的改正“你还没有告诉我在’翻译器’步骤中使用哪种语言”的话音消息。
通过将“BlueMail”服务503(因特网邮件服务)拖入画布303，提供了一个将该流的结果用电子邮件发送给收信人的机制。在此情况下，将收件人(to)字段512设定为webahead@us.ibm.com。将发件人(from)字段515设定为Web服务封装体：email-test.wsfl。将主题(subject)字段516设定为Number2Text Translation Test。最后，将翻译器502的输出连接到电子邮件服务503的消息输入。在此时，运行该封装体可实现与上述相同的功能，不过另外还将结果用电子邮件发送给webahead@us.ibm.com。
最后被拖到封装体的画布303中的项是可视报警修改器518。在一个实施例中，该可视的报警图标可从用户的工具栏411得到。在其他实施例中，用户的浏览器包括这样的本地程序的列表，该些本地程序可以与来自Web服务列表302中的Web服务相同的方式被拖入画布，并且添加到流中。修改器是交互地改变流的项目。在此示例中，报警修改器518仅利用邮件服务的结果输出生成一“报警”对话框。该修改器518将通过报警对话框将因特网邮件操作的成功或失败告知用户。其他的修改器可取得一字符串并将其转化为整数(例如“001”变为1)。
调用/使用封装体：
对于完成的Web服务封装体303，可用三种方式中的任何一种调用它。第一种方式是手动运行。这涉及按下“play”按钮或类似物。第二种方式是以定期的方式调用封装体。例如，可每隔一个小时调用服务。第三种方式是通过SOAP服务器插件调用封装体。该SOAP服务器插件提供了两个功能。一个功能是能够作为UDDI服务器被查询。当客户请求所有开启的服务/封装体时，插件将返回遵循UDDI和WSDL标准的动态生成的响应。当查询服务器时，该服务器将发送封装体名称作为服务名称，作为由将被调用的第一服务确定的输入列表的输入，以及由最后一个服务的输出限定的输出。另一个功能是SOAP插件担当一接口来运行封装体，就好像封装体是Web服务似的。当外部客户请求SOAP服务器插件。后者转而调用指定的封装体时，会发生调用。通过这种方式，封装体可用作新封装体的组件。本发明的一个部分是IDS SOAP桥，其为IDS提供了类似的功能。IDS是基于封装体的报告环境。该IDS SOAP桥提供了对IDS的SOAP访问。由于该桥将其本身公告为Web服务，因此IDS封装体可被集成到封装体流中。
参照图3，在优选实施例中，Web服务封装体构造器GUI 301包括两个框架302、303。一个框架显示可用于构建新的封装体的可用服务的服务列表302。另一个框架显示封装体303，在封装体完成时其将包括来自第一个框架的互连的服务。
参照图4，其示出服务列表302的一优选实施例的示例。该服务列表包括可用于封装的服务401-406。在一个实施例中，该些服务包括远程服务和本地Web服务的混合。可拖入容器的、该列表中的每个服务均由一图标指示。一些服务401、402、405还包括关于该服务的附加信息。
参照图5，其示出已由本发明创建的示例性封装体303。已将三个Web服务501-503放入该封装体303，并且用户已将这三个服务互连。本地服务518已被放入并连接到第三个Web服务503的输出。
参照图6，其示出服务流初始化。向UDDI服务器查询可用的服务(步骤601)。使用查询的结果，用候选的Web服务图标更新本地服务目录(步骤602)。用户可使用该本地服务目录来向服务列表302选择性地添加服务。
一旦在封装体303中创建一新的服务流(步骤603)，则将其保存在本地文件中以便将来使用(步骤604)。在优选实施例中，用基于XML的WSFL语言描述该新的流。将该命名的封装体可选地添加到服务列表302中，来作为一个可拖入新的封装体303的新服务流。
图7中示出创建一服务流封装体的示例。在步骤701，在GUI显示301中打开新的封装体303。在步骤702，将第一服务拖放入该封装体303。在步骤703，将第二服务拖放入该封装体303。在步骤704，将该第一服务的输出连接到该第二服务的输入。在步骤705，选择用于该第二服务的选项。在步骤706，将第三服务拖放入该封装体303。在步骤707，将该第三服务的输入连接到该第二服务的输出。在步骤708，将第四服务拖放入该封装体并使该服务与第三服务相连接，该第四服务是一本地服务。该封装体完成。在步骤709，可手动地运行该封装体以验证其功能。
图8示出服务流的执行。在步骤801，通过GUI显示打开并示出一服务流。可通过按下GUI“play”按钮420(在步骤802)或通过SOAP服务器插件(步骤803)来运行该服务流。
图9示出示例性的Web服务流SOAP服务插件的操作。在步骤901，接收到对封装体的请求。在步骤902，对照本地已知的服务检查该名称空间。如果没有发现封装体，则报告异常。如果发现一封装体(步骤903)但是没有加载该封装体，则从该封装体的源加载该封装体(步骤905)。当加载了所请求的封装体时，可执行该封装体(步骤906)，并返回该封装体的执行结果(步骤907)。
图10示出Web服务流的WSDL生成。在步骤1001，接收到对命名的封装体的“WSDL”的请求。在步骤1002，对照已知的服务检查该名称空间。如果没有发现封装体(步骤1003)，则报告异常。如果发现一封装体但是没有加载该封装体(步骤1004)，则在步骤1005，加载该封装体。在步骤1006，可选地检查该封装体的输出和输入，并且在步骤1007，返回动态生成的“WSDL”。
图11示出IDS SOAP桥流。在步骤1101，接收到对“IDS”操作的请求。在步骤1102，提交对“IDS”系统的操作请求。在步骤1103，返回“IDS”对象或指定的数据类型，并且在步骤1104，返回用于异步操作的可选的跟踪令牌。
图12示出经由ISB获取异步请求。在步骤1204，接收到对经由跟踪令牌的“IDS”操作的请求。在步骤1205，检查“IDS”服务器操作。如果不允许经由该令牌的操作(步骤1206)，则报告异常。如果允许经由该令牌的操作，则返回“IDS”对象或指定的数据类型(步骤1207)。在步骤1208，返回可选的完成百分比的信息。
尽管对于理解本发明不是必须的，但是在附录A中提供了一示例性的实现。版权所有者并不反对相关专利事务所内的任何人进行摹真复制，然而在别的方面却保留所有版权权利。
下面给出对该文档的简短描述：
Block.java＝＝这个类提供了Web服务的构件块的基本实现。
DragTree.java＝＝这个类提供了可从其中拖动服务对象的树组件。
FlowPane.jave＝＝这个类实现了用户可在其中拖放Web服务对象或者设置该Web服务对象的属性的工作区。
Link.java＝＝这个类实现了Web服务对象之间的连接组件。
Operation.java＝＝这个类提供了Web服务方法调用的表示。
ParamInputDialog.java＝＝这个类提供了用于向Web服务方法调用设置参数的对话框。
Service.java＝＝代表一Web服务对象的核心类。
WorkFlowFrame.java＝＝这个类代表包含一个FlowPane的内部框架。
WorkSpace.java＝＝这个类代表包含工作流的集合的工作空间。
提出了根据本发明创建的封装体的一些应用。在一个实施例中，经由网络协议例如SOAP、RPC、HTTP接收到的远程请求调用根据本发明的Web封装体。
在另一个实施例中，封装体的元件并不阻止封装体的成功执行和/或对外部请求的响应。
在另一个实施例中，通过为远程应用提供WSDL表示来将根据本发明的封装体集成到远程应用。这种WSDL可被动态生成。
在另一个实施例中，图标与封装体修改器相结合。封装体修改器可表示逻辑非、与、或、异或、与非。此外，封装体修改器可包括并行、开关和数据连接。
根据本发明的封装体Web服务由一个或多个资源(资源可以是其他Web服务、开关/并行路径以及其他“内置的”功能例如GUI报警或媒体播放)构成，所述封装体Web服务由于提供一种从外部(远程)资源调用封装体流的方法而被增强。下面的示例说明了远程系统/用户如何与本发明相交互来利用Web服务封装体流。
从远程计算机调用一封装体流。该远程计算机使用网络协议与主机通信。在一优选的实现中，该远程计算机能够进行一连串“调用”，来请求可用的服务封装体的列表，和如何调用特定封装体的特定细节，或者进行调用封装体的实际请求。这些“调用”事务优选地是根据公开的当前技术标准的HTTP上的SOAP。
远程计算机向封装体环境查询可用Web服务流的列表。远程计算机优选地向所有可用的封装体发送一个一般请求。此请求可选地更具体，例如仅请求例如所有以字母“A”开头的封装体。主机服务器返回的响应是与该初始请求相匹配的服务的列表。优选地，这可使用UDDI请求和响应来完成。
在一个实施例中，远程计算机对在封装体环境中寄居的一特定封装体进行查询。远程计算机发送一个查询，该查询指定了用于该封装体服务的特定标识符。来自主机的响应是一个文档，该文档足够详细地定义了给定服务封装体的输入和输出，以随后向主机系统发送调用请求。优选地，该响应使用WSDL标准来完整地描述封装体期望的输入和输出。
远程计算机调用在封装体环境中寄居的封装体服务流。该远程计算机指定其希望调用的特定封装体服务，和由先前的对服务描述(WSDL)的调用指定的所需的任何参数。对该调用请求的响应由该服务描述限定。在一优选的实现中，此事务使用HTTP上的SOAP和WSDL来通信和描述。
例如：
计算机A查询计算机B，来请求所有可用的服务(封装体流)。计算机B以可用封装体Web服务流的列表作为响应。计算机A决定使用计算机B上的服务A。计算机A对计算机B进行适当的调用，来调用该封装体流(服务A)作为Web服务。计算机B执行该封装体流并将结果返回计算机A。
在一个实施例中，本发明的Web封装体被外部集成，并且在客户机侧或在服务器侧被可视地设计、配置和管理。
经由Web服务接口远程访问封装体优选地使用HTTP上的SOAP完成。在优选实现中，服务器模仿HTTP协议，适当地响应任何格式正确的请求。当一消息的目标是一封装体服务时，如果该消息不是一个格式正确的SOAP消息，则该服务器返回一错误。通过相同的用于构建封装体的拖放界面来管理此服务器的消息流。
图13示出一Apache Web服务器的服务器事件流。这是服务器如何经常具有一系列步骤需要完成以生成响应的示例。与此类似的服务器或流都能够利用封装体的概念来提供高的可定制性和灵活性。对于流中的每一步骤，用户会将图标拖放到桌面上来完成此系统。例如，可开发一个定制的认证机制，其中将该机制拖放在打算发生认证的点上。另一个进行内容编码的图标，可被拖放在该流的末端。内容编码获取一组数据，并以特定方式将其编码。在此例中，它可应用压缩算法。此外，这些图标可实际表示和执行其他流。对于图13中所示的Apache流中的每一步骤，将代表一个模块。这个流被认为是线性流。
参照图13，下面的一组事件说明了一个简单的HTTP流；接收消息1302，分析消息1304，检查被请求的资源，响应消息1310。当然，可使用由Rogers等人定义的封装体桌面来管理任何事件流。所提供的拖放模块之一可以是认证处理器。在一个优选实施例中，服务器流接收请求消息，对该消息解码，检查以确定资源存在，然后响应该请求。希望对某些请求限制访问。将认证处理器(模块)拖放到流内将提供此功能。该流变为：接收请求1302，分析消息1304，检查认证1306，检查资源1308，然后响应1310。该流也可按不同的顺序进行：接收请求，分析，检查响应，检查授权并然后响应。此外，如果需要的话，检查授权和检查资源可并行执行。响应模块1310将仅以这两个“检查”模块的结果作为输入，来确定合适的响应。
如图13所示，请求1301被处理并变为阅读后的请求1302。在1303转换该请求，并在1304分析头部。在访问控制1305之后，在1306检查认证并在1307检查授权。检查文件Mime类型并且结果通过修正阶段。响应1310被发送给请求1301，并在1311被记入日志。在1312进行清除，并且在1313系统等待一个新请求。在每个阶段，如图所示在1311将过程记入日志。
在一个实施例中，Web封装体在远程机器中运行。其他机器是群集的或网格使能的。
在一个实施例中，已创建根据本发明的Web服务封装体，则在远程封装体使能的服务器上执行该封装体。用户将该封装体拖放到封装体桌面的一个区域内以使能网络连接。拖放仅是启动网络连接的一种方式。还可简单地创建一网络连接并发送请求。
从本地桌面到远程服务器的通信包括使用网络协议到一个或多个服务器的网络连接。在一优选实现中，此网络连接将使用HTTP上的SOAP。
远程服务器被单独表示为或组合为一个一般“服务器以太”(serverether)。用户将选择的封装体流拖放到表示一个单独的远程服务器或群集的组的图标上。这启动一个网络请求以处理该Web服务封装体。在一个优选实现中，群集的组随机地选择一个服务器以在其上执行该封装体，或者可选地在每个服务器上执行该封装体。
然后将封装体发送给远程服务器以便执行。在一个优选实现中，该封装体是在XML消息中描述的，该消息包括必要组件的身份，将调用哪些Web服务，可在何处发现这些Web服务，将以什么顺序调用它们以及将哪些结果传送给哪些Web服务。
在一个实施例中，所述结果是在流中最后执行的服务的结果。这类似于远程访问封装体的情况。在另一个实施例中，该结果可以是捕获了该流的每个请求和响应消息的文档，从而可在本地机器上严格地重放这些事件。在一个优选实现中，后面的响应也被以XML编码，并包含具有时间编码以精确地捕获被远程执行的流的原始SOAP包封。
在一个实施例中，Web服务流顺序执行(如在图14中的封装体中所示)。单个记录1401向求和图标1402提供信息，然后向均值图标1403并最终向中值图标1404提供信息，并且由结果图标1405提供结果。每个图标均被个性化以执行所需的功能，包括“null”，其将记录传递到下一个阶段。
在一个实施例中，Web服务流并行地执行。此功能由封装体修改器提供。
在一个实施例中，提供一并行执行修改器(图14)。给定单个Web服务调用1501，随后可有多条并行路径。然后在1505，或者通过另一个Web服务调用/封装体或者经由一数据规范器来吸收一个或多个路径的结果。数据规范器获取多个数据输入并以可用的方式格式化该数据。例如，如果求一组数据的和1502、中值1504和均值1503，并且并行计算，一优选的规范器1505可被配置为仅存储最低值。在另一个实施例中，来自所有路径的结果1506被存储，作为该服务调用的最终值。在一优选实现中，该结果1506为一XML文档，其代表由封装体流的结果定义的数据结构。在一优选实现中，任何上述修改器中遵循由封装体环境提供的其他窗口小部件的模式，例如报警对话框。
更复杂的流可能包括并行功能(图15)。图15示出在同一组数据上执行的一组统计操作。在此情况下，求和、中值和均值是打算在单独一组数据上运行的单独的Web服务。该数据没有改变，并且来自一个服务的输出不作为输入流入另一个服务。该封装体已被安排为并行执行Web服务。这通过将初始输入连接到每个服务上来实现。其结果是合并功能的输入，该合并功能使数据相结合。并行执行可优化封装体的总性能。
在一个实施例中，通过使用GUI显示指点设备例如鼠标画出互连线来使图标互连。在另一个实施例中，通过在显示工具栏上选择互连功能或利用每个图标具有的手段，来使图标互连。
在一个实施例中，使用一修改器块1506。在图15的示例中，修改器块是被拖到封装体中的图标。第一图标1501连接到该块的输入A，该块的输出C、D和E连接到它们各自的块1502-1504。这种块可具有多个输入和多个输出。该块可具有预定的功能(互连)，或者可以是实现转换、过滤、监控或除了流互连之外的任意多个有用服务的功能图标。
用户可在适当时拖放多个服务图标，并使起始输入连接到多个分支。使用数据合并修改器或其他Web服务封装体，可将该些分支的输入合并成单个结果。在一个实施例中，此结果为一XML。
当需要在相同或不同的数据集上执行多个操作时，可获得进一步的功能分配。图16示出使多组数据需要同样的统计生成的解决方案。因为数据集的数量大于1，所以流可利用其他封装体服务器以执行最初的并行查询。这利用了封装体流中的并行功能，但是也将服务封装体执行分配到多个封装体服务器上。
在另一个实施例中，执行的Web服务流带有开关功能。此功能由封装体修改器提供。
在一个实施例图18中，提供了开关修改器1802。该开关修改器1802检查给定变量或事件的状态，以确定在哪个路径上继续执行。例如，Web服务调用的结果是三个不同值之一。根据此调用的值将遵循不同的执行路径。例如，结果A分支到第一路径，结果B分支到第二路径而结果C转到第三路径。还存在其他的可能性，并且本发明决不是由此示例限制。在图18的示例中，将记录1801提供给开关1802，该开关确定是否执行作图或求和操作。此开关然后根据开关1802的个性化，来将消息发送给求和图标1803或作图图标1804(或这两个图标)。在1805，合并且报告该结果。
开关功能提供了另一种根据流的值或状态控制封装体的分支的方法(图18)。给定另一个统计示例，可使输入的请求指示数据的求和或图形表示。使用该开关修改器，提供了一种与其中执行每个路径的并行功能不同的分支机制。开关提供了能够返回多个结果的单个封装体。此外，其使得流设计者能够在存在特定条件的情况下执行不同的分支。例如，封装体设计者可决定应根据一天中的时间来执行不同的分支。封装体设计者生成它们的流，并使用开关修改器来连接它们。可设定封装体修改器中的条件以检测时间为AM还是PM。根据其结果，执行分支中的一个。该示例是一个简单化的示例，但是说明了该开关可由任意数量的事件、其他封装体的输出、时间以及作为执行的一部分传递的参数触发这一点。
在另一个实施例图16中，记录1601可与在另一条路径中顺序执行(求和1612、均值1613，然后中值1614)的其他记录并行地由任何一条路径顺序执行(求和1602、均值1603，然后中值1604)。
在另一个实施例中，通过向并行图标1702、1703、1704提供多条互连线来指示记录1701的并行执行，并且通过将该些并行图标的输出提供给结果图标1705来合并1705该结果。
尽管已示出和说明了本发明的优选实施例，但是应理解，本发明并不局限于文中所公开的准确结构，并且“保留”在所附权利要求限定的本发明的范围内进行一切改变和修改的权利。
附录
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import java.awt.Point；
import java.io.Serializable；
/**
*该类提供了Web服务的构件块的基本实现。
*/
public abstract class Block extends Object implements Serializable{
int x；
int y；
Link outLink；
boolean running＝false；
final static int marginLeft＝6；
final static int marginTop＝3；
/**
*构造函数
*/
public Block(){
}
public void setLoc(int x，int y){
this.x＝x；
this.y＝y；
}
<!-- SIPO <DP n="20"> -->
<dp n="d20"/>
public int getX(){
return this.x；
}
public int getY(){
return this.y；
}
public Link getOutLink(){
return this.outLink；
}
public void setOutLink(Link link){
this.outLink＝link；
}
public void setRunning(boolean value){
this.running＝value；
}
public abstract Point getOutPoint()；
public abstract Point getInPoint(int index)；
public abstract boolean isDragingTitle(int posX，int posY)；
public abstract boolean isDragingOutput(int posX，int posY)；
public abstract Object execute()；
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import javax.swing.*；
import javax.swing.event.*；
<!-- SIPO <DP n="21"> -->
<dp n="d21"/>
import javax.swing.plaf.metal.*；
import javax.swing.tree.*；
import java.awt.*；
import java.awt.datatransfer.*；
import java.awt.dnd.*；
import java.awt.dnd.peer.*；
import java.awt.event.*；
import java.io.*；
/**
*该类提供了可从其拖出服务对象的树组件。
*/
public class DragTree
extends JTree
implements TreeSelectionListener，DragGestureListener，
DragSourceListener{
/**存储组件的父框架*/
private WorkFrame parent＝null；
/**存储选择的节点信息*/
protected TreePath SelectedTreePath＝null；
protected DefaultMutableTreeNode SelectedNode＝null；
/**拖动所需变量*/
private DragSource dragSource＝null；
private DragSourceContext dragSourceContext＝null；
<!-- SIPO <DP n="22"> -->
<dp n="d22"/>
private Point cursorLocation＝null；
/**构造函数
@param root：树的根节点
@param parent：JTree的父JFrame*/
public DragTree(DefaultTreeModel treemodel，WorkFrame parent){
super(treemodel)；
this.parent＝parent；
addTreeSelectionListener(this)；
dragSource＝DragSource.getDefaultDragSource()；
DragGestureRecognizer dgr＝
dragSource.createDefaultDragGestureRecognizer(this，//DragSource
DnDConstants.ACTION_COPY_OR_MOVE，//指定合法动作
this//DragGestureListener)；
/*取消鼠标右键点击作为合法动作-如果为JTree实现了
*JPopupMenu，则特别有用
*/
dgr.setSourceActions(dgr.getSourceActions()&
～InputEyent.BUTTON3_MASK)；
//不必要，但给出了文件管理器的外观
putClientProperty(″JTree.lineStyle″，″Angled″)；
//MetalTreeUI ui＝(MetalTreeUI)getUI()；)
}
/**返回所选节点*/
public DefaultMutableTreeNode getSelectedNode(){
return SelectedNode；
}
<!-- SIPO <DP n="23"> -->
<dp n="d23"/>
/////////////////////////接口代码////////////////////
/**DragGestureListener接口方法*/
public void dragGestureRecognized(DragGestureEvent e){
//获得所选节点
DefaultMutableTreeNode dragNode＝getSelectedNode()；
if(dragNode！＝null&&dragNode.isLeaf()){
//获得Transferable对象
Transferable transferable＝(Operation)
dragNode.getUserObject()；
try{
((FlowPane)
parent.getSelectedFrame().getContentPane()).setOutsiderDrop(true)；
}catch(java.lang.NullPointerException ne){
System.out.println(″no internal frame，not dragged″)；
}
//开始拖动
dragSource.startDrag (e，DragSource.DefaultCopyDrop，
transferable，this)；
}else{
System.out.println(″not leaf，not dragged″)；}
}
/**DragSourceListener接口方法*/
public void dragDropEnd(DragSourceDropEvent dsde){
}
/**DragSourceListener接口方法*/
public void dragEnter(DragSourceDragEvent dsde){
<!-- SIPO <DP n="24"> -->
<dp n="d24"/>
setCursor(dsde)；
}
/**DragSourceListener接口方法*/
public void dragOver(DragSourceDragEvent dsde){
setCursor(dsde)；
}
/**DragSourceListener接口方法*/
public void dropActionChanged(DragSourceDragEvent dsde){
}
/**DragSourceListener接口方法*/
public void dragExit(DragSourceEvent dsde){
}
/**DragSourceListener接口方法。这有点难看。这是根据是否允许
*放Transferable对象而设置光标的地方。然而，需要有鼠标的位
*置和设置光标的对象，这两者来自两个不同的事件。尽管它不漂
*亮，但使用DropTargetListener dragOver方法中的位置设置一
*全局变量。
*/
void setCursor(DragSourceDragEvent dsde){
/*//如果不知道光标位置，则什么也不做。
if(cursorLocation＝＝null)return；
TreePath destinationPath＝
getPathForLocation(cursorLocation.x，cursorLocation.y)；
//获得设置鼠标类型的对象
<!-- SIPO <DP n="25"> -->
<dp n="d25"/>
DragSourceContext dsc＝dsde.getDragSourceContext()；
//如果目标路径可行，则设置光标以允许放...
if(testDropTarget(destinationPath，SelectedTreePath)＝＝null)
dsc.setCursor(DragSource.DefaultCopyDrop)；
//...否则设置不允许放
else dsc.setCursor(DragSource.DefaultCopyNoDrop)；
*/
}
/**TreeSelectionListener-设置所选节点*/
public void valueChanged(TreeSelectionEvent evt){
SelectedTreePath＝evt.getNewLeadSelectionPath()；
if(SelectedTreePath＝＝null){
SelectedNode＝null；
return；
}
SelectedNode＝(DefaultMutableTreeNode)
SelectedTreePath.getLastPathComponent()；
}
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import java.awt.*；
import java.awt.datatransfer.*；
import java.awt.dnd.*；
import java.awt.dnd.peer.*；
<!-- SIPO <DP n="26"> -->
<dp n="d26"/>
import java.awt.event.*；
import javax.swing.ImageIcon；
import javax.swing.*；
import java.io.*；
import java.util.*；
/**
*该类实现用户可在其中拖放Web服务对象或设置Web服务对象的属
*性的工作区。
*/
public class FlowPane extends Container
implements DropTargetListener，
DragGestureListener，
DragSourceListener，
ActionListener/*，鼠标侦听器*/{
JPopupMenu popupDelOp＝new JPopupMenu()；
JPopupMenu popupSetDelOp＝new JPopupMenu()；
JPopupMenu popupDelLink＝new JPopupMenu()；
JPopupMenu popupFilter＝new JPopupMenu()；
JPopupMenu popupPresenter＝new JPopupMenu()；
JMenuItem itemSet；
JMenuItem itemSetDelOp；
JMenuItem itemDeleteOp；
JMenuItem itemDeleteLink；
JMenuItem itemView；
JMenuItem itemFilterDelete；
JMenuItem itemFilterSet；
JMenuItem itemFilterView；
JMenuItem itemPresenterDel；
<!-- SIPO <DP n="27"> -->
<dp n="d27"/>
WorkFrame workFrame；
WorkFlowFrame flowFrame；
WorkFlow workflow；
boolean outsiderDrop＝true；//如果从左侧树拖动
boolean movingDrop；//如果标题栏被拖动则为真
int dragFromX，dragFromY；
/**拖动所需变量*/
private DragSource dragSource＝null；
private DragSourceContext dragSourceContext＝null；
/**
*构造函数
*/
public FlowPane(WorkFrame workFrame，
WorkFlowFrame flowFrame，
WorkFlow workflow){
DropTarget dropTarget＝new DropTarget(this，this)；
this.workFrame＝workFrame；
this.flowFrame＝flowFrame；
this.workflow＝workflow；
this.workflow.setContai ner(this)；
this.setBackground(Color.white)；
dragSource＝DragSource.getDefaultDragSource()；
DragGestureRecognizer dgr＝
dragSource.createDefaultDragGestureRecognizer(this，//DragSource
DnDConstants.ACTION MOVE，//指定合法操作
<!-- SIPO <DP n="28"> -->
<dp n="d28"/>
this//DragGestureListener
)；
createPopupMenu()；
addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
checkForTriggerEvent(e)；
}
public void mouseReleased(MouseEvent e){
checkForTriggerEvent(e)；
}
})；
}
void setWorkflow(WorkFlow workflow){
this.workflow＝workflow；
workflow.setContainer(this)；
}
WorkFrame getWorkFrame(){
return this.workFrame；
}
void createPopupMenu(){
popupSetDelOp.add(itemSet＝new JMenuItem(″设置值″))；
itemSet.addAction Listener(this)；
popupSetDelOp.addSeparator()；
popupSetDelOp.add(itemSetDelOp＝new JMenuItem(″删除″))；
popupSetDelOp.addSeparator()；
<!-- SIPO <DP n="29"> -->
<dp n="d29"/>
itemSetDelOp.addActionListener(this)；
popupSetDelOp.add(itemView＝new JMenuItem(″视图″))；
itemView.addActionListener(this)；
popupSetDelOp.setInvoker(this)；
popupDelOp.add(itemDeleteOp＝new JMenuItem(″删除″))；
itemDeleteOp.addActionListener(this)；
popupDelLink.add(itemDeleteLink＝new JMenuItem(″删除″))；
itemDeleteLink.addActionListener(this)；
popupDelLink.setInvoker(this)；
popupFilter.add(itemFilterDelete＝new JMen uItem(″删除过滤
器″))；
itemFilterDelete.addActionListener(this)；
popupFilter.setInvoker(this)；
popupFilter.add(itemFilterSet＝new JMenuItem(″设置过滤器
″))；
itemFilterSet.addActionListener(this)；
popupFilter.setInvoker(this)；
popupFilter.add(itemFilterView＝new JMenuItem(″查看过滤
器″))；
itemFilterView.addActionListener(this)；
popupFilter.setInvoker(this)；
popupPresenter.add (itemPresenterDel＝new JMenuItem
(″Delete″))；
itemPresenterDel.addActionListener(this)；
popupPresenter.setInvoker(this)；
}
void checkForTriggerEvent(MouseEvent e){
<!-- SIPO <DP n="30"> -->
<dp n="d30"/>
//获得所选操作
if(e.isPopupTrigger()){
Block block＝workflow.Select(e.getX()，e.get)；
if(block！＝null){
if(block instanceof Operation){
Operation oper＝(Operation)block；
if(oper.isDragingTitle(e.getX()，e.getY())
‖oper.isDragingOutput(e.getX()，e.getY())){
popupDelOp.show(e.getComponent()，e.getX()，
e.getY())；
return；
}else{
int index＝oper.selectlnput(e.getY())；
if((index＞＝0)
&&(oper.getInLink(index)＝＝null)
&&oper.isSetable(index)){
workflow.setSelectedIndex(index)；
popupSetDelOp.show(e.getComponent()，
ee.getX()，e.getY())；
return；
}
}
}//block instanceof Operation结束
else if(block instanceof XMLFilter){
popupFilter.show(e.getComponent()，e.getX()，
e.getY())；
return；
}
<!-- SIPO <DP n="31"> -->
<dp n="d31"/>
else if(block instanceof Presenter){
popupPresenter.show(e.getComponent()，e.getX()，
e.getY())；
return；
}
}//if block！＝null结束
else{//检查是否选择了一连接
Link link＝workflow.selectLink(e.getX()，e.getY())；
if(link′＝null){
popupDelLink.show(e.getComponent()，e.getX()，
e.getY())；
return；
}
}
}
}
/**DropTaregetListener接口方法*/
public void dragEnter(DropTargetDragEvent e){
//System.out.println(″drag enter′)；
}
/**DropTaregetListener接口方法*/
public void dragExit(DropTargetEvent e){
//System.out.println(″drag exit″)；
}
/**DropTaregetListener接口方法*/
<!-- SIPO <DP n="32"> -->
<dp n="d32"/>
public void dragOver(DropTargetDragEvent e){
//设置光标位置。setCursor方法中需要
}
/**DropTaregetListener接口方法*/
public void dropActionChanged(DropTargetDragEvent e){
}
/**DropTargetListener接口方法-释放拖动时做什么*/
public void drop(DropTargetDropEvent e){
//只放在具有焦点的内部框架上
if(！this.flowFrame.isSelected()){
e.rej ectDrop()；
//System.out.println(″Reject drop because frame not<br/>
selected″)；
return；
}
//获得transferable
//System.out.println(″drop at″+e.getLocation().x+
″，″+e.getLocation().y)；
Transferable tr＝e.getTransferable()；
//不支持flavor，拒绝放
if(！tr.isDataFlavorSupported(Operation.OPERATION_FLAVOR
)&&！tr.isDataFlavorSupported(XMLFilter.XMLFILTER_FLAVOR)
&&！tr.isDataFlavorSupported(Presenter.PRESENTER FLAVOR)){
e.rejectDrop()；
//System.out.println(″Reject drop because of not supported
flavor″)；
<!-- SIPO <DP n="33"> -->
<dp n="d33"/>
}else{
e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE)；
//System.out.println(″accept drop″)；
}
Block dragedBlock＝null；
if(tr.isDataFlavorSupported(operation.OPERATION_FLAVOR))
{
//转换到适当的数据类型
try{
dragedBlock＝(Operation)
tr.getTransferData(Operation.OPERATION_FLAVOR)；
}catch(Exception exc){
exc.printStackTrace()；
e.dropComplete(true)；
return；
}
//System.out.println(″dragedOperation＝″+dragedOper)；
//获得新位置
Point loc＝e.getLocation()；
//获得节点
//Operation oper＝
(Operation)workFrame.getTree().getSelectedNode().getUserObject()；
//System.out.println(″selectedNode＝″+oper.toString())；
if(outsiderDrop){
//System.out.println(″outsiderDrop″)；
workflow.addOperation((Operation)dragedBlock，
e.getLocation().x，e.getLocation().y)；
}else{
<!-- SIPO <DP n="34"> -->
<dp n="d34"/>
if(movingDrop){
//System.out.println(″move to″+e.getLocation().x+
″，″+e.getLocation().y)；
workflow.moveOperation(
e.getLocation().x-dragFromX，
e.getLocation().y-dragFromY)；
}else{
String msg＝
workflow.addOperationLink(e.getLocation().x，e.getLocation().y)；
if(msg！＝null)
JOptionPane.showMessageDialog(this，msg)；
}
}
//适当展开节点-可能这不是最好的方法...
}else if(tr.isDataFlavorSupported(XMLFilter.
XMLFILTER_FLAVOR)){
try{
//转换到适当的数据类型
dragedBlock＝(XMLFilter)
tr.getTransferData(XMLFilter.XMLFILTER_FLAVOR)；
}catch(Exception exc){
exc.printStackTrace()；
e.dropComplete(true)；
return；
}
//System.out.println(″dragedFilter＝″+dragedBlock)；
//获得新位置
Point loc＝e.getLocation()；
<!-- SIPO <DP n="35"> -->
<dp n="d35"/>
if(outsiderDrop){
//System.out.println(″outsiderDrop″)；
workflow.addFilter((XMLFilter)dragedBlock，
e.getLocation().x，e.getLocation().y)；
}else{
if(movingDrop){
workflow.moveFilter(
e.getLocation().x-dragFromX，
e.getLocation().y-dragFromY)；
}else{
String msg＝workflow.addFilterLink
(e.getLocation().x，e.getLocation().y)；
if(msg！＝null)
JOptionPane.showMessageDialog(this，msg)；
}
}
}else if(tr.isDataFlavorSupported(Presenter.PRESENTER_
FLAVOR)){
try{
//转换到适当的数据类型
dragedBlock＝(Presenter)
tr.getTransferData(Presenter.PRESENTER_FLAVOR)；
}catch(Exception exc){
exc.printStackTrace()；
e.dropComplete(true)；
return；
}
//System.out.println(″dragedFilter＝″+dragedBlock)；
<!-- SIPO <DP n="36"> -->
<dp n="d36"/>
//获得新位置
Point loc＝e.getLocation()；
if(outsiderDrop){
if(workflow.getPresenter()！＝null)
JOptionPane.showMessageDialog(this，″Cannot add
more than one presenter！″，null，JOptionPane.WARNING_MESSAGE)；
else{workflow.setPresenter((Presenter)dragedBlock，
e.getLocation().x，e.getLocation().y)；
//System.out.println(″workflow setpresenter″)；
}
}else{
if(movingDrop){
workflow.movePresenter(e.getLocation().x-
dragFromX，e.getLocation().y-dragFromY)；
}
}
}
this.repaint()；
e.dropComplete(true)；
//System.out.println(″drop complete″)；
}//方法结束
public void paint(Graphics g){
super.paint(g)；
Vector opers＝workflow.getOperationVec()；
for(int i＝0；i＜opers.size()；i++){
((Operation)(opers.elementAt(i))).draw(g)；
}
<!-- SIPO <DP n="37"> -->
<dp n="d37"/>
Vector links＝workflow.getLinkVec()；
for(int i＝0；i＜links.size()；i++){
((Link)(links.elementAt(i))).draw(g)；
}
Vector filters＝workflow.getFilterVec()；
for(int i＝0；i＜filters.size()；i++){
((XMLFilter)(filters.elementAt(i))).draw(g)；
}
if(workflow.getPresenter()！＝null){
/*Image image＝
Toolkit.getDefaultToolkit().createImage(workflow.getPresenter()..
getIconFileName())；
g.drawImage(image，
workflow.getPresenterl).getXI)，
workflow.getPresenter().getY()，
this)；*/
//System.out.println(″draw presenter″)；
Presenter presenter＝workflow.getPresenter()；
String type＝presenter.getType()；
//g.drawRect(workflow.getPresenter().getX()，
workflow.getPresenter().getY()，16，16)；
if(type.equals(″Text″))
g.drawImage(this.workFrame.textImage，presenter.getX
()，presenter.getY()，presenter.recW，presenter.recH，this)；
else if(type.equals(″Image″))
g.drawImage(this.workFrame.imageImage，
presenter.getX()，presenter.getY()，presenter.recW，presenter.recH，this)；
else if(type.equals(″Sound″))
<!-- SIPO <DP n="38"> -->
<dp n="d38"/>
g.draw Image(this.workFrame.soundImage，
presenter.getX()，presenter.getY()，presenter.recW，presenter.recH，this)；
}
}
///////拖动代码/////////////////////
/**DragGestureListener接口方法*/
public void dragGestureRecognized(DragGestureEvent e){
//获得所选操作
Block block＝workflow.select(e.getDragOrigin().x，
e.getDragOrigin().y)；
if(block！＝null){
setOutsiderDrop(false)；
if(block.isDragingTitle(e.getDragOrigin().x，
e.getDragOrigin O.y)){//移动框
movingDrop＝true；
dragFromX＝e.getDragOrigin().x；
dragFromY＝e.getDragOrigin().y；
//开始拖动
if(block instanceof Operation)
dragSource.startDrag(e，DragSource.
DefaultMoveDrop，(Operation)block，this)；
else if(block instanceof XMLFilter)
dragSource.startDrag(e，DragSource.
DefaultMoveDrop，(XML Filter)block，this)；
else if(block instanceof Presenter)
dragSource.startDrag(e，DragSource.
DefaultMoveDrop，(Presenter)block，this)；
<!-- SIPO <DP n="39"> -->
<dp n="d39"/>
}else{
//ImageIcon icon＝new ImageIcon
(″images\\item.jpg″)；
if(block.isDragingOutput(e.getDragOrigin().x，
e.getDragOrigin().y)){
movingDrop＝false；
if(block instanceof Operation)
dragSource.startDrag(e，DragSource.
DefaultMoveDrop，(Operation)block，this)；
else if(block instanceof XMLFilter)
dragSource.startDrag(e，DragSource.
DefaultMoveDrop，(XMLFilter)block，this)；
}
}
}
}
/**DragSourceListener接口方法*/
public void dragDropEnd(DragSourceDropEvent dsde){
}
/**DragSourceListener接口方法*/
public void dragEnter(DragSourceDragEvent dsde){
}
/**DragSourceListener接口方法*/
public void dragOver(DragSourceDragEvent dsde){
}
<!-- SIPO <DP n="40"> -->
<dp n="d40"/>
/**DragSourceListener接口方法*/
public void dropActionChanged(DragSourceDragEvent dsde){
}
/**DragSourceListener接口方法*/
public void dragExit(DragSourceEvent dsde){
}
public void setOutsiderDrop(boolean flag){
outsiderDrop＝flag；
}
////鼠标侦听器//////
/*public void mouseClicked(MouseEvent e){
workflow.mouseClicked(e.getX()，e.getYl))；
this.repaint()；
}
public void mousePressed(MouseEvent e){
}
public void mouseReleased(MouseEvent e){
}
public void mouseEntered(MouseEvent e){
}
public void mouseExited(MouseEvent e){
}*/
<!-- SIPO <DP n="41"> -->
<dp n="d41"/>
public void actionPerformed(ActionEvent e){
//确定选择了哪个菜单项
if(e.getSource＝＝itemDeleteLink){
workflow.deleteLink()；
}else if(e.getSource()＝-itemDeleteOp){
workflow.deleteOpo；
}else if(e.getSouree()＝＝itemSet){
String input＝JOptionPane.showInternalInputDialog
(this，″Set value for″+workflow.selectedOperation.getParamName
(workflow.selectedIndex)，″Input″，JOptionPane.INFORMATION
MESSAGE)；
if(input！＝null)
workflow.selectedOperation.setParamValue(input，
workflow.selectedIndex)；
}else if(e.getSource＝＝itemSetDelOp){
workflow.selectedOperation.delParamValue(workflow.selectedIndex)；
}else if(e.getSource＝＝itemView){
JOptionPane.showInternalMessageDialog(
this，
workflow.selectedOperation.getParamValue(workflow.selectedIndex)，
″Value of″+
workflow.selectedOperation.getParamName(workflow.selectedIndex)，
JOptionPane.INFORMATION MESSAGE)；
}else if(e.getSource＝＝itemFilterDelete){
workflow.deleteFilter()；
}else if(e.getSource＝＝itemFilterSet){
String input＝JOptionPane.showInternalInputDialog(
this，
<!-- SIPO <DP n="42"> -->
<dp n="d42"/>
″Set filter″，
″Input″，
JOptionPane.INFORMATION_MESSAGE)；
if(input！＝null)
workflow.selectedFilter.setXmlpath(input)；
}else if(e.getSource＝＝itemFilterView){
JOptionPane.showInternalMessageDialog(
this，
workflow.selectedFilter.getXmlpath()，
″Filter Value″，
JOptionPane.INFORMATION MESSAGE)；
}else if(e.getSource＝＝itemPresenterDel){
workflow.deletePresenter()；
}
repaint()；
}
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import java.io.*；
import java.awt.*；
/**
*该类实现在Web服务对象间的连接组件。
*/
public class Link extends Object implements Serializable{
Block fromBlock；
<!-- SIPO <DP n="43"> -->
<dp n="d43"/>
Block to Block；
//Presenter presenter；
int toIndex；
boolean running＝false；
static final int range＝5；
static final int ARROW_SIDE＝8；//箭头大小
static final int ARROW_HEIGHT＝10；
/**
*构造函数
*/
public Link(Operation from，Operation to，int tolndex){
this.fromBlock＝from；
this.toBlock＝to；
this.toIndex＝toIndex；
}
public Link(Operation from，XMLFilter to){
this.fromBlock＝from；
this.toBlock＝to；
this.toIndex＝-1；
}
public Link(XMLFilter from，Operation to，int toIndex){
this.fromBlock＝from；
this.toBlock＝to；
this.toIndex＝toIndex；
<!-- SIPO <DP n="44"> -->
<dp n="d44"/>
}
public Link(Operation from，Presenter presenter){
this.fromBlock＝from；
//this.presenter＝presenter；
this.toBlock＝presenter；
this.tolndex＝-1；
}
public Link(XMLFilter filter，Presenter presenter){
this.fromBlock＝filter；
//this.presenter＝presenter；
this.toBlock＝presenter；
this.toIndex＝-1；
}
public void draw(Graphics g){
if(running)
g.setColor(Color.green)；
//if(presenter＝＝null){
g.drawLine(fromBlock.getOutPoint().x，
fromBlock.getOutPoint().y，toBlock.getInPoint(toIndex).x，
toBlock.getInPoint(toIndex).y)；
this.drawArrow(g，fromBlock.getOutPoint()，
toBlock.getInPoint(toIndex))；
/*}else{
g.drawLine(fromBlock.getOutPoint().x，
fromBlock.getOutPoint().y，presenter.getInPoint().x，presenter.getInPoint
<!-- SIPO <DP n="45"> -->
<dp n="d45"/>
(toIndex).y)；
this.drawArrow(g，fromBlock.getOutPoint()，
presenter.getInPoint())；
}*/
g.setColor(Color.black)；
}
/*public Link select(int posX，int posY){
final double coef＝1.01；
int x1＝fromBlock.getOutPoint().x；
int y1＝fromBlock.getOutPoint().y；
int x2＝toBlock.getOutPoint().x；
int y2＝toBlock.getOutPoint().y；
double length＝Math.sqrt(Math.pow((x2-x1)，2)+
Math.pow((y2-y1)，2))；
double d1＝Math.sqrt(Math.pow((posX-x1)，2)+
Math.pow((posY-y1)，2))；
double d2＝Math.sqrt(Math.pow((posX-x1)，2)+
Math.pow((posY-y1)，2))；
if((d1+d2)＜length*coef)
return this；
else return null；
}
*/public Link select(int px，int py){
int x1＝fromBlock.getOutPoint().x；
int y1＝fromBlock.getOutPoint().y；
//int x2＝
<!-- SIPO <DP n="46"> -->
<dp n="d46"/>
(toBlock！＝null)？toBlock.getInPoint(toIndex).x：presenter.getInPoint().x；
//int y2＝
(toBlock！＝null)？toBlock.getInPoint(toIndex).y：presenter.getInPoint().y；
int x2＝toBlock.getInPoint(toIndex).x；
int y2＝toBlock.getInPoint(toIndex).y；
//处理x1＝x2时的情况
if(x1＝＝x2){
if(py＞＝Math.min(y1，y2)&&py＜＝Math.max(y1，y2)&&
Math.abs(px-x1)＜＝range)
return this；
else return null；
}else if(y1＝y2){
if(px＞＝Math.min(x1，x2)&&px＜＝Math.max(x1，x2)&&
Math.abs(py-y1)＜＝range)
return this；
else return null；
}else{
double slope＝(double)(y2-y1)/(x2-x1)；
double ix＝(slope*py-slope*y1+slope*slope*x1+px)/
(slope*slope+1)；
double iy＝y1+slope*(ix-x1)；
double d＝Math.sqrt(Math.pow((px-ix)，2)+Math.pow
((py-iy)，2))；
if(ix＞＝Math.min(x1，x2)&&ix＜＝Math.max(x1，x2)&&d
range)
return this；
else{
/*System.out.println(″The slope is：″+slope)；
<!-- SIPO <DP n="47"> -->
<dp n="d47"/>
System.out.println(″The first point is：″+x1+″，″+y1)；
System.out.println(″The second point is：″+x2+″，″+
y2)；
System.out.println(″The point is：″+px+″，″+py)；
System.out.println(″The intersection is ：(x，y)″+ix
+″，″+iy)；
System.out.println(″distance is：″+d)；
System.out.println(″the range is：″+range)；*/
return null；
}
}
}
public Block getFromBlock(){
return this.fromBlock；
}
public Block getToBlock(){
return this.toBlock；
}
/*public Presenter getPresenter(){
return this.presenter；
}
*/
public int getToIndex(){
return toIndex；
<!-- SIPO <DP n="48"> -->
<dp n="d48"/>
}
public void setRunning(boolean value){
this.running＝value；
}
/**
*从点pFrom到点pTo绘制箭头。
*/
private void drawArrow(Graphics g，Point pFrom，Point pTo){
double slope；
int borderSpace＝2；
double fx，fy，tx，ty；
/*(x1，y1)：(centerX，centerY)左边的点*/
/*(x2，y2)：(centerX，centerY)右边的点*/
double x1，y1，x2，y2；
double centerX＝0；
double centerY＝0；
double distance；
fx＝pFrom.getX()；
fy＝pFrom.getY()；
tx＝pTo.getX()；
ty＝pTo.getY()；
distance＝Math.sqrt(Math.pow(fx-tx，2)+Math.pow(fy-ty，2))；
if(distance＜＝borderSpace)return；
if(tx＝＝fx){ //重直线，斜率将为无限大，
centerX＝tx； //中点具有与pFrom、pTo相同的x。
if(ty＞＝fy) //箭头向下。
<!-- SIPO <DP n="49"> -->
<dp n="d49"/>
centerY＝ty-ARROW_HEIGHT；
else //箭头向上。
centerY＝ty+ARROW_HEIGHT；
y1＝centerY；
y2＝centerY；
x1＝centerX-(int)ARROW_SIDE/2；
x2＝centerX+(int)ARROW_SIDE/2；
}else if(ty＝＝fy){ //水平线。
centerY＝ty； //中点具有与pFrom、pTo相同的y。
if(tx＞＝fx) //箭头向右。
centerX＝tx-ARROW_HEIGHT；
else //箭头向左。
centerX＝tx+ARROW_HEIGHT；
x1＝centerX；
x2＝centerX；
y1＝centerY-(int)ARROW_SIDE/2；
y2＝centerY+(int)ARROW_SIDE/2；
}else{
//线的斜率
slope＝(pTo.getY()-pFrom.getY())/(pTo.getX()
-pFrom.getX())；
//箭头部的斜率
slope＝-1/slope；
centerX＝tx+ARROW_HEIGHT*(fx-tx)/distance；
centerY＝ty+ARROW_HEIGHT*(fy-ty)/distance；
x1＝centerX+ARROW_SIDE/Math.sqrt(l+slope*slope)/2；
x2＝centerX-ARROW_SIDE/Math.sqrt(l+slope*slope)/2；
y1＝centerY+ARROW_SIDE/Math.sqrt (l+slope*slope)
<!-- SIPO <DP n="50"> -->
<dp n="d50"/>
*slope/2；
y2＝centerY-ARROW_SIDE/Math.sqrt (l+slope*slope)
*slope/2；
}
int xPoints[]＝{(int)x1，(int)tx，(int)x2}；
int yPoints[]＝{(int)y1，(int)ty，(int)y2}；
g.fillPolygon(xPoints，yPoints，3)；
g.drawLine((int)fx，(int)fy，(int)tx，(int)ty)；
}
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import java.awt.datatransfer.*；
import java.util.*；
import java.io.*；
import java.awt.*；
import java.awt.geom.*；
import java.awt.geom.Rectangle2D.Double；
import org.apache.soap.*；
import org.apache.soap.rpc.*；
import org.apache.soap.transport.http.*；
import org.w3c.dom.*；
import org.apache.xerces.parsers.*；
import org.xml.sax.*；
<!-- SIPO <DP n="51"> -->
<dp n="d51"/>
import java.io.*；
import java.net.*；
/**
*该类提供了Web服务方法调用的表示。
*/
public class Operation extends Block //Object
implements Transferable，Serializable{
final public static DataFlavor OPERATION_FLAVOR＝
new DataFlavor(Operation.class，″Operation Information″)；
static DataFlavor flavors[]＝{OPERATION_FLAVOR}；
int width；
int height；
static int recH；
Service service；
String serviceName；
Strjng name；
String paramTypes[]；
String paramNames[]；
Object paramValues[]；
Link inLink[]；
String returnName；
String returnType；
Object returnValue；
/*int x；
<!-- SIPO <DP n="52"> -->
<dp n="d52"/>
int y；
int width；
int height；
static int recH；
final static int marginLeft＝3；
final static int marginTop＝3；
*/
final static int connectorW＝6；
final static int connectorH＝6；
/**
*构造函数
*/
public Operation(){
}
public Operation(Service service，String name，String paramNames[]，
String paramTypes[]，String returnName，String returnType){
this.serviceName＝service.getName()；
this.service＝service；
this.name＝name；
this.paramNames＝paramNames；
this.paramTypes＝paramTypes；
this.paramValues＝new Object[this.paramNames.length]；
this.returnName＝returnName；
this.returnType＝returnType；
this.returnValue＝null；
<!-- SIPO <DP n="53"> -->
<dp n="d53"/>
}
public Operation(Operation operation，int x，int y){
this.service＝operation.service；
this.serviceName＝operation.serviceName；
this.name＝operation.name；
this.paramNames＝operation.paramNames；
this.paramTypes＝operation.paramTypes；
this.paramValues＝new Object[this.paramNames.length]；
this.returnName＝operation.returnName；
this.returnType＝operation.returnType；
this.returnValue＝null；
this.x＝x；
this.y＝y；
this.width＝operation.width；
this.height＝operation.height；
}
public String toString(){
StringBuffer sbuf＝new StringBuffer()；
sbuf.append(returnType+″″+name+″(″)；
for(int i＝0；i＜paramNames.length；i++){
sbuf.append(paramTypes[i]+″″+paramNames[i])；
if(i！＝paramNames.length-1)
sbuf.append(″，″)；
}
sbuf.append(″)″)；
return sbuf.toString()；
<!-- SIPO <DP n="54"> -->
<dp n="d54"/>
}
//---------Transferable--------------
public boolean isDataFlavorSupported(DataFlavor df){
return df.equals(OPERATION_FLAVOR)；
}
/**实现Transferable接口*/
public Object getTransferData(DataFlavor df)throws
UnsupportedFlavorException，IOException{
if(df.equals(OPERATION FLAVOR)){
return this；
}else{
throw new UnsupportedFlavorException(df)；
}
}
/**实现Transferable接口*/
public DataFlavor[]getTransferDataFlavors(){
return flavors；
}
/*public void setLoc(int x，int y){
this.x＝x；
this.y＝y；
System.out.println(name+″setLoc@″+this.x+″，″+this.y)；
}
*/
<!-- SIPO <DP n="55"> -->
<dp n="d55"/>
public void draw(Graphics g){
int fontH＝g.getFontMetrics().getHeight()；
recH＝fontH+marginTop*2；
//System.out.println(″draw at l+this.x+s，″+this.y+″″+name)；
//发现框的宽度
String title1＝serviceName；
String title2＝this.returnType+″″+this.name；
width＝Math.max(g.getFontMetrics().stringWidth(title1)，
g.getFontMetrics().stringWidth(title2))；
for(int i＝0；i＜this.paramNames.length；i++){
String param＝(String)this.paramTypes[i]+″″
+(String)this.paramNames[i]+″*″；
width＝Math.max(width，g.getFontMetrics().stringWidth
(param))；
}
width＝width+marginLeft*2+connectorW*2；
//绘制标题
Rectangle2D titleBar＝new Rectangle2D.Double(x，y，width+1，
recH)；
//g.fill3DRect(x，y，width，recH，true)；
Graphics2D g2＝(Graphics2D)g；
if(！running){
g2.setPaint(new GradientPaint(x，y，Color.darkGray，
x+width+l，y+recH，Color.lightGray))；
}else{
g2.setPaint(new GradientPaint(x，y，new Color(80，125，80)，
x+width+l，y+recH，new Color(80，255，80)))；
<!-- SIPO <DP n="56"> -->
<dp n="d56"/>
}
g2.fill(titleBar)；
g.setColor(Color.white)；
Font oldFont＝g.getFont()；
g.setFont(new Font(oldFont.getName()，Font.BOLD，
oldFont.getSize()))；
g.drawString(title1，x+marginLeft，y+marginTop+fontH)；
g.setColor(Color.black)；
g.setFont(oldFont)；
drawConnector(x，y+recH，width，recH，″out″，g)；
g.draw3DRect(x，y+recH，width，recH，true)；
g.drawString(title2，x+marginLeft，y+marginTop+fontH+
recH)；
for(int i＝0；i＜this.paramNames.length；i++){
int curY＝y+(i+2)*recH；
//if(inLink！＝null&&inLinkEil！＝null‖paramValues[i]！
＝null)
drawConnector(x，curY，width，recH，″in″，g)；
g.draw3DRect(x，curY，width，recH，true)；
if(this.paramValues[i]！＝null)
g.drawString((String)this.paramTypes [i]+″″+
(String)this.paramNames[i]+″*″，x+marginLeft，curY+marginTop+
fontH)；
else
g.drawString((String)this.paramTypes[i]+″″+
(String)this.paramNames[i]，x+marginLeft，curY+marginTop+fontH)；
}
height＝recH*(this.paramNames.length+2)；
<!-- SIPO <DP n="57"> -->
<dp n="d57"/>
}
/*private void drawConnector(int px，int py，int recW，int recH，
String type，Graphics g){
if(type.equals(″in″)){
g.fill3DRect(px-connectorW，py+recH/2-connectorH/2，
connectorW，connectorH，true)；
}else{
g.fill3DRect(px+recW，py+recH/2-connectorH/2，
connectorW，connectorH，true)；
}
}
*/
private void drawConnector(int px，int py，int recW，int recH，String
type，Graphics g){
if(type.equals(″in″)){
int xPoints[]＝{px，px+connectorW，px}；
int yPoints[]＝{py+recH/2-connectorH/2，py+recH/2，py+
recH/2+connectorH/2}；
g.fillPolygon(xPoints，yPoints，3)；
}else{
int xPoints[]＝{px+recW，px+recW+connectorW，px+
recW}；
int yPoints[]＝{py+recH/2-connectorH/2，py+recH/2，py+
recH/2+connectorH/2}；
g.fillPolygon(xPoints，yPoints，3)；
}
<!-- SIPO <DP n="58"> -->
<dp n="d58"/>
}
private String getDisplayName(){
StringBuffer sbuf＝new StringBuffer()；
sbuf.append(returnType++name+″(″；
for(int i＝0；i＜paramNames.length；i++){
sbuf.append(paramTypes[i])；
if(i！＝paramNames.length-1)
sbuf.append(″，″)；
}
sbuf.append(″)″)；
return sbuf.toString()；
}
/*public Link getOutLink(){
return this.outLink；
}
public int getX(){
return this.x；
}
public int getY(){
return this.y；
}
*/
/*//---------可串行化的--------------
<!-- SIPO <DP n="59"> -->
<dp n="d59"/>
private void writeObject(java.io.ObjectOutputStream out)throws
IOException{
out.defaultWriteObject()；
}
private void readObject(java.io.ObjectInputStream in)
throws IOException，ClassNotFoundException{
in.defaultReadObject()；
}*/
public Operation select(int posX，int posY){
if(posX＞＝x&&posX＜＝x+width+connectorW&&posY＞＝
y&&posY＜＝y+height){
//System.out.println(″Operation select″+this.name)；
return this；
}
else
return null；
}
public int selectInput(int posY){
if(posY＞y+2*recH){
//System.out.println(″selected index＝″+
(posY-(y+2*recH))/recH)；
return(posY-(y+2*recH))/recH；
}
else
return-1；
<!-- SIPO <DP n="60"> -->
<dp n="d60"/>
}
public boolean isDragingTitle(int posX，int posY){
return(posY＞＝y&&posY＜(y+recH))；
}
public boolean isDragingOutput(int posX，int posY){
return(posY＞＝(y+recH)&&posY＜(y+2*recH))；
}
public void setParamValue(String input，int index){
this.paramValues[index]＝input；
}
public void delParamValue(int index){
this.paramValues[index]＝null；
}
public void setParamValue(Object input，int index){
int pos＝paramTypes[index].indexOf(″：″)；
String type＝paramTypes[index].substring(pos+1)；
if(type.equals(″string″))
this.paramValues[index]＝(String)input；
else if(type.equals(″int″))
this.paramValues[index]＝new Integer((String)
input)；
else if(type.equals(″float″))
this.paramValues[index]＝new Float((String)input)；
<!-- SIPO <DP n="61"> -->
<dp n="d61"/>
else if(type.equals(″double″))
this.paramValues[index]＝new java.lang.Double
((String)input)；
else
this.paramValues[index]＝input；
}
public void setInLink(Link link，int index){
if(this.in Link＝＝null)
this.inLink＝new Link[this.paramNames.length]；
inLink[index]＝link；
}
public Point getOutPoint(){
return new Point(x+width+connectorW，y+recH+recH/2)；
}
public Point getInPoint(int index){
//System.out.println(″getInPoint index＝″+index)；
return new Point(x-connectorW，y+(index+2)*recH+recH/2)；
}
public String getReturuType(){
return this.returnType；
}
public String getParamName(int index){
return this.paramNames[index]；
<!-- SIPO <DP n="62"> -->
<dp n="d62"/>
}
public String getParamType(int index){
return this.paramTypes[index]；
}
public Object getParamValue(int index){
return this.paramValues[index]；
}
public Link getInLink(int index){
return(inLink＝＝null？null：inLink[index])；
}
public Link[]getInLink(){
return this.inLink；
}
public Object execute(){
URL url＝null；
try{
url＝new URL(service.getUrl())；
}catch(Exception e){
}
String encodingStyleURI＝Constants.NS_URI_SOAP_ENC；
//构建调用
Call call＝new Call()；
call.setTargetObjectURI(service.getUrnt))；
<!-- SIPO <DP n="63"> -->
<dp n="d63"/>
call.setMethodName(this.name)；
call.setEncodingStyleURI(encodingStyleURI)；
Vector params＝new Vector(paramNames.length)；
for(int i＝0；i＜paramNames.length；i++){
params.addElement(new Parameter(paramNames[i]，
getJavaType(paramTypes[i])，paramValues[i]，null))；
}
call.setParams(params)；
//进行调用：注意action URI为空，因为XML-SOAP rpc router
//不需要它。这在未来可能改变。
Response resp＝null；
try{
resp＝call.invoke(/*router URL*/url，/*actionURI*/″″)；
}catch(org.apache.soap.SOAPException e){
return e.getMessage()；
}
//检查响应。
if(resp.generatedFault()){
Fault fault＝resp.getFault()；
System.out.println(″Ouch，the call failed：″)；
System.out.println(″Fault Code＝″+fault.getFaultCode())；
System.out.println(″Fault String＝″+fault.getFaultString
())；
return fault.getFaultString()；
}else{
Parameter result＝resp.getReturnValue()；
//String value＝(String)result.getValue()；
//return value；
<!-- SIPO <DP n="64"> -->
<dp n="d64"/>
return result.getValue()；
}
}
static Class getJavaType(String xmlType){
Class aClass＝null；
int pos＝xmlType.indexOf(″：″)；
String type＝xmlType.substring(pos+1)；
try{
if(type.equals(″string″))
aclass＝Class.forName(″java.lang.String″)；
else if(type.equals(″int″))
aClass＝Class.forName(″java.lang.Integerl′)；
else if(type.equals(″float″))
aClass＝Class.forName(″java.lang.Float″)；
else if(type.equals(″double″))
aClass＝Class.forName(″java.lang.Double″)；
else aClass＝Class.forName(″java.lang.Object″)；
}catch(Exception e){}
//System.out.println(″javatype＝″+aClass)；
return aClass；
}
boolean isSetable(int index){
int pos＝paramTypes[index].indexOf(″：″)；
String type＝paramTypes[index].substring(pos+1)；
return(type.equals(″string″)‖
type.equals(″int″)‖
<!-- SIPO <DP n="65"> -->
<dp n="d65"/>
type.equals(″float″)‖
type.equals(″double″))；
}
boolean isParamValueAllSet(){
for(int i＝0；i＜paramValues.length；i++){
if(paramValues[i]＝＝null){
return false；
}
}
return true；
}
boolean isParamOrLinkSet(){
for(int i＝0；i＜paramValues.length；i++){
if(paramValues[i]＝＝null&&this.inLink[i]＝＝null){
System.out.println(name+″isParamOrLinkSet()
＝false″)；
return false；
}
return true；
}
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import javax.swing.JOptionPane；
<!-- SIPO <DP n="66"> -->
<dp n="d66"/>
import javax.swing.JDialog；
import javax.swing.JTextField；
import java.beans.*；//属性改变代码
import java.awt.*；
import java.awt.event.*；
/**
*该类提供了用于为Web服务方法调用设置参数的对话框。
*/
public class ParamInputDialog extends JDialog{
private String typedText＝null；
private JOptionPane optionPane；
/**
*构造函数
*/
public ParamInputDialog(){
}
public String getValidatedText(){
return typedText；
}
public ParamInputDialog(String name){
super()；
setTitle(″Input″)；
this.setModal(true)；
<!-- SIPO <DP n="67"> -->
<dp n="d67"/>
final String msgString＝″Set value for″+name；
final JTextField textField＝new JTextField(50)；
Object[]array＝{msgString，textField}；
final String btnString1＝″Enter″；
final String btnString2＝″Cancel″；
Object[]options＝{btnString1，btnString2}；
optionPane＝new JOptionPane(array，JOptionPane.
QUESTION_MESSAGE，JOptionPane.YES NO OPTION，null，options，
options[0])；
setContentPane(optionPane)；
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE)；
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent we){
/*
*不是直接关闭窗口，而是改变JOptionPane
*的值属性。
*/
optionPane.setValue(new Integer
(JOptionPane.CLOSED_OPTION))；
}
})；
textField.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
optionPane.setValue(btnString1)；
}
})；
optionPane.addPropertyChangeListener(new
PropertyChangeListener(){
<!-- SIPO <DP n="68"> -->
<dp n="d68"/>
public void propertyChange(PropertyChangeEvent e){
String prop＝e.getPropertyName()；
if(isVisible()&&(e.getSource()＝＝optionPane)&&
(prop.equals(JOptionPane.VALUE_PROPERTY)‖prop.equals
(JOptionPane.INPUT_VALUE_PROPERTE))){
Object value＝optionPane.getValue()；
if(value＝＝JOptionPane.
UNINITIALIZED_VALUE){
//忽略重置
return；
}
//重置JOptionPane的值。如果不这样，则当用户
//下次按下同一个键时，将不会触发属性改变事件。
optionPane.setValue
(JOptionPane.UNINITIALIZED_VALUE)；
if(value.equals(btnStringl)){
typedText＝textField.getText()；
}else{//用户关闭对话框或点击取消。
typedText＝null；
setVisible(false)；
}
}
}
})；
}
}
<!-- SIPO <DP n="69"> -->
<dp n="d69"/>
//Copyright(c)2001 IBM package
com.ibm.webahead.flow；
import java.util.*；
import java.io.*；
import java.net.URL；
import org.apache.xerces.parsers.DOMParser；
import org.w3c.dom.*；
import com.ibm.wsdl.*；
/**
*代表Web服务对象的核心类。
*/
public class Service extends Object implements Serializable{
String name；
String urn；
String url；
Vector operationVec；
/**
*构造函数
*/
public Service(){
}
public Service(File file)throws Exception{
com.ibm.wsdl.WSDLDocument wsdldom＝null；
<!-- SIPO <DP n="70"> -->
<dp n="d70"/>
wsdldom＝new com.ibm.wsdl.WSDLDocument
(file.getAbsolutePath())；
initService(wsdldom)；
}
public Service(String url)throws Exception{
com.ibm.wsdl.WSDLDocument wsdldom＝null；
System.out.println(″constructing Service from：″+url)；
wsdldom＝new com.ibm.wsdl.WSDLDocument(new URL(url))；
initService(wsdldom)；
}
void initService(com.ibm.wsdl.WSDLDocument wsdldom){
WSDLMessageElement msgs[]＝wsdldom.getMessageElements
()；
com.ibm.wsdl.WSDL.ServiceElement serviceElems[]＝
wsdldom.getServiceElements()；
name＝serviceElems[Ol getDomElement().getAttributes().item
(0).getNodeValue()；
//System.out.println(name)；
WSDLPortElement[]servPorts＝serviceElems[0].
getPortElements()；
NodeList nodes＝servPorts[0].getDomElement().getChildNodes
()；
for(int i＝0；i＜nodes.getLength()；i++){
String localname＝nodes.item(i).getLocalName()；
if(localname！＝null&&localname.equals(″address″)){
url＝nodes.item(i).getAttributes().getNamedItem
<!-- SIPO <DP n="71"> -->
<dp n="d71"/>
(″location″).getNodeValue()；
break；
}
}
urn＝initUrn(wsdldom)；
//System.out.println(″url＝″+url+″urn＝″+urn)；
WSDLPortTypeElement ports[]＝wsdldom.
getPortTypeElements()；
WSDLOperationElement operations[]＝ports[0].
getOperationElements()；
initOperation(msgs，operations)；
}
String initUrn(WSDLDocument wsdldom)throws java.lang.
NullPointerException{
Element binding＝wsdldom.getBindingElements()[0].
getDomElement()；
Node oper＝binding.getElementsByTagName(″operation″).item
(0)；
NodeList children＝oper.getChildNodes()；
Node node＝null；
for(int i＝0；i＜children.getLength()；i++){
node＝children.item(i)；
if(node.getNodeName().equals(″input″)){
break；
}
}
//System.out.println(″Input node name＝″+node.getLocalName
<!-- SIPO <DP n="72"> -->
<dp n="d72"/>
())；
children＝node.getChildNodes()；
//System.out.println(″length＝″+node.getChildNodes().
getLength())；
for(int i＝0；i＜children.getLength()；i++){
node＝children.item(i)；
//System.out.println(node.getNodeNamei))；
if(node.getNodeName().indexOf(″body″)＞＝0){
break；
}
}
//System.out.println(″soap：body name＝″+node.getLocalName
())；
urn＝node.getAttributes().getNamedItem(″namespace″).
getNodeValue()；
return urn；
}
void initOperation(WSDLMessageElement[]msgs，
WSDLOperationElement[]operations){
Hashtable msgTable＝new Hashtable(10)；
for(int i＝0；i＜msgs.length；i++){
msgTable.put(msgs[i].getName()，msgs[i].getPartElements
())；
//System.out.println(msgs[i].getName())；
}
operationVec＝new Vector(operations.length)；
for(int i＝0；i＜operations.length；i++){
<!-- SIPO <DP n="73"> -->
<dp n="d73"/>
String name＝operations[i].getName()；
String inMsg＝operations[i].getInputElement().getMessage
()；
WSDLPartElement[]inParts＝(WSDLPartElement[])
msgTable.get(inMsg)；
//System.out.println(″inMsg＝″+inMsg)；
String partNames[]＝new String[inParts.length]；
String partTypes[]＝new String[inParts.length]；
for(int j＝0；j＜inParts.length；j++){
partNames[j]＝inParts[j].getName()；
partTypes[j]＝inParts[j].getType()；
//System.out.println(inParts[j].getType()+″：″+
inParts[j].getName())；
}
String outMsg＝operations[i].getOutputElement().
getMessage()；
//System.out.println(″outMsg＝″+outMsg)；
WSDLPartElement[]outParts＝(WSDLPartElement[])
msgTable.get(outMsg)；
String returnName＝outParts[0].getName()；
String returnType＝outParts[0].getType()；
//System.out.println(″return＝″+returnName+″：：″+
returnType)；
Operation oper＝new Operation(this，name，partNames，
partTypes，returnName，returnType)；
operationVec.add(oper)；
}
}
<!-- SIPO <DP n="74"> -->
<dp n="d74"/>
public Vector getOperationVec(){
return operationVec；
}
/*public Service(File file){
parse(file)；
}
void parse(File file){
Document doc＝null；
Vector paramNames＝null；
Vector paramTypes＝null；
String returnName＝null；
String returnType＝null；
try
{
DOMParser parser＝new DOMParser()；
parser.parse(file.getAbsolutePath())；
doc＝parser.getDocument()；
}
catch(Exception e)
{
System.err.println(″Sorry，an error occurred：″+e)；
return；
}
//已经分析了文档，现在打印它。
//获得Service名称
<!-- SIPO <DP n="75"> -->
<dp n="d75"/>
NodeList nodes＝doc.getElementsByTagName(″service″)；
name＝nodes.item(0).getAttributes().getNamedItem(″name″).
getNodeValue()；
//获得操作
nodes＝doc.getElementsByTagName(″operation″)；
operations＝new Vector()；
//遍历所有操作
for(int i＝0；i＜nodes.getLength()；i++){
Node node＝nodes.item(i)；
//获得操作名称
String operationName＝node.getAttributes().getNamedItem
(″name″).getNodeValue()；
NodeList msgNodes＝node.getChildNodes()；
//获得输入、输出消息
String inputmsg，outputmsg；
if(msgNodes.item(0).getNodeName().equals(″input″)){
inputmsg＝msgNodes.item(0).getAttributes().
getNamedItem(″name″).getNodeValue()；
outputmsg＝msgNodes.item(1).getAttributes().
getNamedItem(″name″).getNodeValue()；
}
else{
outputmsg＝msgNodes.item(0).getAttributes().
getNamedItem(″name″).getNodeValue()；
inputmsg＝msgNodes.item(1).getAttributes().
getNamedItem(″name″).getNodeValue()；
}
NodeList msgnodes＝doc.getElementsByTagName
<!-- SIPO <DP n="76"> -->
<dp n="d76"/>
(″message″)；
int count＝0；
for(int j＝0；j＜msgnodes.getLength()；j++){
if(msgnodes.item(j).getAttributes().item(0).
getNodeValue().equals(inputmsg)){
Node msgnode＝msgnodes.item(j)；
NodeList children＝msgnode.getChildNodes()；
paramNames＝new Vector()；
paramTypes＝new Vector()；
for(int k＝0；k＜children.getLength()；k++){
NamedNodeMap attribs＝children.item(k).
getAttributes()；
paramNames.addElement(attribs.
getNamedItem(″name″).getNodeValue())；
paramTypes.addElement(attribs.
getNamedItem(″type″).getNodeValue())；
}
count++；
}
if(msgnodes.item (j).getAttributes().item(0).
getNodeValue().equals(outputmsg)){
Node msgnode＝msgnodes.item (j).getFirstChild()；
returnName＝msgnode.getAttributes().
getNamedItem(″name″).getNodeValue()；
returnType＝msgnode.getAttributes().
getNamedItem(″type″).getNodeValue()；
count++；
}
<!-- SIPO <DP n="77"> -->
<dp n="d77"/>
if(count＝＝2)break；
}
operations.addElement(new Operation(operationName，
paramNames，paramTypes，returnName，returnType))；
}
}
*/
String getName(){
return name；
}
public String toString(){
return name；
}
String getUrl(){
return url；
}
String getUrn(){
return urn；
}
//Copyright(c)2001 IBM package
com.ibm.webahead.flow；
<!-- SIPO <DP n="78"> -->
<dp n="d78"/>
import javax.swing.*；
import javax.swing.event.*；
import javax.swing.plaf.metal.*；
import javax.swing.tree.*；
import java.awt.*；
import java.awt.datatransfer.*；
import java.awt.dnd.*；
import java.awt.dnd.peer.*；
import java.awt.event.*；
import java.io.*；
import java.util.*；
/**
*该类代表包含一个工作流的内部框架。
*/
public class WorkFlowFrame extends JInternalFrame
// 实现DropTargetListener
{
WorkFrame parent；
WorkFlow workflow；
/**
*构造函数
*/
public WorkFlowFrame(String title，WorkFrame parent，WorkFlow
workflow){
super(title，true，true，true，true)；
this.parent＝parent；
<!-- SIPO <DP n="79"> -->
<dp n="d79"/>
this.workflow＝workflow；
this.setContentPane(new FlowPane(parent，this，workflow))；
}
public WorkFlow getWorkflow(){
return this.workflow；
}
public void setWorkflow(WorkFlow workflow){
this.workflow＝workflow；
((FlowPane)this.getContentPane()).setWorkflow(workflow)；
}
}
//Copyright(c)2001 IBM
package com.ibm.webahead.flow；
import java.util.*；
import javax.swing.*；
import javax.swing.tree.*；
import java.io.*；
import java.io.*；
/**
*该类代表包括一工作流集合的工作空间。
*/
public class WorkSpace extends Object implements Serializable{
//String folder；
<!-- SIPO <DP n="80"> -->
<dp n="d80"/>
DefaultMutableTreeNode root；
Vector flowVec；
Vector serviceVec；
/**
*构造函数
*/
public WorkSpace(){
}
public WorkSpace(File dir){
serviceVec＝new Vector()；
flowVec＝new Vector()；
root＝new DefaultMutableTreeNode(″Untitled.wsp″)；
File files[]＝dir.listFiles()；
for(int i＝0；i＜files.length；i++){
File file＝files[i]；
Service service＝null；
try{
service＝new Service(files[i])；
}catch(Exception e){
System.out.println(″error in constructing″+files[i].
getName())；
e.printStackTrace()；
break；
}
serviceVec.addElement(service)；
<!-- SIPO <DP n="81"> -->
<dp n="d81"/>
DefaultMutableTreeNode node＝new
DefaultMutableTreeNode(service，true)；
Vector operVec＝service.getOperationVec()；
for(int j＝0；j＜operVec.size()；j++){
DefaultMutableTreeNode child＝new
DefaultMutableTreeNode(operVec.elementAt(j)，false)；
node.add(child)；
}
root.add(node)；
}
}
public WorkSpace(File[]files){
serviceVec＝new Vector()；
flowVec＝new Vector()；
root＝new DefaultMutableTreeNode(″Untitled.wsp″)；
for(int i＝0；i＜files.length；i++){
File file＝files[i]；
Service service＝null；
try{
service＝new Service(files[i])；
}catch(Exception e){
System.out.println(″error in constructing″+files[i].
getName())；
e.printStackTrace()；
break；
}
serviceVec.addElement(service)；
<!-- SIPO <DP n="82"> -->
<dp n="d82"/>
DefaultMutableTreeNode node＝new
DefaultMutableTreeNode(service，true)；
Vector operVec＝service.getOperationVec()；
for(int j＝0；j＜operVec.size()；j++){
DefaultMutableTreeNode child＝new
DefaultMutableTreeNode(operVec.elementAt(j)，false)；
node.add(child)；
}
root.add(node)；
}
}
public WorkSpace(Vector urls){
serviceVec＝new Vector()；
flowVec＝new Vector()；
root＝new DefaultMutableTreeNode(″Untitled.wsp″)；
for(int i＝0；i＜urls.size()；i++){
String url＝(String)urls.elementAt(i)；
Service service＝null；
try{
service＝new Service(url)；
}catch(Exception e){
System.out.println(″error in constructing″+url)；
e.printStackTrace()；
break；
}
serviceVec.addElement(service)；
DefaultMutableTreeNode node＝new
<!-- SIPO <DP n="83"> -->
<dp n="d83"/>
DefaultMutableTreeNode(service，true)；
Vector operVec＝service.getOperationVec()；
for(int j＝0；j＜operVec.size()；j++){
DefaultMutableTreeNode child＝new
DefaultMutableTreeNode(operVec.elementAt(j)，false)；
node.add(child)；
}
root.add(node)；
}
}
void addWSDL(DefaultTreeModel treemodel，File[]files){
for(int i＝0；i＜files.length；i++){
File file＝files[i]；
Service service＝null；
try{
service＝new Service(files[i])；
}catch(Exception e){
System.out.println(″error in constructing″+files
[i].getName())；
e.printStackTrace()；
break；
}
if(isDuplicatedService(service))
continue；
serviceVec.addElement(service)；
<!-- SIPO <DP n="84"> -->
<dp n="d84"/>
DefaultMutableTreeNode node＝new
DefaultMutableTreeNode(service，true)；
Vector operVec＝service.getOperationVec()；
for(int j＝0；j＜operVec.size()；j++){
DefaultMutableTreeNode child＝new
DefaultMutableTreeNode(operVec.elementAt(j)，false)；
node.add(child)；
}
DefaultMutableTreeNode parentNode＝
(DefaultMutableTreeNode)treemodel.getRoot()；
treemodel.insertNodeInto(node，parentNode，parentNode.
getChildCount())；
}
}
public void addWSDL(DefaultTreeModel treemodel，Vector urls){
for(int i＝0；i＜urls.size()；i++){
String url＝(String)urls.elementAt(i)；
Service service＝null；
try{
service＝new Service(url)；
}catch(Exception e){
System.out.println(″error in constructing″+url)；
e.printStackTrace()；
break；
}
<!-- SIPO <DP n="85"> -->
<dp n="d85"/>
if(isDuplicatedService(service))
continue；
serviceVec.addElement(service)；
DefaultMutableTreeNode node＝new
DefaultMutableTreeNode(service，true)；
Vector operVec＝service.getOperationVec()；
for(int j＝0；j＜operVec.size()；j++){
DefaultMutableTreeNode child＝new
DefaultMutableTreeNode(operVec.elementAt(j)，false)；
node.add(child)；
}
treemodel.insertNodeInto(node，root，root.getChildCount
())；
}
}
DefaultMutableTreeNode getRoot(){
return root；
}
void deleteService(DefaultTreeModel treemodel，DragTree tree){
if(treemodel！＝null&&tree！＝null&&tree.getSelectedNode()！
＝null){
DefaultMutableTreeNode selectedNode＝
(DefaultMutableTreeNode)(tree.getLastSelectedPathComponent())；
if(tree.getSelectedNode().isLeaf()){
selectedNode＝(DefaultMutableTreeNode)
<!-- SIPO <DP n="86"> -->
<dp n="d86"/>
selectedNode.getParent()；
}
Service service＝(Service)selectedNode.getUserObject()；
serviceVec.remove(service)；
treemodel.removeNodeFromParent(selectedNode)；
}
}
boolean isDuplicatedService(Service service){
for(int i＝0；i＜serviceVec.size()；i++){
if(((Service)serviceVec.elementAt(i)).getName().equals
(service.getName()))
return true；
}
return false；
}
}
Claims (51)
1.一种用于在Web服务环境中创建计算机程序的方法，该方法包括以下步骤：
将第一Web服务程序的第一表示移动到一GUI显示分区内；
将第二程序的第二表示移动到该GUI显示分区内；以及
使用GUI功能将该第一表示与第二表示互连，其中该第一Web服务程序与该第二程序可编程地通信以执行希望的操作。
2.根据权利要求1的方法，还包括以下步骤：
使用GUI功能选择第一表示或第二表示中的任何一个；以及
使用GUI功能设定所选择的表示的参数。
3.根据权利要求1的方法，其中，所述GUI功能包括鼠标、鼠标按钮、键盘、触摸屏、触控板、语音识别技术、光标定位或光笔中的任何一个。
4.根据权利要求1的方法，其中，所述第一表示或第二表示中的任何一个是显示的图标。
5.根据权利要求1的方法，其中，移动所述表示的功能是拖放。
6.根据权利要求2的方法，其中，所述设定参数的步骤还包括以下步骤：
使用GUI功能启动参数选项的显示；
根据预定的计划在该参数选项的显示上进行操作；以及
退出该参数选项的显示。
7.根据权利要求1的方法，还包括以下步骤：
启动对所述互连的表示的检测；以及
突出显示所述第一表示以指示功能状态。
8.根据权利要求7的方法，其中，所述突出显示指示空闲、工作、错误或警告中的任何一个。
9.根据权利要求7的方法，其中，所述突出显示是通过颜色、亮度、文本消息、形状改变或音频消息中的任何一个来实现的。
10.根据权利要求1的方法，还包括以下步骤：
将所述第一和第二表示以及互连保存为一封装体表示。
11.根据权利要求10的方法，其中，所述封装体表示被放置在用户的菜单上作为程序的第三表示。
12.根据权利要求1的方法，还包括以下步骤：
创建所述第一Web服务的第一表示，以及
将所创建的第一表示放置在用户的菜单上。
13.根据权利要求12的方法，其中，从所述用户菜单、网页或系统创建的下拉菜单中的任何一个移动所述第一表示。
14.根据权利要求1的方法，其中，从由所述Web服务提供的WSDL创建所述第一表示。
15.根据权利要求1的方法，其中，所述互连步骤包括UDDI集成。
16.根据权利要求1的方法，其中，所述希望的操作包括创建音频文件、视频文件、文本可查看文件、外部程序执行、图形用户界面改变或图形用户界面对话框中的任何一个。
17.根据权利要求1的方法，其中，所述第二程序是Web服务程序。
18.一种用于在Web服务环境中创建计算机程序的计算机程序产品，该计算机程序产品包括具有计算机可读程序代码的计算机可读介质，所述程序代码包括：
用于将第一Web服务程序的第一表示移动到一GUI显示分区内的计算机可读程序代码；
用于将第二程序的第二表示移动到该GUI显示分区内的计算机可读程序代码；以及
用于使用GUI功能将该第一表示与第二表示互连的计算机可
用于使用GUI功能将该第一表示与第二表示互连的计算机可读程序代码，其中该第一Web服务程序与该第二程序可编程地通信以执行希望的操作。
19.根据权利要求18的计算机程序产品，还包括以下步骤：
用于使用GUI功能选择所述第一表示或第二表示中的任何一个的计算机可读程序代码；以及
用于使用GUI功能设定所选择的表示的参数的计算机可读程序代码。
20.根据权利要求18的计算机程序产品，其中，所述GUI功能包括鼠标、鼠标按钮、键盘、触摸屏、触控板、语音识别技术、光标定位或光笔中的任何一个。
21.根据权利要求18的计算机程序产品，其中，所述第一表示或第二表示中的任何一个是显示的图标。
22.根据权利要求18的计算机程序产品，其中，移动所述表示的计算机可读程序代码包括拖放。
23.根据权利要求18的计算机程序产品，其中，所述设定参数的计算机可读程序代码还包括：
用于使用GUI功能启动参数选项的显示的计算机可读程序代码；
用于根据预定的计划在该参数选项的显示上进行操作的计算机可读程序代码；以及
用于退出该参数选项的显示的计算机可读程序代码。
24.根据权利要求18的计算机程序产品，还包括：
用于启动对所述互连的表示的检测的计算机可读程序代码；以及
用于突出显示所述第一表示以指示功能状态的计算机可读程序代码。
25.根据权利要求24的计算机程序产品，其中，所述突出显示指示空闲、工作、错误或警告中的任何一个。
26.根据权利要求24的计算机程序产品，其中，所述突出显示是通过颜色、亮度、文本消息、形状改变或音频消息中的任何一个来实现的。
27.根据权利要求18的计算机程序产品，还包括用于将所述第一和第二表示以及互连保存为一封装体表示的计算机可读程序代码。
28.根据权利要求27的计算机程序产品，其中，所述封装体表示被放置在用户的菜单上作为程序的第三表示。
29.根据权利要求18的计算机程序产品，还包括：
用于创建所述第一Web服务的第一表示的计算机可读程序代码，以及
用于将所创建的第一表示放置在用户的菜单上的计算机可读程序代码。
30.根据权利要求29的计算机程序产品，其中，从所述用户菜单、网页或系统创建的下拉菜单中的任何一个移动所述第一表示。
31.根据权利要求18的计算机程序产品，其中，从由所述Web服务提供的WSDL创建所述第一表示。
32.根据权利要求18的计算机程序产品，其中，所述用于互连的计算机可读程序代码包括用于UDDI集成的计算机可读程序代码。
33.根据权利要求18的计算机程序产品，其中，所述希望的操作包括创建音频文件、视频文件、文本可查看文档、外部程序执行、图形用户界面改变或图形用户界面对话框中的任何一个。
34.根据权利要求18的计算机程序产品，其中，所述第二程序是Web服务程序。
35.一种用于在Web服务环境中创建计算机程序的系统，该系统包括以下装置：
将第一Web服务程序的第一表示移动到一GUI显示分区内的移动器；
将第二Web服务程序的第二表示移动到该GUI显示分区内的移动器；以及
使用GUI功能将该第一表示与第二表示互连的互连器，其中该第一Web服务程序与该第二程序可编程地通信以执行希望的操作。
36.根据权利要求35的系统，还包括：
使用GUI功能选择第一表示或第二表示中的任何一个的选择器；以及
使用GUI功能设定所选择的表示的参数的参数设定器。
37.根据权利要求35的系统，其中，所述GUI功能包括鼠标、鼠标按钮、键盘、触摸屏、触控板、语音识别技术、光标定位或光笔中的任何一个。
38.根据权利要求35的系统，其中，所述第一表示或第二表示是显示的图标。
39.根据权利要求35的系统，其中，移动所述表示的功能是拖放。
40.根据权利要求36的系统，其中，所述参数设定器还包括：
使用GUI功能启动参数选项的显示的显示启动器；
根据预定的计划在该参数选项的显示上进行操作的操作器；以及
退出该参数选项的显示的退出器。
41.根据权利要求35的系统，还包括：
启动对所述互连的表示的检测的启动器；以及
突出显示所述第一表示以指示功能状态的修改器。
42.根据权利要求41的系统，其中，所述突出显示指示空闲、工作、错误或警告中的任何一个。
43.根据权利要求41的系统，其中，所述突出显示是通过颜色、亮度、文本消息、形状改变或音频消息中的任何一个来实现的。
44.根据权利要求35的系统，还包括将所述第一和第二表示以及互连保存为一封装体表示的表示保存器。
45.根据权利要求44的系统，其中，所述封装体表示被放置在用户的菜单上作为程序的第三表示。
46.根据权利要求35的系统，还包括：
创建第一Web服务的第一表示的创建器，以及
将所创建的第一表示放置在用户的菜单上的菜单放置器。
47.根据权利要求45的系统，其中，从用户菜单、网页或系统创建的下拉菜单中的任何一个移动所述第一表示。
48.根据权利要求35的系统，其中，从由Web服务提供的WSDL创建所述第一表示。
49.根据权利要求35的系统，其中，所述互连器还包括UDDI集成。
50.根据权利要求35的系统，其中，所述希望的操作包括创建音频文件、视频文件、文本可查看文件、外部程序执行、图形用户界面改变或图形用户界面对话框中的任何一个。
51.根据权利要求35的系统，其中，所述第二程序是Web服务程序。
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US10/406,378 | 2003-04-02 | ||
| US10/406,378 US20040207659A1 (en) | 2003-04-02 | 2003-04-02 | Program creation by combining web services using graphic user interface controls |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN1761943A true CN1761943A (zh) | 2006-04-19 |
Family
ID=33097312
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNA2004800074692A Pending CN1761943A (zh) | 2003-04-02 | 2004-03-17 | 通过使用图形用户界面控件来组合Web服务的程序创建 |
Country Status (5)
| Country | Link |
|---|---|
| US (2) | US20040207659A1 (zh) |
| EP (1) | EP1609060A2 (zh) |
| KR (1) | KR20050119645A (zh) |
| CN (1) | CN1761943A (zh) |
| WO (1) | WO2004088511A2 (zh) |
Cited By (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2008131671A1 (fr) * | 2007-04-25 | 2008-11-06 | Tencent Technology (Shenzhen) Company Limited | Système d'affichage utilisateur associé, procédé, et extrémité client d'une communication instantanée |
| CN101853156A (zh) * | 2010-05-12 | 2010-10-06 | 上海普元信息技术股份有限公司 | 构件化软件系统中实现Web Service调用的方法 |
| CN101630328B (zh) * | 2009-08-20 | 2011-05-11 | 浙江大学 | Web服务属性图形化展示方法 |
| CN102077203A (zh) * | 2008-11-28 | 2011-05-25 | 马林克罗特公司 | 用于药液输送系统的工作流驱动用户界面 |
| WO2011150777A1 (zh) * | 2010-06-04 | 2011-12-08 | 中兴通讯股份有限公司 | Web应用的开发装置及其开发方法 |
| CN101335802B (zh) * | 2007-06-27 | 2012-10-03 | 三星电子株式会社 | 成像方法与装置、以及主机 |
| CN101459688B (zh) * | 2007-12-10 | 2013-04-24 | 株式会社理光 | 用于监视多个可用网服务ws的装置的计算机实施的方法 |
| US9525788B2 (en) | 2007-06-27 | 2016-12-20 | Samsung Electronics Co., Ltd. | Method and apparatus to input workflow steps and parameters |
| CN111512286A (zh) * | 2017-12-29 | 2020-08-07 | 华为技术有限公司 | 编排程序的方法及电子设备 |
| CN112130836A (zh) * | 2020-09-10 | 2020-12-25 | 华帝股份有限公司 | 基于json文件生成多级联动组件的方法 |
Families Citing this family (97)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7650576B2 (en) * | 2002-03-07 | 2010-01-19 | Business Objects Americas | Method and system for creating graphical and interactive representations of input and output data |
| US8561069B2 (en) * | 2002-12-19 | 2013-10-15 | Fujitsu Limited | Task computing |
| EP2270622B1 (en) * | 2003-06-05 | 2016-08-24 | Intertrust Technologies Corporation | Interoperable systems and methods for peer-to-peer service orchestration |
| US8200775B2 (en) * | 2005-02-01 | 2012-06-12 | Newsilike Media Group, Inc | Enhanced syndication |
| US7412045B2 (en) | 2003-10-30 | 2008-08-12 | Hewlett-Packard Development Company, L.P. | Telecommunications service program |
| US7187380B2 (en) * | 2003-10-30 | 2007-03-06 | Hewlett-Packard Development Company, L.P. | Telecommunications graphical service program |
| US8225282B1 (en) * | 2003-11-25 | 2012-07-17 | Nextaxiom Technology, Inc. | Semantic-based, service-oriented system and method of developing, programming and managing software modules and software solutions |
| US8117280B2 (en) * | 2003-12-12 | 2012-02-14 | Fujitsu Limited | Task computing |
| US7823122B1 (en) * | 2003-12-16 | 2010-10-26 | The Mathworks, Inc. | Model and subsystem function signatures |
| US7487513B1 (en) * | 2003-12-30 | 2009-02-03 | Sap Ag | Web service archive |
| US7822826B1 (en) * | 2003-12-30 | 2010-10-26 | Sap Ag | Deployment of a web service |
| WO2005076130A1 (en) * | 2004-02-03 | 2005-08-18 | Corizon Limited | Method and apparatus for composite user interface creation |
| JP2005234666A (ja) * | 2004-02-17 | 2005-09-02 | Nec Corp | ＰｏＣシステムおよびＰｏＣサーバならびにＰｏＣクライアント |
| JP3805776B2 (ja) * | 2004-02-26 | 2006-08-09 | 三菱電機株式会社 | グラフィカルプログラミング装置及びプログラマブル表示器 |
| US20050228693A1 (en) * | 2004-04-09 | 2005-10-13 | Webb James D | Data exchange web services for medical device systems |
| EP1759289A4 (en) * | 2004-04-28 | 2008-08-20 | Fujitsu Ltd | SEMANTIC TASK DATA PROCESSING |
| US7665064B2 (en) * | 2004-05-14 | 2010-02-16 | Gt Software, Inc. | Systems and methods for web service function, definition, implementation, and/or execution |
| WO2005114964A1 (en) * | 2004-05-21 | 2005-12-01 | Computer Associates Think, Inc. | Method and apparatus for web service communication |
| US7620934B2 (en) * | 2004-05-28 | 2009-11-17 | Sap Ag | System and method for a Web service definition |
| US7617480B2 (en) * | 2004-05-28 | 2009-11-10 | Sap Ag | System and method for a Web service virtual interface |
| US20090228447A1 (en) * | 2004-07-01 | 2009-09-10 | Creekbaum William J | System, method, and solfware application for enabling a user to search an external domain within a visual mapping interface |
| US9038001B2 (en) * | 2004-07-01 | 2015-05-19 | Mindjet Llc | System and method for graphically illustrating external data source information in the form of a visual hierarchy in an electronic workspace |
| US9047388B2 (en) | 2004-07-01 | 2015-06-02 | Mindjet Llc | System, method, and software application for displaying data from a web service in a visual map |
| US10216372B1 (en) * | 2004-12-06 | 2019-02-26 | The Mathworks, Inc. | Automatic import to a graphical model |
| US8065336B2 (en) * | 2004-12-20 | 2011-11-22 | Fujitsu Limited | Data semanticizer |
| US7606803B2 (en) * | 2004-12-28 | 2009-10-20 | International Business Machines Corporation | Method and system for dynamic creation of service flows |
| US20060143031A1 (en) * | 2004-12-28 | 2006-06-29 | International Business Machines Corporation | Method and system for dynamic creation of web services |
| US8700738B2 (en) | 2005-02-01 | 2014-04-15 | Newsilike Media Group, Inc. | Dynamic feed generation |
| US20070050446A1 (en) | 2005-02-01 | 2007-03-01 | Moore James F | Managing network-accessible resources |
| US8140482B2 (en) | 2007-09-19 | 2012-03-20 | Moore James F | Using RSS archives |
| US20070168461A1 (en) * | 2005-02-01 | 2007-07-19 | Moore James F | Syndicating surgical data in a healthcare environment |
| US9202084B2 (en) | 2006-02-01 | 2015-12-01 | Newsilike Media Group, Inc. | Security facility for maintaining health care data pools |
| US8200700B2 (en) * | 2005-02-01 | 2012-06-12 | Newsilike Media Group, Inc | Systems and methods for use of structured and unstructured distributed data |
| US8347088B2 (en) | 2005-02-01 | 2013-01-01 | Newsilike Media Group, Inc | Security systems and methods for use with structured and unstructured data |
| US20080126178A1 (en) * | 2005-09-10 | 2008-05-29 | Moore James F | Surge-Based Online Advertising |
| US20080040151A1 (en) * | 2005-02-01 | 2008-02-14 | Moore James F | Uses of managed health care data |
| US9141402B2 (en) | 2005-04-25 | 2015-09-22 | Aol Inc. | Providing a user interface |
| US7739611B2 (en) * | 2005-04-25 | 2010-06-15 | Aol Inc. | User interface with connectable elements |
| US20060259869A1 (en) * | 2005-04-25 | 2006-11-16 | Hewitt Joseph R | Providing a user interface |
| US7493564B2 (en) | 2005-04-26 | 2009-02-17 | International Business Machines Corporation | Method for the display of visual sequencing of launched application portlets and task page relationship information in a web-base environment |
| US9317259B2 (en) * | 2005-05-12 | 2016-04-19 | International Business Machines Corporation | Apparatus, system, and method for automatically generating a reusable software component for interfacing with a web service |
| US7895578B2 (en) * | 2005-06-13 | 2011-02-22 | Business Objects Software Ltd. | Apparatus and method for using connector components to provide connectivity to interactive graphics representative of input and output data |
| US7774713B2 (en) * | 2005-06-28 | 2010-08-10 | Microsoft Corporation | Dynamic user experience with semantic rich objects |
| US7590935B2 (en) * | 2005-07-08 | 2009-09-15 | Microsoft Corporation | Dynamic generation of WSDL documents based on database metadata |
| US20070067388A1 (en) * | 2005-09-21 | 2007-03-22 | Angelov Dimitar V | System and method for configuration to web services descriptor |
| US20070067384A1 (en) * | 2005-09-21 | 2007-03-22 | Angelov Dimitar V | System and method for web services configuration creation and validation |
| US8078671B2 (en) * | 2005-09-21 | 2011-12-13 | Sap Ag | System and method for dynamic web services descriptor generation using templates |
| US8250522B2 (en) | 2005-09-28 | 2012-08-21 | Sap Ag | Method and system for generating a web services meta model on the java stack |
| US8700681B2 (en) | 2005-09-28 | 2014-04-15 | Sap Ag | Method and system for generating schema to java mapping descriptors |
| US20070073771A1 (en) | 2005-09-28 | 2007-03-29 | Baikov Chavdar S | Method and system for directly mapping web services interfaces and java interfaces |
| US9454616B2 (en) * | 2005-09-28 | 2016-09-27 | Sap Se | Method and system for unifying configuration descriptors |
| US7698684B2 (en) * | 2005-09-28 | 2010-04-13 | Sap Ag | Method and system for generating schema to Java mapping descriptors and direct mapping of XML schema and Java interfaces |
| CA2527447C (en) * | 2005-11-18 | 2015-05-05 | Allen Vi Cuong Chan | Message oriented construction of web services |
| US8140987B2 (en) * | 2005-12-29 | 2012-03-20 | Sap Ag | GUI modeling of web services |
| US20070156868A1 (en) * | 2005-12-29 | 2007-07-05 | Ido Keren | Efficient dynamic discovery of web services |
| US8010695B2 (en) * | 2005-12-30 | 2011-08-30 | Sap Ag | Web services archive |
| US8024425B2 (en) * | 2005-12-30 | 2011-09-20 | Sap Ag | Web services deployment |
| US7814060B2 (en) * | 2005-12-30 | 2010-10-12 | Sap Ag | Apparatus and method for web service client deployment |
| US20070156872A1 (en) * | 2005-12-30 | 2007-07-05 | Stoyanova Dimitrina G | Method and system for Web services deployment |
| US8972872B2 (en) * | 2006-03-27 | 2015-03-03 | Fujitsu Limited | Building computing applications based upon metadata |
| WO2007137145A2 (en) * | 2006-05-17 | 2007-11-29 | Newsilike Media Group, Inc | Certificate-based search |
| US20080046437A1 (en) * | 2006-07-27 | 2008-02-21 | Wood Charles B | Manual Conflict Resolution for Background Synchronization |
| US20080052343A1 (en) * | 2006-07-27 | 2008-02-28 | Wood Charles B | Usage-Based Prioritization |
| US20080052162A1 (en) * | 2006-07-27 | 2008-02-28 | Wood Charles B | Calendar-Based Advertising |
| US8527939B2 (en) * | 2006-09-14 | 2013-09-03 | Sap Ag | GUI modeling of knowledge base in a modeling environment |
| US7793154B2 (en) | 2006-11-30 | 2010-09-07 | International Business Machines Corporation | Method and implementation for automating processes using data driven pre-recorded transactions |
| JP4767828B2 (ja) * | 2006-12-01 | 2011-09-07 | インターナショナル・ビジネス・マシーンズ・コーポレーション | コンピュータ用アプリケーション・プログラムの作成システム、方法、及びプログラム |
| US20080209392A1 (en) * | 2007-02-26 | 2008-08-28 | Able Steve L | Systems and Methods for Definition and Execution of Batch Processing Services |
| US20080222237A1 (en) * | 2007-03-06 | 2008-09-11 | Microsoft Corporation | Web services mashup component wrappers |
| US20080222572A1 (en) * | 2007-03-06 | 2008-09-11 | Microsoft Corporation | Look and feel of a web services mashup designer |
| US20080222599A1 (en) * | 2007-03-07 | 2008-09-11 | Microsoft Corporation | Web services mashup designer |
| US20080244514A1 (en) * | 2007-03-29 | 2008-10-02 | Microsoft Corporation | Scriptable object model for network based services |
| US20080270911A1 (en) * | 2007-04-24 | 2008-10-30 | Nehal Dantwala | System and method to develop a custom application for a multi-function peripheral (mfp) |
| US8271998B2 (en) * | 2007-04-27 | 2012-09-18 | International Business Machines Corporation | Dynamic discovery and definition of mappings of parameters used by service oriented architecture services at runtime |
| KR101382504B1 (ko) * | 2007-05-21 | 2014-04-07 | 삼성전자주식회사 | 매크로 생성 장치 및 방법 |
| US8683446B2 (en) * | 2007-07-09 | 2014-03-25 | International Business Machines Corporation | Generation of test cases for functional testing of applications |
| ITPC20080006A1 (it) * | 2008-02-04 | 2009-08-05 | Mario Carletti | Metodo per la costruzione e l'esecuzione di flussi di lavoro che riusano operazioni e contenuti informativi di siti internet esistenti in ambienti multiutente. |
| US20100070891A1 (en) * | 2008-09-18 | 2010-03-18 | Creekbaum William J | System and method for configuring an application via a visual map interface |
| US9396455B2 (en) * | 2008-11-10 | 2016-07-19 | Mindjet Llc | System, method, and software application for enabling a user to view and interact with a visual map in an external application |
| US9495997B2 (en) * | 2009-01-06 | 2016-11-15 | Dell Products L.P. | System and method for dynamic enablement of storage media associated with an access controller |
| US8397056B1 (en) | 2009-04-21 | 2013-03-12 | Jackbe Corporation | Method and apparatus to apply an attribute based dynamic policy for mashup resources |
| US8458596B1 (en) | 2009-04-21 | 2013-06-04 | Jackbe Corporation | Method and apparatus for a mashup dashboard |
| US8392267B1 (en) | 2009-06-30 | 2013-03-05 | Mindjet Llc | System, method, and software application for dynamically generating a link to an online procurement site within a software application |
| US20110035650A1 (en) * | 2009-08-05 | 2011-02-10 | International Business Machines Corporation | Service registry policy aggregator |
| US9110577B1 (en) * | 2009-09-30 | 2015-08-18 | Software AG USA Inc. | Method and system for capturing, inferring, and/or navigating dependencies between mashups and their data sources and consumers |
| US9971807B2 (en) * | 2009-10-14 | 2018-05-15 | Oblong Industries, Inc. | Multi-process interactive systems and methods |
| US8788513B2 (en) * | 2009-10-30 | 2014-07-22 | Dassault Systemes Americas Corp. | Computer method and system providing access to data of a target system |
| US9367595B1 (en) | 2010-06-04 | 2016-06-14 | Software AG USA Inc. | Method and system for visual wiring tool to interconnect apps |
| US20120210258A1 (en) * | 2011-02-11 | 2012-08-16 | Microsoft Corporation | Compositional dashboards with processor components |
| US8949771B2 (en) * | 2011-06-22 | 2015-02-03 | Microsoft Corporation | Media files including programming code and description |
| US9741004B1 (en) * | 2012-08-16 | 2017-08-22 | Nintex Pty Limited | Apparatus and method for transforming web services into managed workflow actions |
| CN104007961A (zh) * | 2014-04-29 | 2014-08-27 | 云南电网公司 | 在图形界面构建中使用的可视化标注方法 |
| US10026041B2 (en) | 2014-07-12 | 2018-07-17 | Microsoft Technology Licensing, Llc | Interoperable machine learning platform |
| US9436507B2 (en) | 2014-07-12 | 2016-09-06 | Microsoft Technology Licensing, Llc | Composing and executing workflows made up of functional pluggable building blocks |
| US9760343B2 (en) * | 2014-11-28 | 2017-09-12 | Sap Se | Application builder based on metadata |
| US20180004393A1 (en) | 2016-07-01 | 2018-01-04 | Autodesk, Inc. | Three dimensional visual programming interface for a network of devices |
| CN108681451A (zh) * | 2018-05-14 | 2018-10-19 | 浪潮软件集团有限公司 | 一种可视化的kubernetes微服务编排的实现方法 |
Family Cites Families (27)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2865573B2 (ja) * | 1994-09-21 | 1999-03-08 | 株式会社日立製作所 | ワークフロー管理システム |
| US5850548A (en) | 1994-11-14 | 1998-12-15 | Borland International, Inc. | System and methods for visual programming based on a high-level hierarchical data flow model |
| US5701451A (en) * | 1995-06-07 | 1997-12-23 | International Business Machines Corporation | Method for fulfilling requests of a web browser |
| US5710918A (en) * | 1995-06-07 | 1998-01-20 | International Business Machines Corporation | Method for distributed task fulfillment of web browser requests |
| US5745754A (en) * | 1995-06-07 | 1998-04-28 | International Business Machines Corporation | Sub-agent for fulfilling requests of a web browser using an intelligent agent and providing a report |
| US5752246A (en) * | 1995-06-07 | 1998-05-12 | International Business Machines Corporation | Service agent for fulfilling requests of a web browser |
| US5793964A (en) * | 1995-06-07 | 1998-08-11 | International Business Machines Corporation | Web browser system |
| US5721908A (en) * | 1995-06-07 | 1998-02-24 | International Business Machines Corporation | Computer network for WWW server data access over internet |
| US6157960A (en) | 1997-05-07 | 2000-12-05 | International Business Machines Corporation | Technique for programmatically creating distributed object programs |
| US6125400A (en) | 1997-11-10 | 2000-09-26 | International Business Machines Corporation | Method and system of running object oriented programs across a network through compression and distillation of remote method invocation |
| US6336116B1 (en) * | 1998-08-06 | 2002-01-01 | Ryan Brown | Search and index hosting system |
| US6336118B1 (en) | 1998-12-03 | 2002-01-01 | International Business Machines Corporation | Framework within a data processing system for manipulating program objects |
| US6633888B1 (en) * | 1999-02-03 | 2003-10-14 | International Business Machines Corporation | Method and apparatus for visually creating and testing object oriented components |
| WO2000058873A1 (en) | 1999-03-26 | 2000-10-05 | Octane Software, Inc. | Workflow design engine |
| US6792605B1 (en) * | 1999-06-10 | 2004-09-14 | Bow Street Software, Inc. | Method and apparatus for providing web based services using an XML Runtime model to store state session data |
| US6560633B1 (en) * | 1999-06-10 | 2003-05-06 | Bow Street Software, Inc. | Method for creating network services by transforming an XML runtime model in response to an iterative input process |
| US6380951B1 (en) * | 1999-10-01 | 2002-04-30 | Global Graphics Software Limited | Prepress workflow method and program |
| US7184966B1 (en) | 1999-12-30 | 2007-02-27 | Honeywell International Inc. | Systems and methods for remote role-based collaborative work environment |
| US8600783B2 (en) * | 2000-08-18 | 2013-12-03 | The Crawford Group, Inc. | Business to business computer system for communicating and processing rental car reservations using web services |
| US7917888B2 (en) | 2001-01-22 | 2011-03-29 | Symbol Technologies, Inc. | System and method for building multi-modal and multi-channel applications |
| US6986145B2 (en) | 2001-03-13 | 2006-01-10 | Dipayan Gangopadhyay | In-context access to relevant services from multiple applications and information systems by object schema traversal |
| US20030004746A1 (en) * | 2001-04-24 | 2003-01-02 | Ali Kheirolomoom | Scenario based creation and device agnostic deployment of discrete and networked business services using process-centric assembly and visual configuration of web service components |
| US7367028B2 (en) * | 2001-08-14 | 2008-04-29 | National Instruments Corporation | Graphically deploying programs on devices in a system |
| CA2376038A1 (en) * | 2002-03-07 | 2003-09-07 | Ajay Sidda | System and method for graphically creating data flows and control flows for xml web services |
| US20040017392A1 (en) * | 2002-05-01 | 2004-01-29 | Welch Keith C. | Web service control for use in a graphical programming environment |
| JP3874706B2 (ja) * | 2002-07-29 | 2007-01-31 | 株式会社東芝 | アプリケーションプログラムプラン生成装置、アプリケーションプログラムプラン生成方法、プログラム及び記録媒体 |
| US20040064528A1 (en) * | 2002-09-30 | 2004-04-01 | Microsoft Corporation | Safe interoperability among web services |
-
2003
- 2003-04-02 US US10/406,378 patent/US20040207659A1/en not_active Abandoned
- 2003-10-06 US US10/679,759 patent/US7543299B2/en not_active Expired - Fee Related
-
2004
- 2004-03-17 WO PCT/GB2004/001130 patent/WO2004088511A2/en not_active Application Discontinuation
- 2004-03-17 KR KR1020057016882A patent/KR20050119645A/ko not_active Application Discontinuation
- 2004-03-17 EP EP04721231A patent/EP1609060A2/en not_active Withdrawn
- 2004-03-17 CN CNA2004800074692A patent/CN1761943A/zh active Pending
Cited By (14)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2008131671A1 (fr) * | 2007-04-25 | 2008-11-06 | Tencent Technology (Shenzhen) Company Limited | Système d'affichage utilisateur associé, procédé, et extrémité client d'une communication instantanée |
| CN101335802B (zh) * | 2007-06-27 | 2012-10-03 | 三星电子株式会社 | 成像方法与装置、以及主机 |
| US10764450B2 (en) | 2007-06-27 | 2020-09-01 | Hewlett-Packard Development Company, L.P. | Method and apparatus to input workflow steps and parameters |
| US10419626B2 (en) | 2007-06-27 | 2019-09-17 | Hp Printing Korea Co., Ltd. | Method and apparatus to input workflow steps and parameters |
| US9525788B2 (en) | 2007-06-27 | 2016-12-20 | Samsung Electronics Co., Ltd. | Method and apparatus to input workflow steps and parameters |
| CN101459688B (zh) * | 2007-12-10 | 2013-04-24 | 株式会社理光 | 用于监视多个可用网服务ws的装置的计算机实施的方法 |
| CN102077203A (zh) * | 2008-11-28 | 2011-05-25 | 马林克罗特公司 | 用于药液输送系统的工作流驱动用户界面 |
| CN101630328B (zh) * | 2009-08-20 | 2011-05-11 | 浙江大学 | Web服务属性图形化展示方法 |
| CN101853156B (zh) * | 2010-05-12 | 2013-07-17 | 上海普元信息技术股份有限公司 | 构件化软件系统中实现Web Service调用的方法 |
| CN101853156A (zh) * | 2010-05-12 | 2010-10-06 | 上海普元信息技术股份有限公司 | 构件化软件系统中实现Web Service调用的方法 |
| WO2011150777A1 (zh) * | 2010-06-04 | 2011-12-08 | 中兴通讯股份有限公司 | Web应用的开发装置及其开发方法 |
| CN111512286A (zh) * | 2017-12-29 | 2020-08-07 | 华为技术有限公司 | 编排程序的方法及电子设备 |
| US11204681B2 (en) | 2017-12-29 | 2021-12-21 | Huawei Technologies Co., Ltd. | Program orchestration method and electronic device |
| CN112130836A (zh) * | 2020-09-10 | 2020-12-25 | 华帝股份有限公司 | 基于json文件生成多级联动组件的方法 |
Also Published As
| Publication number | Publication date |
|---|---|
| KR20050119645A (ko) | 2005-12-21 |
| WO2004088511A2 (en) | 2004-10-14 |
| US20040199896A1 (en) | 2004-10-07 |
| US20040207659A1 (en) | 2004-10-21 |
| EP1609060A2 (en) | 2005-12-28 |
| US7543299B2 (en) | 2009-06-02 |
| WO2004088511A3 (en) | 2005-07-28 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN1761943A (zh) | 通过使用图形用户界面控件来组合Web服务的程序创建 | |
| CA2539474C (en) | System and method for dynamic generation and customization of web service client applications for terminals | |
| Yu et al. | A framework for rapid integration of presentation components | |
| Liu et al. | iMashup: a mashup-based framework for service composition | |
| CN1223938C (zh) | 一种构件的封装和一致性访问的方法 | |
| Domingue et al. | IRS-III: A broker-based approach to semantic Web services | |
| US8135668B2 (en) | Service composition environment | |
| US7676786B2 (en) | System and method and apparatus for using UML tools for defining web service bound component applications | |
| EP1986369B1 (en) | End user control configuration system with dynamic user interface | |
| US20090132220A1 (en) | Method For Creating A Telecommunications Application | |
| US7287229B2 (en) | Template-driven process system | |
| US20130046894A1 (en) | Model-driven rest consumption framework | |
| US8543972B2 (en) | Gateway data distribution engine | |
| MXPA04006074A (es) | Estructura para crear aplicaciones modulares en redes informaticas. | |
| US20090129575A1 (en) | System And Computer Program Product For Creating A Telecommunications Application | |
| US9218324B2 (en) | Method of encapsulating diverse user interface components while consistently enforcing external constraints | |
| CN1662899A (zh) | 网络服务代理 | |
| WO2023093414A1 (zh) | 微应用的开发方法、装置、设备、存储介质及程序产品 | |
| KR100426311B1 (ko) | Ｅｊｂ 컴포넌트 조립 장치 및 방법 | |
| US20150161235A1 (en) | Database content publisher | |
| CN110708202A (zh) | 插件节点的配置方法、装置、设备及存储介质 | |
| CN1661553A (zh) | 交互式无线应用程序系统和方法 | |
| CN1662011A (zh) | 使用元数据定义映射来构建组件应用程序的系统和方法 | |
| CN1581071A (zh) | 具有xml驱动的体系结构的信息处理方法、装置和程序 | |
| CN101976189A (zh) | 组件展现方法和装置 |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C02 | Deemed withdrawal of patent application after publication (patent law 2001) | ||
| WD01 | Invention patent application deemed withdrawn after publication |