1. 1 3. Implementing Web Services 1.Create SOAP proxy interfaces and WSDL based service descriptions 2.Register/publish services 3.Stores service descriptions as binding templates&URL 4.Locates services and its binding info 5.Invoke & obtain WSDL 6.Exchange data using SOAP RPC/Messaging Web Services requester Service delivery -SOAP Clients Web Services Broker UDDI based Registry Services Web Services Provider Service container -SOAP Interfaces -WSDL Descriptions General Approach A Web service can be created as a new application or from using an existing application by re-purposing them as services.

2. 2 Web Services Support in J2EE  Java Architecture for XML Binding (JAXB) provides Application developers with a way to generate programming objects based on XML definitions and vice versa, more specifically: -Marshalling: converting a Java object tree into an XML document. -Unmarshalling: converting an XML document into a Java object tree. -Validation: checking an XML document for conformance with a DTD. marshalling unmarshalling <> XML schema Instance Of XML document Java Object compiling Conforms to Java class

3. 3  Java provides the Java API for XML Remote Procedure Calls (JAX-RPC) -Set of high-level Java APIs enabling XML-based Java applications to interoperate using RPC. -Used for synchronous communications UDDI Application server -JAX-RPC runtime -JAX-RPC API -Service endpoint 3. Soap/http request 4. Soap/http response 1. Lookup service 2. Return information Client  Java provides the Java API for XML Messaging (JAXM) -Lightweight XML messaging API for application-to-application (A2A) integration and business-to- business (B2B) communication. -Support asynchronous communications JAXM API JAXM Messaging Provider JAXM Messaging Provider SOAP message HTTP Receiver ApplicationSender Application

4. 4 JAX-RPC Application Architecture -A typical JAX-RPC application architecture model involves:  JAX-RPC Service: Java business component (e.g. servlet, bean).  JAX-RPC Service client: access exposed Web service.  Serialization/Deserialization:Java-to-XML and XML-to-Java mappings  JAX-RPC Runtime Environment: runtime mechanisms and execution environment for the Web services and service clients. J2SE Environment JAX-RPC Client Invocation Stubs/Dynamic Proxy/DII JAX-RPC Runtime JWSDP Environment JAX-RPC-based Service TIES JAX-RPC Runtime WSDL Request/Response Soap over HTTP

5. 5 JAX-RPC-based Service Implementation -JAX-RPC services can be implemented using Java classes (  RMI) or by using a WSDL document. Developing a JAX-RPC Service from Java Classes -The key steps include the following: 1.Define the Remote interface (Service Definition). 2.Implement the remote interface (Service Implementation). 3.Configure the Service. 4.Generate the Stubs and ties. 5.Package and deploy the service. Developing a JAX-RPC-based Service from a WSDL Document -This consists of developing a JAX-RPC-based service using a WSDL document exposed by an existing Web services environment. -The key steps include the following: 1.Create a service configuration referring to the WSDL. 2.Generate the client-side stubs and server-side ties. 3.Package and deploy the service.

6. 6 JAX-RPC Client Implementation -Can be implemented either as stub-based or dynamic proxy-based or dynamic invocation interface based. Stub-based Client -Uses the local stub classes generated (automatically) from the WSDL file. Dynamic Proxy-based Client -Enables the invocation of a target service endpoint dynamically at runtime, without requiring a local stub class. Dynamic Invocation Interface (DII) Client -Enables the client to discover and invoke target services dynamically at runtime. -The client uses a set of operations and parameters, and a search criterion to discover the target service. Hence a client can invoke a service and its methods without knowing in advance its data types.

7. 7 4. Sample Implementation SOA for Sample Implementation > StockBroker > StockClient > StockTrader getStockQuote(index:int): double > broker: StockTrader > client: StockTrader

8. 8 Service Definition import java.rmi.*; public interface StockTrader extends java.rmi.Remote { public double getStockQuote(int id) throws java.rmi.RemoteException; } Service Implementation import java.rmi.*; public class StockTraderImpl implements StockTrader { public double getStockQuote(int id) { return ((new Quote(id)).getValue()); } Web Service Implementation

9. 9 Configuring the Service -Sample configuration file: serviceconfig.xml <service name=“StockTrader” targetNamespace=http://www.binkadi.com/jws/wsdl typeNamespace=http://www.binkadi.com/jws/types packageName=“com.binkadi.jws.stock.jaxrpc”> -Service configuration requires creating a configuration file in an XML format that provides the following information:  The name of the service.  The name of the package containing the stubs and ties.  The target namespace for the generated WSDL and its XML schema and class names of the remote interface and its implementation.

10. 10 · Service interface: A factory for stubs or dynamic invocation/proxy objects that are used to actually invoke methods · ServiceFactory class: A factory for Services · Call interface: Used for dynamic invocation · Stub interface: Base interface for stubs JAX-RPC Client-Side APIs (javax.xml.rpc) -There are just a few key classes and interfaces that are needed to write Web service clients or service implementations:

11. 11 Usage for Dynamic Invocation: 1.The client creates a ServiceFactory 2.From the ServiceFactory, the client instantiates a Service ServiceFactory sFactory = ServiceFactory.newInstance(); Service service = serviceFactory.createService(new Qname(qService)); - The Service is a factory object that creates the port. The port is a remote interface (java.rmi.Remote) into the Web service. - In the case of dynamic RPC, the Service object is used to create Call objects, which specify which method to call on the Web services port. Call call = service.createCall(target_port); call.setTargetEndpointAddress(target_endpoint); call.setOperationName(newQname(BODY_NAMESPACE_VALUE,”getStockPrice”));

12. 12 1.Obtain the interface details of the Web service you want to invoke. · by getting a WSDL file that describes the Web service 2. Optionally generate Web service client invocation code (stubs). · This step is optional as there is usually a dynamic invocation API available where a stub is not required to invoke a Web service. 3. Write the client. · Static call: create or obtain a reference to a stub object and then call its Web service-exposed methods. · Dynamic call: create a call object and invoke a method on the web service (a stub is not required). 4. Run the client. · To run the client, your Web service runtime's client code will need to be in your classpath. Creating and running an RPC-style Web service client

13. 13 //Execute the remote method System.out.println(stub.getStockQuote(1233465)); } catch (Exception ex) { ex.printStackTrace(); } Stub-based Client -Uses the local stub classes generated by the WSDL compiler. //import the Stub interface import javax.xml.rpc.Stub; public class StockClient { public static void main(String[] args) { try { //obtain the instance of Stub interface StockTrader_Stub stub = (StockTrader_Stub) (new StockTrader_Impl().getStockTraderPort()); //Configure the stub setting required properties stub._setProperty(javax.xml.rpc.Stub.ENDPOINT_ADDRESS_PROPERTY, http://www.binkadi.com/jws/jaxrpc/stocktrader);

14. 14 4. Set the URL location of the Service: String endpoint ="http://localhost:6080/SimpleRPC/services/StockTrader"; call.setTargetEndpointAddress(endpoint); Dynamic Web service client 1. Import the needed classes: import javax.xml.namespace.QName; import javax.xml.rpc.Call; import javax.xml.rpc.Service; 2. Create a Service object: Service service = (Service) Class.forName("org.apache.axis.client.Service").newInstance(); 3. Use the Service to create the call object: Call call = (Call) service.createCall(); 5. Invoke the call object: Object [] arguments = new Object[0]; String stockId = (String) call.invoke(arguments);

15. 15 Example: import javax.xml.namespace.QName; import javax.xml.rpc.Call; import javax.xml.rpc.Service; public class StockClient { public static void main(String[] args) throws Exception{ String endpoint = "http://localhost:6080/SimpleRPC/services/StockTader"; String namespaceURI = "http://server.simplerpc.stock.lpc"; Service service = (Service) Class.forName("org.apache.axis.client.Service").newInstance(); Call call = (Call) service.createCall(); call.setTargetEndpointAddress(endpoint); call.setOperationName(new QName(namespaceURI,"getQuote")); Object [] arguments = new Object[0]; String quote = (String) call.invoke(arguments); System.out.println(“Stock quote: " + quote); } }