Frontend
CXF provides the concept of frontend modeling, which lets you create web services
using different frontend APIs. The APIs let you create a web service using simple
factory beans and JAX-WS implementation. It also lets you create dynamic web
service clients. The primary frontend supported by CXF is JAX-WS. We will look
at how to use the Frontend programming model in the next chapter.
JAX-WS
JAX-WS is a specification that establishes the semantics to develop, publish, and
consume web services. JAX-WS simplifies web service development. It defines
Java-based APIs that ease the development and deployment of web services.
The specification supports WS-Basic Profile 1.1 that addresses web service
interoperability. It effectively means a web service can be invoked or consumed by
a client written in any language. JAX-WS also defines standards such as JAXB and
SAAJ. CXF provides support for complete JAX-WS stack.
JAXB provides data binding capabilities by providing a convenient way to map XML
schema to a representation in Java code. The JAXB shields the conversion of XML
schema messages in SOAP messages to Java code without the developers seeing
XML and SOAP parsing. JAXB specification defines the binding between Java and
XML Schema. SAAJ provides a standard way of dealing with XML attachments
contained in a SOAP message.
JAX-WS also speeds up web service development by providing a library of
annotations to turn Plain Old Java classes into web services and specifies a detailed
mapping from a service defined in WSDL to the Java classes that will implement that
service. Any complex types defined in WSDL are mapped into Java classes following
the mapping defined by the JAXB specification.
As discussed earlier, two approaches for web service development exist: Code-First
and Contract-First. With JAX-WS, you can perform web service development using
one of the said approaches, depending on the nature of the application.
With the Code-first approach, you start by developing a Java class and interface and
annotating the same as a web service. The approach is particularly useful where
Java implementations are already available and you need to expose implementations
as services.
You typically create a Service Endpoint Interface (SEI) that defines the service
methods and the implementation class that implements the SEI methods. The
consumer of a web service uses SEI to invoke the service functions. The SEI directly
corresponds to a wsdl:portType element. The methods defined by SEI correspond
to the wsdl:operation element.
@WebService
public interface OrderProcess {
String processOrder(Order order);
}
JAX-WS makes use of annotations to convert an SEI or a Java class to a web
service. In the above example, the @WebService annotation defined above the
interface declaration signifies an interface as a web service interface or Service
Endpoint Interface.
In the Contract-first approach, you start with the existing WSDL contract, and generate
Java class to implement the service. The advantage is that you are sure about what to
expose as a service since you define the appropriate WSDL Contract-first. Again the
contract definitions can be made consistent with respect to data types so that it can be
easily converted in Java objects without any portability issue. In Chapter 3 we will look
at how to develop web services using both these approaches.
WSDL contains different elements that can be directly mapped to a Java class
that implements the service. For example, the wsdl:portType element is directly
mapped to SEI, type elements are mapped to Java class types through the use of Java
Architecture of XML Binding (JAXB), and the wsdl:service element is mapped to
a Java class that is used by a consumer to access the web service.
The WSDL2Java tool can be used to generate a web service from WSDL. It has various
options to generate SEI and the implementation web service class. As a developer,
you need to provide the method implementation for the generated class. If the WSDL
includes custom XML Schema types, then the same is converted into its equivalent
Java class.
Simple frontend
Apart from JAX-WS frontend, CXF also supports what is known as 'simple frontend'.
The simple frontend provides simple components or Java classes that use reflection
to build and publish web services. It is simple because we do not use any annotation
to create web services. In JAX-WS, we have to annotate a Java class to denote it
as a web service and use tools to convert between a Java object and WSDL. The
simple frontend uses factory components to create a service and the client. It does
so by using Java reflection API. In Chapter 3 we will look at how to develop simple
frontend web services
The following code shows a web service created using simple frontend:
// Build and publish the service
OrderProcessImpl orderProcessImpl = new OrderProcessImpl();
ServerFactoryBean svrFactory = new ServerFactoryBean();
svrFactory.setServiceClass(OrderProcess.class);
svrFactory.setAddress("http://localhost:8080/OrderProcess");
svrFactory.setServiceBean(orderProcessImpl);
svrFactory.create();