Book Name: Service Oriented Architecture with Java

Authors      : Binildas A. Christudas,Malhar Barai,                      Vincenzo Caselli 

Publisher   : Packt

Language  : English

Why this book is Special?

• This book is special because of one reason. It collectively describes all the information and frameworks those a Java Web Service Programmer wants to know. If you are a Java developer and wants to implement SOA through Web Services then I am sure this book will give you a good idea about the frameworks those will help you for this.

To whom this book is helpful?

• If you are a Java Programmer who wants to learn more about SOA with web services..
• If you want to learn any of the Famous Java Web service Implementation frameworks like Axis2, Spring WS, CXF etc.. OR if you need to know more basic but mush needed information about SOA using Web services.
• If you want to get some idea about SCA and SDO.

Advantages:

• Even if you are new to the web service concepts also you can use this book. Its starts from the beginning.
• Start with explaining how SOA helps in the Software world and what all are its advantages.
• It explains about RPC and Document Based-WS and all its basics.
• If you are familiar with Ant then examples will be more easy because almost all examples are using Ant scripts.
• It also goes through JAXB binding and its examples.
• It will be very rare to get books related with Service Component Architecture this time. This book had a good explanation about this Architecture and it gives a good example with its description. Being a person who implemented SCA this section was very interesting to me.
• Gives a very good introduction about MOM and ESBs. If you are just starting to learn these then this book will be helpful to you.
• It gives web service implementation examples with multiple frameworks. CXF, Axis2 and Spring WS are the most famous two frameworks which we are using nowadays. And you can find examples for these three frameworks application examples.

Disadvantages:

• I think description is less for each topics. Book is covering a lot of topics and for each one we can write one entire book. But as a reader of this book I am expecting some more explanation for each topic. Sometimes I feel the author is just touching a topic and going to the next one.
• Some of the Described Versions became OLD. For example Axis2 is there now. Book is already mentioned Axis2 and CXF but taken Axis1.x and XFire for the further explanation.

“Your life today is the result of your attitudes and choices in the past. Your life tomorrow will be the result."

This is a story of an elderly carpenter who had been working for a contractor for the past 53 years. He had built many beautiful houses but now as he was getting old, he wanted to retire and lead a leisurely life with his family. So, he goes to the contractor and tells him about his plan of retiring. The contractor feels sad at the prospect of losing a good worker but agrees to the plan because the carpenter had indeed become too fragile for the tough building work. But as a last request, he asks the old carpenter to construct just one last house.
The old man agrees and starts working but his heart was not in his work any more. He had lost the motivation towards work. So, he resorted to shoddy workmanship and constructed the house half-heartedly. After the house was built, the contractor came to visit his employee’s last piece of work. After inspecting the house, he handed over the front door keys to the carpenter and said, “This is your new house. My gift to you.” The carpenter was shocked and upset. Had he known that he was building his own house, he would have done a better job! Now, he would have to live in the house, which is not worth staying.
Think of yourself as the carpenter. You work hard every day but are you giving your best? We put our least to the work we don’t like or do not have interest in. Later, we get shocked at the situation we have created for ourselves and try to figure out why we didn’t do it differently.
Enjoy your tasks and carry on your responsibilities with pleasure and not with pain. “Life is a do-it-yourself project”. Do your job enthusiastically and with devotion, a positive output and a pleasing life will certainly be on your way.

What is WSDL and what its Structure?

A WSDL document defines services as collections of network endpoints, or ports. In WSDL, the abstract definition of endpoints and messages is separated from their concrete network deployment or data format bindings. This allows the reuse of abstract definitions: messages, which are abstract descriptions of the data being exchanged, and port types which are abstract collections of operations.

The concrete protocol and data format specifications for a particular port type constitutes a reusable binding. A port is defined by associating a network address with a reusable binding, and a collection of ports define a service. Hence, a WSDL document uses the following elements in the definition of network services:

WSDL document describes a web service using these major elements:

Element	Defines
<types>	The data types used by the web service
<message>	The messages used by the web service
<portType>	The operations performed by the web service
<binding>	The communication protocols used by the web service
<port>	A single endpoint defined as a combination of a binding and a network address.
<service>	A collection of related endpoints.

The main structure of a WSDL document looks like this:

<definitions>              <types>                       definition of types……..              </types>              <message>                       definition of a message….              </message>              <portType>                       definition of a port…….              </portType>             <binding>                      definition of a binding….              </binding>               <service>                      definition of services….              </service> </definitions>

A WSDL document can also contain other elements, like extension elements and a service element that makes it possible to group together the definitions of several web services in one single WSDL document.

Creating WSDL for our Example

<types>:In the Types we are defining or configuring the Datatypes which we are using for the entire application. Here we are importing the XSD files here.

<message>:In our example we need to configure our input and our parameters/ the message which we are passing through Webservice. We are configuring request and response objects here.

<portType>: We have one operation which is called getProduct. So here we need to declare this getProduct operation.

<binding> : Here we will be providing our protocol types and we are using SOAP protocol.

<service> : Defining the Service End point. And for the ProductService we are defining it as “http://localhost:8080/ContractFirst/services/ProductService”

   1: <?xml version="1.0" encoding="UTF-8" standalone="no"?>

   2: <wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"

   3:     xmlns:tns="http://com/your/company/service/ProductService/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"

   4:     xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="ProductService"

   5:     targetNamespace="http://com/your/company/service/ProductService/"

   6:     xmlns:prd="http://com/your/company/service/Product/">

   7:     <wsdl:types>

   8:         <xsd:schema targetNamespace="http://com/your/company/service/ProductService/"

   9:             xmlns:prd="http://com/your/company/service/Product/">

  10:             <xsd:import namespace="http://com/your/company/service/Product/"

  11:                 schemaLocation="../Product.xsd" />

  12:             <xsd:element name="getProductRequest">

  13:                 <xsd:complexType>

  14:                     <xsd:sequence>

  15:                         <xsd:element name="productRequest" type="prd:ProductRequest" />

  16:                     </xsd:sequence>

  17:                 </xsd:complexType>

  18:             </xsd:element>

  19:             <xsd:element name="getProductResponse">

  20:                 <xsd:complexType>

  21:                     <xsd:sequence>

  22:                         <xsd:element name="productResponse" type="prd:ProductResponse" />

  23:                     </xsd:sequence>

  24:                 </xsd:complexType>

  25:             </xsd:element>

  26:         </xsd:schema>

  27:     </wsdl:types>

  28:     <wsdl:message name="ProductRequest">

  29:         <wsdl:part element="tns:getProductRequest" name="parameters" />

  30:     </wsdl:message>

  31:     <wsdl:message name="ProductResponse">

  32:         <wsdl:part element="tns:getProductResponse" name="parameters" />

  33:     </wsdl:message>

  34:     <wsdl:portType name="ProductService">

  35:         <wsdl:operation name="getProduct">

  36:             <wsdl:input message="tns:ProductRequest" />

  37:             <wsdl:output message="tns:ProductResponse" />

  38:         </wsdl:operation>

  39:     </wsdl:portType>

  40:     <wsdl:binding name="ProductServiceSOAP" type="tns:ProductService">

  41:         <soap:binding style="document"

  42:             transport="http://schemas.xmlsoap.org/soap/http" />

  43:         <wsdl:operation name="getProduct">

  44:             <soap:operation

  45:                 soapAction="http://com/your/company/service/ProductService/getProduct" />

  46:             <wsdl:input>

  47:                 <soap:body use="literal" />

  48:             </wsdl:input>

  49:             <wsdl:output>

  50:                 <soap:body use="literal" />

  51:             </wsdl:output>

  52:         </wsdl:operation>

  53:     </wsdl:binding>

  54:     <wsdl:service name="ProductService">

  55:         <wsdl:port binding="tns:ProductServiceSOAP" name="ProductServiceSOAP">

  56:             <soap:address

  57:                 location="http://localhost:8080/ContractFirst/services/ProductService" />

  58:         </wsdl:port>

  59:     </wsdl:service>

  60: </wsdl:definitions>

In our next part we will go through Skelton creation using WSDL to Java tool which is giving by CXF. We will go through class path settings and wsdl2java commands.

Why people are interested in CODE-FIRST approach? Answer is simple. No need to go through the complexities of XML, XSD, WSDL structure. Just code in any of your favorite programming language and create the WSDL file using any of your tools/frameworks. I had taken some interviews these days for a Webservice-SOA project. Honestly it was too difficult to find out the right candidates with good knowledge in Webservices. Most of them are just consumed webservices. And if we find somebody who developed webservices then they would be just familiar with the Code first approach and have no idea about WSDL files. Becuase just seeing WSDL in that endpoint URL finishes their works.

Here in this series of Posts I would like to put a small webservice example which is doing in “CONTRACT FIRST” approach.

If you want to go through a Code-First Approach using CXF then please check my previous posts. For your convenience I am pasting it below.

1. Creating Web services using Apache CXF (Part 1) : The Basics.
2. Creating Web services using Apache CXF (Part 2) : Development.
3. Creating Web services using Apache CXF (Part 3) : Configuration.
4. Creating Web services using Apache CXF (Part 4): Testing.

Why we require CONTRACT FIRST approach?

This article from SOA world will help you to understand. A contract-first approach results in better long-term development, interoperability, and maintenance. For larger applications, long-lasting Web services, and service-oriented architecture (SOA), contract-first thinking has advantages that usually outweigh the ease of method-first thinking. I know first exposure to Web services, WSDL and Schema are very tough to grasp but when you are coming into a BIG SOA application development people will choose contract-first. At least me!

Some of the Points for this selection are:

• Its better to define data types and all first than converting from a programming language.
• It makes you be very clear with both the producer and consumer of the service exactly what is needed and what is expected
• Contract-first is the generally accepted ‘best practice”.

Creating a small webservice application using CXF

Lets start our example. Want we are trying to achieve is, we want to deploy a service called “getProduct”. If we are giving a “Composite ID” as an input to our web service then it should return a Product Details to us.

First we will start with our XSD structure. Even though this is a small service and we can define it inside the WSDL itself, we will create a separate XSD for our better understanding. We can import this XSD in the types tag of WSDL.

Creating our XSD

Here I had created one ProductDetails and one ProductId types.

Product Details contains all the product related information like productname, category, price and details. ProductId type is a composite primary key with sequence number and deptcode. I am also created a request and response types here.

   1: <?xml version="1.0" encoding="UTF-8"?>

   2: <xsd:schema targetNamespace="http://com/your/company/service/Product/"

   3:     xmlns:prd="http://com/your/company/service/Product/"

   4:     elementFormDefault="qualified" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

   5:     <xsd:complexType name="productID">

   6:         <xsd:sequence>

   7:             <xsd:element minOccurs="0" name="sequenceNumber" type="xsd:int" />

   8:             <xsd:element minOccurs="0" name="deptNumber" type="xsd:string" />

   9:         </xsd:sequence>

  10:     </xsd:complexType>

  11:     <xsd:complexType name="productDetails">

  12:         <xsd:sequence>

  13:             <xsd:element name="id" nillable="false" type="prd:productID" />

  14:             <xsd:element name="productName" nillable="false" type="xsd:string" />

  15:             <xsd:element name="category" nillable="true" type="xsd:string" />

  16:             <xsd:element name="price" nillable="false" type="xsd:long" />

  17:             <xsd:element name="details" nillable="true" type="xsd:string" />

  18:         </xsd:sequence>

  19:     </xsd:complexType>

  20:     <xsd:complexType name="ProductRequest">

  21:         <xsd:sequence>

  22:             <xsd:element name="productID" type="prd:productID" />

  23:         </xsd:sequence>

  24:     </xsd:complexType>

  25:     <xsd:complexType name="ProductResponse">

  26:         <xsd:sequence>

  27:             <xsd:element name="product" type="prd:productDetails" />

  28:         </xsd:sequence>

  29:     </xsd:complexType>

  30: </xsd:schema>

In the next PART we will be creating a small WSDL file which internally using this XSD. Points we cover are WSDL Tags, XSD inclusion, NameSpaces. <Click on this link to move to that post>

To test this we can follow the same client program which is given in the CXF site.

Just create a simple Java class and execute it.

   1: package com.your.company.service.client;

   2:  

   3: import java.util.List;

   4:  

   5: import org.apache.cxf.interceptor.LoggingInInterceptor;

   6: import org.apache.cxf.interceptor.LoggingOutInterceptor;

   7: import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;

   8:  

   9: import com.your.company.service.Product;

  10: import com.your.company.service.ProductService;

  11:  

  12: public final class Client {

  13:  

  14:     private Client() {

  15:     }

  16:  

  17:     public static void main(String args[]) throws Exception {

  18:  

  19:         JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

  20:  

  21:         factory.getInInterceptors().add(new LoggingInInterceptor());

  22:         factory.getOutInterceptors().add(new LoggingOutInterceptor());

  23:         factory.setServiceClass(ProductService.class);

  24:         factory.setAddress("http://localhost:8080/CXFExample/productservice");

  25:         ProductService client = (ProductService) factory.create();

  26:  

  27:         List<Product> products = client.getProducts();

  28:         if (products != null && products.size() > 0)

  29:             System.out.println("Product Name : "

  30:                     + products.get(0).getItemName() + ", Price: "

  31:                     + products.get(0).getPrice());

  32:         System.exit(0);

  33:  

  34:     }

  35:  

  36: }

Other related posts:

1. Creating Web services using Apache CXF (Part 1) : The Basics.

2. Creating Web services using Apache CXF (Part 2) : Development.

3. Creating Web services using Apache CXF (Part 3) : Configuration.

4. Creating Web services using Apache CXF (Part 4): Testing.

• Web.xml Declarations

We have to declare Spring Context Listener, CXF Servlet, Spring Context Location and URL Mapping.

   1: <?xml version="1.0" encoding="UTF-8"?>

   2: <web-app id="services" version="2.5"

   3:     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"

   4:     xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

   5:     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

   6:         http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

   7:     

   8:     <!-- Adding the Spring Context Listener. It will help to init Spring Context -->

   9:     <listener>

  10:         <listener-class> org.springframework.web.context.ContextLoaderListener 

  11:         </listener-class>

  12:     </listener>

  13:     

  14:     <!-- Context file location of Spring -->

  15:     <context-param>

  16:         <param-name>contextConfigLocation</param-name>

  17:         <param-value>/WEB-INF/applicationContext.xml</param-value>

  18:     </context-param>

  19:     

  20:     <!-- CXF Servlet -->

  21:     <servlet>

  22:         <servlet-name>CXFServlet</servlet-name>

  23:         <servlet-class> org.apache.cxf.transport.servlet.CXFServlet 

  24:         </servlet-class>

  25:     </servlet>

  26:     

  27:     <!-- Mapping with a URL Pattern -->

  28:     <servlet-mapping>

  29:         <servlet-name>CXFServlet</servlet-name>

  30:         <url-pattern>/*</url-pattern>

  31:     </servlet-mapping>

  32: </web-app>

• Application Context configurations

   1: <?xml version="1.0" encoding="UTF-8"?>

   2: <beans xmlns="http://www.springframework.org/schema/beans"

   3:     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

   4:     xmlns:cxf="http://cxf.apache.org/core" xmlns:jaxws="http://cxf.apache.org/jaxws"

   5:     xsi:schemaLocation="http://www.springframework.org/schema/beans

   6:         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

   7:         http://www.springframework.org/schema/context

   8:         http://www.springframework.org/schema/context/spring-context-2.5.xsd

   9:         http://cxf.apache.org/core

  10:         http://cxf.apache.org/schemas/core.xsd

  11:         http://cxf.apache.org/jaxws

  12:         http://cxf.apache.org/schemas/jaxws.xsd"

  13:     default-autowire="byName">

  14:  

  15:     <!-- Load CXF modules from cxf.jar -->

  16:     <import resource="classpath:META-INF/cxf/cxf.xml" />

  17:     <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />

  18:     <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />

  19:         

  20:     <!-- The service bean -->

  21:     <bean id="productServiceImpl" class="com.your.company.service.ProductServiceImpl" />

  22:  

  23:     <!-- Aegis data binding -->

  24:     <bean id="aegisBean" class="org.apache.cxf.aegis.databinding.AegisDatabinding"

  25:         scope="prototype" />

  26:     <bean id="aegis-service" class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean"

  27:         scope="prototype">

  28:         <property name="dataBinding" ref="aegisBean" />

  29:         <property name="serviceConfigurations">

  30:             <list>

  31:                 <bean class="org.apache.cxf.jaxws.support.JaxWsServiceConfiguration" />

  32:                 <bean class="org.apache.cxf.aegis.databinding.AegisServiceConfiguration" />

  33:                 <bean class="org.apache.cxf.service.factory.DefaultServiceConfiguration" />

  34:             </list>

  35:         </property>

  36:     </bean>

  37:     

  38:     <!-- Service endpoint -->

  39:     <jaxws:endpoint id="productService"

  40:         implementorClass="com.your.company.service.ProductServiceImpl"

  41:         implementor="#productServiceImpl" address="/productservice">

  42:         <jaxws:serviceFactory>

  43:             <ref bean="aegis-service" />

  44:         </jaxws:serviceFactory>

  45:     </jaxws:endpoint>

  46:     

  47:         <!-- Enable message logging using the CXF logging feature -->

  48:     <cxf:bus>

  49:         <cxf:features>

  50:             <cxf:logging />

  51:         </cxf:features>

  52:     </cxf:bus>

  53: </beans>

Create a WAR out of this Project and deploy it in Apache Tomcat. And try to access the WSDL URL

 http://localhost:8080/CXFExample/ProductService?wsdl.

Other related posts:

1. Creating Web services using Apache CXF (Part 1) : The Basics.

2. Creating Web services using Apache CXF (Part 2) : Development.

3. Creating Web services using Apache CXF (Part 3) : Configuration.

4. Creating Web services using Apache CXF (Part 4): Testing.

We need to set-up the project  environment first. Please download the following JARs.

Versions Used :

CXF 2.2.2           Download Link : CXF Site Download Link

Spring 2.5.6       Download Link : SpringSource Download site

The following jars are required for all CXF usage: But you will be getting it through CXF Download.
- cxf.jar
- commons-logging.jar
- geronimo-activation.jar (Or the Sun equivalent) [6]
- geronimo-annotation.jar (Or the Sun equivalent) [6]
- geronimo-javamail.jar (Or the Sun equivalent) [6]
- geronimo-stax-api.jar (Or the Sun equivalent) [6]
- neethi.jar
- jaxb-api.jar  [6]
- jaxb-impl.jar
- XmlSchema.jar
- wstx-asl.jar  [6]
- wsdl4j.jar

The following jars are required for XML catalog support:
- xml-resolver.jar

For Java2WSDL and WSDL2Java:
- The above jars
- jaxb-xjc.jar
- velocity.jar
- commons-collections.jar
- commons-lang.jar

For JAX-WS support:
- geronimo-ws-metadata.jar [6]
- geronimo-jaxws_2.1_spec-1.0.jar (Or the Sun equivalent) [6]
- saaj-api.jar [6]
- saaj-impl.jar [6]
- asm.jar (semi-optional, helps with performance of wrapper types and is
        required when adding JAXB annotations onto the SEI methods and
    parameters.)

For XML Configuration support:
- aopalliance.jar
- spring-beans.jar
- spring-context.jar
- spring-core.jar
- spring.web.jar
- FastInfoset.jar

For standalone HTTP support:
- geronimo-servlet.jar
- jetty.jar
- jetty-util.jar
- sl4j.jar & sl4j-jdk14.jar (optional – but improves logging)
For Aegis support:
- jdom.jar (optional, if you want to map xsd:anyType to JDOM)

For WS-Security support:
- bcprov-jdk15.jar
- xalan.jar
- serializer.jar
- wss4j.jar
- xmlsec.jar

For HTTP Binding support:
- jra.jar
- jettison.jar (Needed for JSON services only)

For JAX-RS support:
- abdera*
- axiom*
- jsr311-api.jar
- jettison.jar (Needed for JSON services only)

For JMS transport
- geronimo-jms.jar (Or the Sun equivalent)
- spring-jms.jar

For CORBA support:
- antlr.jar

If you want to use Aegis databinding which is providing by CXF then:

Download :jdom-1.0.jar

For Spring you can download its latest version say 2.5.

Step 2: Creating a Project

• Open your IDE ( I am using Eclipse) and create a Web project. Lets say with Name CXFExample.

• Create a package say “com.your.company.service”
• Create a POJO class with a name say “Product”. And include some properties like productName etc.

   1: package com.your.company.service;

   2:  

   3: import org.apache.cxf.aegis.type.java5.IgnoreProperty;

   4:  

   5: public final class Product {

   6:     private String itemName;

   7:     private String category;

   8:     private double price;

   9:     private String details;

  10:  

  11:     public Product() {

  12:     }

  13:  

  14:     public Product(String itemName, String category, double price,

  15:             String details) {

  16:         this.itemName = itemName;

  17:         this.category = category;

  18:         this.price = price;

  19:         this.details = details;

  20:     }

  21:  

  22:     public String getItemName() {

  23:         return itemName;

  24:     }

  25:  

  26:     public void setItemName(String itemName) {

  27:         this.itemName = itemName;

  28:     }

  29:  

  30:     public String getCategory() {

  31:         return category;

  32:     }

  33:  

  34:     public void setCategory(String category) {

  35:         this.category = category;

  36:     }

  37:  

  38:     public double getPrice() {

  39:         return price;

  40:     }

  41:  

  42:     public void setPrice(double price) {

  43:         this.price = price;

  44:     }

  45:  

  46:     @IgnoreProperty

  47:     public String getDetails() {

  48:         return details;

  49:     }

  50:  

  51:     public void setDetails(String details) {

  52:         this.details = details;

  53:     }

  54:  

  55: }

Note that we used one Annotation from Aegis. Its just to get some idea about that annotation. As you know Aegis is using for data binding. As the annotation denotes if we are mentioning it is not needed in the WSDL file.

• Creating the Service Interface

   1: package com.your.company.service;

   2:  

   3: import java.util.List;

   4:  

   5: import javax.jws.WebParam;

   6: import javax.jws.WebService;

   7:  

   8: @WebService

   9: public interface ProductService {

  10:  

  11:     List<Product> getProducts();

  12:  

  13:     void addProduct(@WebParam(name = "product") Product product);

  14:  

  15:     public void addProducts(@WebParam(name = "products") List<Product> products);

  16:  

  17: }

Here we are using @WebService annotation and @WebParam Annotations. They are JAX-WS annotations.

@WebService is using to denote this Interface as the Web Service Interface. So while creating WSDL file this will consider.

@WebParam is using to name the Arguments in the WSDL file. Default it will be like Arg0, Arg1 etc. But if we are giving some names then that will be more identifiable in the WSDL.

• Create the Service Implementation class

   1: package com.your.company.service;

   2:  

   3: import java.util.ArrayList;

   4: import java.util.List;

   5:  

   6: import javax.jws.WebParam;

   7: import javax.jws.WebService;

   8:  

   9: @WebService(endpointInterface = "edu.web.service.ProductService")

  10: public final class ProductServiceImpl implements ProductService {

  11:  

  12:     public List<Product> getProducts() {

  13:         List<Product> products = new ArrayList<Product>();

  14:         products.add(new Product("SpringInAction", "Manning", 200,

  15:                 "Book about Spring"));

  16:         products.add(new Product("EJB3InAction", "Manning", 200,

  17:                 "Book about EJB3"));

  18:         return products;

  19:     }

  20:  

  21:     @Override

  22:     public void addProduct(Product product) {

  23:         System.out.println(product);

  24:     }

  25:  

  26:     @Override

  27:     public void addProducts(@WebParam(name = "products") List<Product> products) {

  28:         for (Product product : products) {

  29:             System.out.println(product);

  30:         }

  31:     }

  32: }

Here we are writing the Impls of our Interface methods. @WebService annotation is marking this class as a web service implementation

In the next PART we will be discussing about the Configurations.

Other related posts:

1. Creating Web services using Apache CXF (Part 1) : The Basics.

2. Creating Web services using Apache CXF (Part 2) : Development.

3. Creating Web services using Apache CXF (Part 3) : Configuration.

4. Creating Web services using Apache CXF (Part 4): Testing.

As we discussed in the previous post, CXF is the combination of two projects: Celtix developed by IONA and XFire developed by Codehaus working together at the Apache Software Foundation.

If you want an Enterprise support  for CXF then please find the following links.

Click here to Read Full Article

Posted in apache, Celtix, CXF, Spring, Spring Framework, web, Web Applications, webservices, Xfire ]]> http://lijinjoseji.wordpress.com/2009/06/10/creating-web-services-using-apache-cxf-part-1-the-basics/feed/ 17 Lijin Read Full Article http://lijinjoseji.wordpress.com/2009/06/10/creating-web-services-using-apache-cxf-part-1-the-basics/ http://feedproxy.google.com/~r/LijinsBlog/~3/pf6a1DSdqEU/ http://lijinjoseji.wordpress.com/2009/06/10/apache-cxf-an-ultimate-web-service-open-source-framework-lets-start-learning/#comments Wed, 10 Jun 2009 08:43:15 +0000 Lijin http://lijinjoseji.wordpress.com/2009/06/10/apache-cxf-an-ultimate-web-service-open-source-framework-lets-start-learning/ ]]>

Apache CXF is an open source services framework which is a result of the merge between the XFire and Celtix projects. CXF helps us build and develop services using JAX-WS. These services can speak a variety of protocols such as SOAP, XML/HTTP, RESTful HTTP, or CORBA and work over a variety of transports such as HTTP, JMS or JBI.

Click here to Read Full Article

Posted in apache, Celtix, CXF, jax-ws, Spring, Spring Framework, web, Web Applications, webservices, Xfire ]]> http://lijinjoseji.wordpress.com/2009/06/10/apache-cxf-an-ultimate-web-service-open-source-framework-lets-start-learning/feed/ 4 Lijin Read Full Article http://lijinjoseji.wordpress.com/2009/06/10/apache-cxf-an-ultimate-web-service-open-source-framework-lets-start-learning/ http://feedproxy.google.com/~r/LijinsBlog/~3/curpz0rpwGE/ http://lijinjoseji.wordpress.com/2009/06/09/the-second-level-cache-in-hibernate-settings-and-configurations/#comments Tue, 09 Jun 2009 12:35:30 +0000 Lijin http://lijinjoseji.wordpress.com/2009/06/09/the-second-level-cache-in-hibernate-settings-and-configurations/ ]]>

A Hibernate Session is a transaction-level cache of persistent data. We can configure a cluster or JVM-level (SessionFactory-level) cache on a class-by-class and collection-by-collection basis. We can also plug in a clustered cache into Hibernate. At the time of providing cache we need to understand that when we are updating the persistence DB it will not automatically reflect on Cache.

Configuring CACHE in Hibernate

We need to tell Hibernate that which caching implementation we need to  use. This we can accomplish by specifying the name of a class that implements org.hibernate.cache.CacheProvider using the property hibernate.cache.provider_class. Hibernate comes bundled with a number of built-in integrations with open-source cache providers; additionally, we could implement your own and plug it in as outlined above. Prior to 3.2 Hibernate is defaulted to use EhCache as the default cache provider.

To find the CACHE PROVIDERS please check this post <Click Here>

Cache mappings

The <cache> element of a class or collection mapping has the following form:

<cache
    usage="transactional|read-write|nonstrict-read-write|read-only"  (1)
    region="RegionName"                                              (2)
    include="all|non-lazy"                                           (3)
/>

(1)

usage (required) specifies the caching strategy: transactional, read-write, nonstrict-read-write or read-only

(2)

region (optional, defaults to the class or collection role name) specifies the name of the second level cache region

(3)

include (optional, defaults to all) non-lazy specifies that properties of the entity mapped with lazy="true" may not be cached when attribute-level lazy fetching is enabled

Strategy: read only

• Useful for data that is read frequently but never updated.
• It is Simple .
• Best performer among the all.

If application needs to read but never modify instances of a persistent class, a read-only cache may be used. This is the simplest and best performing strategy. It’s even perfectly safe for use in a cluster.

<class name="eg.Immutable" mutable="false">
    <cache usage="read-only"/>
    ....
</class>

Strategy: read/write

• Used when our data needs to be updated.
• It’s having more overhead than read-only caches.
• When Session.close() or Session.disconnect() is called the transaction should be completed in an environment where JTA is no used.
• It is never used if serializable transaction isolation level is required.
• In a JTA environment, for obtaining the JTA TransactionManager we must specify the propertyhibernate.transaction.manager_lookup_class.
• To use it in a cluster the cache implementation must support locking.

If the application needs to update data, a read-write cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property hibernate.transaction.manager_lookup_class, naming a strategy for obtaining the JTA TransactionManager. In other environments, you should ensure that the transaction is completed when Session.close() or Session.disconnect() is called. If you wish to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers do not.

<class name="eg.Cat" .... >
    <cache usage="read-write"/>
    ....
    <set name="kittens" ... >
        <cache usage="read-write"/>
        ....
    </set>
</class>

Strategy: nonstrict read/write

• Needed if the application needs to update data rarely.
• we must specify hibernate.transaction.manager_lookup_class to use this in a JTA environment .
• The transaction is completed when Session.close() or Session.disconnect() is called In other environments (except JTA) .

If the application only occasionally needs to update data (ie. if it is extremely unlikely that two transactions would try to update the same item simultaneously) and strict transaction isolation is not required, a nonstrict-read-write cache might be appropriate. If the cache is used in a JTA environment, you must specify hibernate.transaction.manager_lookup_class. In other environments, you should ensure that the transaction is completed when Session.close() or Session.disconnect() is called.

Strategy: transactional

• It supports only transactional cache providers such as JBoss TreeCache.
• only used in JTA environment.

The transactional cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache may only be used in a JTA environment and you must specify hibernate.transaction.manager_lookup_class.

Posted in Hibernate, hibernate Cache, second level cache ]]> http://lijinjoseji.wordpress.com/2009/06/09/the-second-level-cache-in-hibernate-settings-and-configurations/feed/ 1 Lijin http://lijinjoseji.wordpress.com/2009/06/09/the-second-level-cache-in-hibernate-settings-and-configurations/