(19) United States
`(12) Patent Application Publication (10) Pub. No.: US 2006/0271537 A1
`Chandrasekharan et al.
`(43) Pub. Date:
`Nov.30, 2006
`
`US 20060271537A1
`
`(54) APPARATUS, SYSTEM, AND METHOD FOR
`AUTOMATICALLY GENERATING A
`REUSABLE SOFTWARE COMPONENT FOR
`INTERFACING WITH A WEB SERVICE
`
`(76) Inventors: Sivakumar Chandrasekharan,
`Alameda, CA (US); Sujee
`Sivasubramaniyam, San Mateo, CA
`(US)
`Correspondence Address:
`KUNZLER & ASSOCATES
`8 EAST BROADWAY
`SUTE 6OO
`SALT LAKE CITY, UT 84111 (US)
`(21) Appl. No.:
`11/128,068
`
`(22) Filed:
`
`May 12, 2005
`
`Publication Classification
`
`(51) Int. Cl.
`G06F 7700
`G06F 7/30
`
`(2006.01)
`(2006.01)
`
`100
`
`(52) U.S. Cl. .................................................................. 707/7
`
`(57)
`
`ABSTRACT
`
`An apparatus, system, and method are disclosed for auto
`matically generating a reusable software component for
`interfacing with a web service. The apparatus for automati
`cally generating a reusable software component for inter
`facing with a web service is provided with a logic unit
`containing a plurality of module configured to functionally
`execute the steps of receiving a web service identifier,
`establishing communication with a web service, determining
`one or more functions provided by the web service, and
`automatically generating a reusable web service component
`configured to receive an application request and return a web
`service result. These modules in the described embodiments
`include a receiving module, a determination module, a
`communication module, and a generation module. Benefi
`cially, such an apparatus, system, and method would facili
`tate creation, test, and integration of web service compo
`nents in application code without requiring a substantial
`time and resource investment.
`
`Software Development
`Environment
`104
`
`
`
`
`
`
`
`Web Service
`Utility
`108
`
`
`
`
`
`
`
`
`
`ReuSable WS
`Component
`112
`
`Web Service
`110
`
`
`
`Page 1 of 17
`
`GOOGLE EXHIBIT 1012
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 1 of 7
`
`US 2006/0271537 A1
`
`1OO
`N
`
`Software Development
`Environment
`104
`
`
`
`
`
`
`
`
`
`Web Service
`Utility
`108
`
`
`
`
`
`
`
`Reusable WS
`Component
`112
`
`Web Service
`110
`
`F.G. 1
`
`Page 2 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 2 of 7
`
`US 2006/0271537 A1
`
`
`
`Web Service Utility
`108
`
`Recieve
`2O2
`
`Communication
`204
`
`Determination
`206
`
`Generate
`208
`
`FIG. 2
`
`Page 3 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 3 of 7
`
`US 2006/0271537 A1
`
`
`
`Web Service Utility
`3OO
`
`Recieve
`202
`
`Communication
`204
`
`Determination
`206
`
`Search
`304
`
`Generate
`208
`
`Convert
`302
`
`Presentation
`310
`
`Integration
`314
`
`FIG. 3
`
`Page 4 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 4 of 7
`
`US 2006/0271537 A1
`
`400
`
`
`
`is syster ange WebSphert Studio Waikiyeti SDK
`Ele Edit
`evigate Search eroject conponent tools sun windo
`8
`
`tele
`
`f
`
`R:
`
`V
`non- shows.
`base,08
`410
`Available Operations N N
`
`create Asiress
`
`iDe?tions
`
`star
`docseteadedae
`dospergsuggestion
`decocesearch
`
`so
`es
`put
`d
`WS.googapogetache...,
`Scoogie pogetcache,
`WS_Google pospellingsu... ws Google pospelings....
`S. Google DoGooglesee... WS.google pogooseSea, , ;
`
`<bst: . . . </t>. cae, www.< big tsuseeklt; Mbogt... net.
`Kisualary xsi type isd:string X
`K title Esi : type=ssd: strinsix<bst; sujeet; Mogt; .net ;
`Slt: bgt. Sujees</Sgt.: catitles
`k/itemax
`.
`. .
`K/resultlerents
`csearchConnents xsi : type raisd: string"x
`KsearchQuery xsi : typestsdistrinssueel casearchery
`Ksearch Tiae s.si: type axis: double). 3852.5g/searchisex
`ksearchTips si: types: string/ :
`-
`
`Page 5 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 5 of 7
`
`US 2006/0271537 A1
`
`416
`
`
`
`E. ap. Designer - Activity Editor - ObjenperatureGutput.currenterperature
`3 File Edit yiew Tools Help
`
`3
`
`418
`
`Ne WebServices
`C)
`ifa google
`201N getTerp
`-a My Collection
`.
`
`Page 6 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 6 of 7
`
`US 2006/0271537 A1
`
`500
`YA
`
`502
`
`504
`
`Receive Web Service dentifier
`
`506
`
`508
`
`CD Search for Web Service URL
`
`510
`
`514
`
`516
`
`518
`
`Determine Functions Provided
`
`Interface
`
`Convert
`
`Automatically Generate
`Reusable Component
`
`Store Reusable Component in
`Libra
`
`520
`
`522
`
`524
`
`526
`
`Display Graphical
`Development interface
`
`Present Web Service
`Arduments
`
`Test Web Service Component
`
`Integrate Component with
`Code
`
`528
`
`FIG. 5
`
`Page 7 of 17
`
`

`

`Patent Application Publication Nov.30, 2006 Sheet 7 of 7
`
`US 2006/0271537 A1
`
`600
`Y
`
`6O2
`
`
`
`Receive Web Service
`Information from Customer
`
`606
`
`Use Web Service Utility to
`Generate Component
`608
`
`
`
`610
`
`Integration
`Required?
`
`Integrate Web Service
`Component with Application
`
`
`
`612
`
`614
`
`
`
`Test Web Service Component
`
`
`
`Deliver Web Service
`Component Products
`616
`
`FIG. 6
`
`Page 8 of 17
`
`

`

`US 2006/0271537 A1
`
`Nov.30, 2006
`
`APPARATUS, SYSTEM, AND METHOD FOR
`AUTOMATICALLY GENERATING AREUSABLE
`SOFTWARE COMPONENT FOR INTERFACNG
`WITH A WEB SERVICE
`
`BACKGROUND OF THE INVENTION
`
`0001)
`1. Field of the Invention
`0002 This invention relates to object oriented software
`programming and more particularly relates to automatically
`generating a reusable software component for interfacing
`with a web service.
`0003 2. Description of the Related Art
`0004. A web service, as commonly referred to in the art
`of Software programming, is an application or module of
`code that is accessible over the internet using Hyper Text
`Transfer Protocol (“HTTP), Extensible Markup Language
`(XML), or other data transfer protocols and data formats.
`Web services are often provided by companies or business
`entities to facilitate business transactions over the internet.
`For example AmazonTM provides the Amazon Web Service
`(AWS) to allow software developers to incorporate access
`to the AmazonTM database in their web applications. Addi
`tionally, the AWS provides services to facilitate purchasing
`of AmazonTM products over the internet from separate and
`distinct web applications.
`0005 Web services may be written in various software
`languages and use a Web Service Description Language
`(“WSDL) which has been standardized for commonality
`and interoperability to describe the web service. WSDL is an
`XML syntax format for describing network services as a
`group of communication endpoints exchanging messages
`containing data and commands. Using WSDL, a web service
`can be utilized as a “blackbox” with one or more input ports
`and one or more output ports. For example, an application
`accessing the web service provides a message containing a
`command and/or data, and receives a message containing
`the data or commands resulting from the web service
`request. The web service application code used to perform
`background operations may include JAVA, C, C++, or the
`like. However, since web applications use XML, or WSDL,
`to request access to the web service, the language format of
`the background code is irrelevant.
`0006 The ports of a web service typically include some
`specific formatting requirements. A port of a web service
`requires data or commands of a specific data type. For
`example, a web service for providing a current temperature
`by city would include an input port and an output port. The
`input port may require a character string representing the
`city name, and the output port returns an integer representing
`the temperature in that city.
`0007 Web services employ standardized XML format to
`allow software application developers to access the web
`services from a variety of applications. Typically, web
`applications access web services, because access to the web
`service generally requires a data transfer protocol such as
`HTTP. One common language for web application code is
`JAVA. A JAVA developer, for example, must write JAVA
`application code to translate for accessing the web service.
`0008. The translation code typically assigns input argu
`ments from the JAVA code to XML formatted arguments for
`
`the web service ports. Additionally, the translation code
`converts the resulting messages from XML format back to
`JAVA format. Another function of the translation code is
`invoking and operation of the web service. Web services
`typically require instructions for invoking the service or one
`of the subsets of services provided. For example, a library
`application may include a translation code to access Ama
`ZonTM to allow a user to order a book that is not available in
`the library.
`0009 Adding web service access to an application
`requires the application developer to take several prepara
`tory steps. The software developer must find the Uniform
`Resource Locator (“URL) associated with the web service,
`establish access to the web service, determine the input and
`output arguments of the web service and the associated data
`formats, optionally test the web service, determine the
`required arguments and data types of the requesting appli
`cation, and write the code required to implement web service
`access. Each of these steps may be time consuming, error
`prone, mundane, distracting, and may require additional
`skills.
`0010 Finding a web service URL is often time consum
`ing. A developer can perform a web search using a search
`engine to find the desired web service provider. Alterna
`tively, if the web service provider is known, the developer
`may find a link to the web service on the providers web
`page. Another Solution includes performing a search of a
`Universal Description, Discovery, and Integration (“UDDI)
`registry of web services. However UDDI search services
`such as OASISTM may require user registration which
`requires an additional investment of time and possibly
`increased cost.
`0011 Testing of integrated web services generally
`requires a complete launch of the application accessing the
`web service, or the creation of a separate and distinct testing
`harness code. Such a test harness code is typically written
`independent of the application, and takes a significant time
`investment to develop.
`0012 Furthermore, each of the activities described above
`with relation to integration of web service access code in an
`application may require technical skills beyond those
`required for one of ordinary skill in the art of software
`design to develop a software application. As described
`above, accessing web services requires knowledge of XML,
`the UDDI system, and web service operation and formatting.
`Additionally, these activities divert energy and attention
`away from the task of application development and consume
`Substantial portions of development time.
`0013 From the foregoing discussion, it should be appar
`ent that a need exists for an apparatus, system, and method
`that automatically generate a reusable Software component
`for interfacing with a web service. Beneficially, such an
`apparatus, System, and method would facilitate creation,
`testing, and integration of web service components in appli
`cation code without requiring a substantial time and resource
`investment.
`
`SUMMARY OF THE INVENTION
`0014. The present invention has been developed in
`response to the present state of the art, and in particular, in
`response to the problems and needs in the art that have not
`
`Page 9 of 17
`
`

`

`US 2006/0271537 A1
`
`Nov.30, 2006
`
`yet been fully solved by currently available software devel
`opment utilities. Accordingly, the present invention has been
`developed to provide an apparatus, system, and method for
`automatically generating a reusable Software component for
`interfacing with a web service that overcome many or all of
`the above-discussed shortcomings in the art.
`0.015 The apparatus for automatically generating a reus
`able software component for interfacing with a web service
`is provided with a logic unit containing a plurality of module
`configured to functionally execute the necessary operations
`for automatically generating a reusable Software component
`for interfacing with a web service. These modules in the
`described embodiments include a receiving module, a deter
`mination module, a communication module, and a genera
`tion module. Further embodiments include a convert mod
`ule, a search module, a storage module, a display module, a
`presentation module, a test module, and an integration
`module.
`0016 A system of the present invention is also presented
`for automatically generating a reusable Software component
`for interfacing with a web service. In one embodiment, the
`system includes a computer network configured to provide
`data communication between a web service server and a web
`service utility, a serve connected to the computer network
`and configured to host a web service, and a web service
`utility configured to automatically generate a reusable soft
`ware component for interfacing with a web service.
`0017. A signal bearing medium is also presented for
`automatically generating a reusable Software component for
`interfacing with a web service. In one embodiment, the
`signal bearing medium tangibly embodies a program of
`machine-readable instructions executable by a digital pro
`cessing apparatus to perform the operations of receiving a
`web service identifier, determining one or more functions
`provided by the web service, and automatically generating a
`reusable web service component configured to receive an
`application request and return a web service result.
`0018. In a further embodiment, the signal bearing
`medium may include instructions to determine an interface
`of an identified web service. The instructions may also
`include searching for a Universal Resource Locator (URL)
`address for a web service identified by a user. In another
`embodiment, the instructions may include storing a library
`of selectable web service components configured to inte
`grate with application code.
`0019. In one embodiment, the instructions include dis
`playing a graphical development interface configured to
`facilitate mapping arguments of the reusable web service
`component to arguments of application code. The instruc
`tions may additionally include an operation to present
`required input values and resulting output values for the
`reusable web service component to a user.
`0020 Additionally, the instructions may include an
`operation to test a reusable web service component, and an
`operation to integrate the reusable web service component
`into an application code. The reusable web service compo
`nent may be configured to accept input parameters from an
`application requesting use of a web service, generate web
`service commands in a format compatible with the web
`service, invoke the web service to perform a requested
`function, receive a web service result from the requested
`
`function, convert the web service result into a format com
`patible with the application, and assign the web service
`result to an output parameter for the requesting application.
`0021. A service method is also presented for automati
`cally generating a reusable web service interface component
`for a customer. The method includes receiving a web service
`identifier from a customer, using a web service utility to
`automatically generate a
`0022 reusable web service component, and delivering
`the reusable web service component to the customer.
`0023. In one embodiment, using the web service utility
`includes using the web service utility to perform the steps
`described in relation to the signal bearing medium above. In
`a further embodiment, the service method includes receiving
`an application code language identifier from the customer.
`The method may additionally include integrating the reus
`able web service component into a set of application code
`provided by the customer.
`0024 Reference throughout this specification to features,
`advantages, or similar language does not imply that all of the
`features and advantages that may be realized with the
`present invention should be or are in any single embodiment
`of the invention. Rather, language referring to the features
`and advantages is understood to mean that a specific feature,
`advantage, or characteristic described in connection with an
`embodiment is included in at least one embodiment of the
`present invention. Thus, discussion of the features and
`advantages, and similar language, throughout this specifi
`cation may, but do not necessarily, refer to the same embodi
`ment.
`0025) Furthermore, the described features, advantages,
`and characteristics of the invention may be combined in any
`suitable manner in one or more embodiments. One skilled in
`the relevant art will recognize that the invention may be
`practiced without one or more of the specific features or
`advantages of a particular embodiment. In other instances,
`additional features and advantages may be recognized in
`certain embodiments that may not be present in all embodi
`ments of the invention.
`0026. These features and advantages of the present inven
`tion will become more fully apparent from the following
`description and appended claims, or may be learned by the
`practice of the invention as set forth hereinafter.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`0027. In order that the advantages of the invention will be
`readily understood, a more particular description of the
`invention briefly described above will be rendered by ref
`erence to specific embodiments that are illustrated in the
`appended drawings. Understanding that these drawings
`depict only typical embodiments of the invention and are not
`therefore to be considered to be limiting of its scope, the
`invention will be described and explained with additional
`specificity and detail through the use of the accompanying
`drawings, in which:
`0028 FIG. 1 is a schematic block diagram illustrating
`one embodiment of a system for automatically generating a
`reusable software component for interfacing with a web
`service;
`
`Page 10 of 17
`
`

`

`US 2006/0271537 A1
`
`Nov.30, 2006
`
`0029 FIG. 2 is a schematic block diagram illustrating
`one embodiment of an apparatus for automatically generat
`ing a reusable software component for interfacing with a
`web service;
`0030 FIG. 3 is a detailed schematic block diagram
`illustrating one embodiment of an apparatus for automati
`cally generating a reusable software component for inter
`facing with a web service;
`0031
`FIG. 4A is a screen capture of a software devel
`opment tool for automatically generating a reusable web
`service component for interfacing with a web service in
`accordance with the present invention;
`0032 FIG. 4B is a screen capture of a software devel
`opment tool for integrating a reusable web service compo
`nent with application code:
`0033 FIG. 5 is a schematic flow chart diagram illustrat
`ing one embodiment of a method for automatically gener
`ating a reusable software component for interfacing with a
`web service; and
`0034 FIG. 6 is a schematic flow chart diagram illustrat
`ing one embodiment of a method for automatically gener
`ating a reusable web service interface component for a
`CuStOmer.
`
`DETAILED DESCRIPTION OF THE
`INVENTION
`0035. Many of the functional units described in this
`specification have been labeled as modules, in order to more
`particularly emphasize their implementation independence.
`For example, a module may be implemented as a hardware
`circuit comprising custom VLSI circuits or gate arrays,
`off-the-shelf semiconductors such as logic chips, transistors,
`or other discrete components. A module may also be imple
`mented in programmable hardware devices such as field
`programmable gate arrays, programmable array logic, pro
`grammable logic devices or the like.
`0.036 Modules may also be implemented in software for
`execution by various types of processors. An identified
`module of executable code may, for instance, comprise one
`or more physical or logical blocks of computer instructions
`which may, for instance, be organized as an object, proce
`dure, or function. Nevertheless, the executables of an iden
`tified module need not be physically located together, but
`may comprise disparate instructions stored in different loca
`tions which, when joined logically together, comprise the
`module and achieve the stated purpose for the module.
`0037 Indeed, a module of executable code may be a
`single instruction, or many instructions, and may even be
`distributed over several different code segments, among
`different programs, and across several memory devices.
`Similarly, operational data may be identified and illustrated
`herein within modules, and may be embodied in any suitable
`form and organized within any suitable type of data struc
`ture. The operational data may be collected as a single data
`set, or may be distributed over different locations including
`over different storage devices, and may exist, at least par
`tially, merely as electronic signals on a system or network.
`0038 Reference throughout this specification to “one
`embodiment,”“an embodiment,” or similar language means
`that a particular feature, structure, or characteristic described
`
`99
`
`in connection with the embodiment is included in at least
`one embodiment of the present invention. Thus, appearances
`of the phrases “in one embodiment,”“in an embodiment,
`and similar language throughout this specification may, but
`do not necessarily, all refer to the same embodiment.
`0039 Reference to a signal bearing medium may take
`any form capable of generating a signal, causing a signal to
`be generated, or causing execution of a program of machine
`readable instructions on a digital processing apparatus. A
`signal bearing medium may be embodied by a transmission
`line, a compact disk, digital-Video disk, a magnetic tape, a
`Bernoulli drive, a magnetic disk, a punch card, flash
`memory, integrated circuits, or other digital processing
`apparatus memory device.
`0040. The schematic flow chart diagrams included are
`generally set forth as logical flow chart diagrams. As such,
`the depicted order and labeled steps are indicative of one
`embodiment of the presented method. Other steps and
`methods may be conceived that are equivalent in function,
`logic, or effect to one or more steps, or portions thereof, of
`the illustrated method. Additionally, the format and symbols
`employed are provided to explain the logical steps of the
`method and are understood not to limit the scope of the
`method. Although various arrow types and line types may be
`employed in the flow chart diagrams, they are understood
`not to limit the Scope of the corresponding method. Indeed,
`Some arrows or other connectors may be used to indicate
`only the logical flow of the method. For instance, an arrow
`may indicate a waiting or monitoring period of unspecified
`duration between enumerated steps of the depicted method.
`Additionally, the order in which a particular method occurs
`may or may not strictly adhere to the order of the corre
`sponding steps shown.
`0041
`Furthermore, the described features, structures, or
`characteristics of the invention may be combined in any
`suitable manner in one or more embodiments. In the fol
`lowing description, numerous specific details are provided,
`Such as examples of programming, software modules, user
`selections, network transactions, database queries, database
`structures, hardware modules, hardware circuits, hardware
`chips, etc., to provide a thorough understanding of embodi
`ments of the invention. One skilled in the relevant art will
`recognize, however, that the invention may be practiced
`without one or more of the specific details, or with other
`methods, components, materials, and so forth. In other
`instances, well-known structures, materials, or operations
`are not shown or described in detail to avoid obscuring
`aspects of the invention.
`0042. As used herein, the term “web service utility”
`refers to a method, apparatus, set of programmed computer
`instructions, or software application used to automatically
`generate a reusable Software component for interfacing with
`a web service. As used herein, the term “component” refers
`to a pluggable Software module, function, method, or set of
`instructions configured to integrate with application code in
`a procedural or object oriented application programming
`language.
`0.043 FIG. 1 illustrates one embodiment of a system 100
`for automatically generating a reusable Software component
`for interfacing with a web service. In one embodiment, the
`system 100 includes a computer network 102, a software
`development environment 104 and a server 106. The soft
`
`Page 11 of 17
`
`

`

`US 2006/0271537 A1
`
`Nov.30, 2006
`
`ware development environment 104 may additionally
`include a web service utility 108, and the server 106 may
`additionally include a web service 110. In one embodiment,
`the web service utility 108 automatically generates a reus
`able web service component 112.
`0044) In one embodiment, the system 100 includes a
`computer network 102 configured to provide data commu
`nication between a server 106 hosting a web service 110, and
`a web service utility 108. In one embodiment, the computer
`network 102 may include a connection through the Internet.
`For example, a URL address, IP address, or the like may be
`assigned to the server 106 hosting the web service 110. In
`another example, the URL address may resolve specifically
`to the web service 110 hosted by the server 106, to provide
`direct access to the web service 110.
`0045. In one embodiment, the system 100 includes a
`server 106 connected to the computer network 102 and
`configured to host a web service 110. In one embodiment,
`the server 106 may be dedicated specifically for manage
`ment of the web service 110, and related operations. The
`server 106 may include high bandwidth or multiple connec
`tions to the network 102 for high accessibility. Additionally,
`the server may include one or more processors, one or more
`storage disks, an operating system, and the like. For
`example, the server may be an International Business
`Machines(R (“IBM') Enterprise Server.
`0046.
`In one embodiment, the system 100 may include a
`software development environment 104 which utilizes a web
`service utility 108. In one embodiment, the software devel
`opment environment may be used to develop software
`applications. The Software applications may be written in
`software development languages such as JAVA, .NET. C.
`C++, Basic, or the like. One example of a software devel
`opment environment is described in more detail below with
`relation to FIG. 4.
`0047. In one embodiment, the system 100 includes a web
`service utility 108. The web service utility 108 may connect
`to the computer network 102 and may be configured to
`receive a web service identifier. Additionally, the web ser
`vice utility 108 may establish communication with a web
`service 110 through the computer network 102. The web
`service utility 108 may be further configured to determine
`one or more functions provided by the web service 110, and
`automatically generate a reusable web service component
`112 configured to receive an application request and return
`a result for a particular web service. Further embodiments of
`a web service utility 108 are described below with relation
`to FIG. 2 and FIG. 3.
`0.048. In one embodiment, the reusable web service com
`ponent 112 automatically generated by the web service
`utility 108 may be integrated into a software application
`using the software development environment 104. The reus
`able web service component 112 may be configured to
`accept input parameters from an application requesting use
`of a web service 110. The web service component 112 may
`generate web service commands in a format compatible with
`the web service 110. Additionally, the web service compo
`nent 112 may invoke the web service 110 to perform a
`requested function. In one embodiment, the web service
`component 112 may receive a web service result from the
`requested function and covert the web service result into a
`format compatible with the application language. Addition
`
`ally, the web service component 112 may assign the web
`service result to an output parameter for the requesting
`application.
`0049. The reusable web service component 112 may be
`generated, tested, maintained, and stored as a separate and
`independent software object. Alternatively, the reusable web
`service component 112 may require integration with a
`Software application to operate. For example, the reusable
`web service component 112 may be a function, class,
`module, or object that interfaces with the main body of an
`application code.
`0050. The reusable web service component 112 may be
`invoked by the application code, require input and output
`arguments to interface with the application code, and the
`like. Alternatively, the reusable web service component 112
`may operate independent of the application code. In Such an
`example, the reusable web service component 112 may
`accept web service requests from the application and return
`web service results to the application, but operate distinctly
`and separately from the application.
`0051. The web service component reduces the time
`required for a developer to provide application access to a
`web service. Automatic generation of the web service com
`ponent will provide the benefits of further reduced time and
`cost associated with developing the web service components
`and associated applications, as well as reducing the required
`technical skill required to develop an application that
`accesses web services.
`0.052 FIG. 2 illustrates one embodiment of a web service
`utility 108. In one embodiment, the web service utility 108
`includes an apparatus comprising a plurality of modules
`configured to implement the operations to facilitate auto
`matic generation of the reusable web service component
`112. In one embodiment, the web service utility 108 may
`include a signal bearing medium comprising a program of
`machine-readable instructions executable by the modules of
`the web service utility 108 configured to carry out the
`operations of receiving a web service identifier, determining
`one or more functions provided by the web service 110, and
`automatically generate a reusable web service component
`112 configured to receive an application request and return
`a web service result.
`0053. In one embodiment, the web service utility 108
`includes a receive module 202 configured to receive a web
`service identifier. The identifier may include an address for
`a web service 110 such as a URL address, the name of a web
`service 110, a description of a web service, or a key word
`that can be associated with a web service 110. In one
`embodiment, the receive module 202 receives input from a
`user. The web service utility 108 may present a dialogue box
`for a user to type in the web service identifier such as a
`worldwide web URL. In certain embodiments, the receive
`module 202 may include electrical contacts configured to
`conduct instruction bearing signals, as well as buffers and
`other digital logic gates configured to process the received
`web service identifier.
`0054. In one embodiment, the communication module
`204 is configured to establish communication with a web
`service 110. The communication module 204 may establish
`a communication link using HTTP through the internet.
`Alternatively, the communication module 204 may establish
`
`Page 12 of 17
`
`

`

`US 2006/0271537 A1
`
`Nov.30, 2006
`
`a direct peer to peer link with the server 106 hosting the web
`service 110, and transfer information about the web service
`110 using File Transfer Protocol (FTP), or the like. In one
`embodiment, the information may include a user manual,
`port definition, instructions for interfacing, description of the
`service, or the like. Alternatively, the communication mod
`ule 204 may send a request for the WSDL information to the
`web service 110. The communication module 204 may then
`send the WSDL information to the determination module
`206 for further evaluation.
`0055. In one embodiment, the determination module 206
`is configured to determine one or more functions provided
`by the web service 110. The determination module may
`utilize the WSDL information to evaluate the functions
`available. A function may include a sub-service feature or
`functionality provided by the web service 110. For example,
`the AmazonTM web service 110 may provide a book search
`function, a book information function, and a book ordering
`function. These functions may be accessible from the same
`address for the AmazonTM web service 110 with a