Mule soft ppt 2

Agenda
Mule Integration Workshop
SOAP Webservices

Mule ESB 3.x
Mule Management Console
• Mule ESB 3.x
• Mule Management Console
• Mule Studio

SOAP
With WS-* web services, a client application utilize XML messages using the SOAP standard.
Such a request is recognized by the web service and returns a response to the client. If a client
does not know what operations a web service provides, then the WSDL for the service can be
queried to see what operations are supported before the request is made.
WS-* services can be constructed using various technologies – Axis, CXF and .NET being the
most popular – and clients can also invoke these services using any of these technologies. Mule
enables the use of web services by CXF module.
Implemented through CXF module:
Supports JAX-WS for Component Annotations
Mule can send/receive to/from a web service:
Web service can be hosted in a Mule instance,
Mule can integrate with any Standard SOAP Web Service engine
In Mule, we can configure a component to have a web service as an inbound endpoint. This
causes the component to be hosted as a web service; it is visible to outside applications as a
web service automatically. Whenever a request is received, component will be invoked.

SOAP (Contd)
A component can also be configured to have a web service as an outbound
endpoint. This causes Mule to transform the original request into a SOAP
request and route this to a web service.
The web service can be hosted either locally or remotely. It may also be
hosted inside a Mule instance. These external web services can be constructed
using any technology that implements the web service standards, like Axis,
Xfire, .NET, etc.
A Mule application needs to be configured depending on the technology
used.
Data is transferred using XML:
HTTP transport is implicitly used
SOAP can also be used over other transports
JMS is one popular choice
Data is transferred through XML packets of data across the HTTP transport,
which is implicitly used when web service endpoints are defined. SOAP can
also be used across other transports like JMS, for instance.

SOAP – Operation/Option (Contd)
Frontend Mode
Server
Client
Simple
<simple-service> builds services based on simple POJOs - no annotations are needed. CXF will introspect
POJOs and generate a WSDL for them
<simple-client> allows to interact with a service which was built with the simple frontend if we have a copy
of the service interface.
JAX-WS
<jaxws-service> builds a web service message processor which using the JAX-WS and JAXB standard
annotations or from a set of classes generated from a WSDL. These annotations give complete control over
how our schemas and WSDL are generated.
<jaxws-client> builds a message processor which can operate in two modes: 1) it can use a JAX-WS client
generated from WSDL. 2) it can use a JAX-WS service interface which matches the server interface.
Proxy
<proxy-service> provides raw SOAP and WS-* processing for incoming XML messages, allowing to apply
things like WS-Security to incoming messages and work with the raw XML.
<proxy-client> provides raw SOAP and WS-* processing for outgoing XML messages, allowing to send
outgoing messages in raw XML form and apply things like WS-Security to them.

JAX-WS - Exposing a JAX-WS Web service - Interface
Exposing a JAX-WS Web service - Interface
Eg:
import javax.jws.WebService;
import javax.jws.WebParam;
@WebService
public interface TicketPriceInterface{
String getPrice(@WebParam(name="destination") String destination);
}
This example represents an interface to a web service class. It has a single method returning the status of an airline
ticket, represented by the passenger name record identifier.
Note: we are importing the JAX package and annotating the interface by using the ‘@’ notation indicating that this
interface is a web service. We are also using the “WebParam” annotation in order to set a more descriptive name to
the web service parameter rather than having the default ‘arg0’ being set.

JAX-WS-Exposing a JAX-WS Web service–
Class,MuleConfig
Exposing a JAX-WS Web service - Class
package com.mulesoft;
import javax.jws.WebService;
public class TicketPriceService extends TicketPriceComponent implements TicketPriceInterface{
}
This class implements the previous interface. It is annotated to show which interface to use and the name of the web
service. Note that there is no implementation for the method ‘getPrice(String destination)’ here as this is already
present inside the ‘TicketPriceComponent’ class from which this class extends.
Exposing a JAX-WS Web service – Mule Config
<flow name="ticketStatus">
<http:inbound-endpoint address=http://localhost:8083/price exchange-pattern="request-response">
</http:inbound-endpoint>
<cxf:jaxws-service serviceClass="com.mulesoft.TicketPriceInterface" />
<component class="com.mulesoft.TicketPriceService" /></flow>
Can call the service by using http://localhost:8083/price/getPrice/destination/SFO.
This Mule configuration is similar to the configuration shown previously for exposing a ‘simple’ web service. If we
browse to ‘http://10.0.0.1/status?WSDL’, will see the WSDL that the CXF module create. We can invoke this web service
from within a web browser by using the; “http://host/OPERATION/PARAM_NAME/PARAM_VALUE” format as shown
above. Note that the REST-like URI will be understood by CXF but only if the web service is built using the JAX-WS
annotations.

JAX-WS – Consuming a JAX-WS CXF Web service
Consuming a JAX-WS CXF Web service
• CXF Client:
• Build a CXF client message processor
• Client based on a simple/JAX-WS interface does not need to be generated
using WSDL to Java tool. For this, we need a copy of the service interface
and all data objects locally
• Foreign web service can be:
• Local or remote
• Remote web services must be built using a WSDL to Java tool
• CXF, Axis, .NET, etc.
• CXF client attributes:
• clientClass – Generated WSDL2Java class
• serviceClass – Service Interface Class for local
• wsdlPort
• wsdlLocation
• Operation – if multiple parameters they are put in a Object[] Array

JAX-WS–Consuming a JAX-WS CXF Web service-Config
• wsdlLocation – refers to the WSDL file.
• operation – The name of the operation invoked on the web service.
The objects passed to the endpoint must match the signature of the
method for this operation. If the operation takes in multiple
parameters, they must be put in an ‘Object[]’ array.
Consuming a JAX-WS CXF Web service – Mule Config
<http:outbound-endpoint address="http://localhost:63081/price" exchange-pattern="request-response">
</http:outbound-endpoint>
<cxf:jaxws-client serviceClass="com.mulesoft.TicketPriceInterface" operation="getPrice">
</cxf:jaxws-client>
In this example we see how to consume a JAX-WS web service, this is similar to the configuration used to
consume the simple CXF service. Note that the CXF message processor must be defined within an outbound
endpoint. We need a copy of the service interface and all data objects used to build the service locally in order
for this example to work.

Mule soft ppt 2

More Related Content

What's hot (17)

Similar to Mule soft ppt 2 (20)

Recently uploaded (20)

Mule soft ppt 2