Passing Set<java.lang.Object> and List<java.lang.Object> in Axis 2.0

[vinoth subramaniam]

Is there [size=18]DIRECT or INDIRECT any way to pass java.util.Set<java.lang.Object> and java.util.List<java.lang.Object> in Axis 2.0 ? I have read that it is possible by converting it into Object[]. But it will affect our entire project.

and i have read that Axis 2.0 will support JAXB 2.0 and in JAXB 2.0 , java.util.List<java.lang.Object> can be mapped as xsd:IDREFS . How it can be implemented in WSDL file?

Kindly someone help me.

I am using jboss-5.0.0.GA and runtime is JDK 1.6.

Thanks in advance [/size]

[Peer Reynders]

vinoth subramaniam wrote:I have read that Axis 2.0 will support JAXB 2.0

That intention has existed for a long time - so I wouldn't hold my breath. The XML object model used by the Axis2 engine is Apache Axiom.

in JAXB 2.0 , java.util.List<java.lang.Object> can be mapped as xsd:IDREFS.

Incorrect. xsd:IDREFS are mapped to java.util.List<java.lang.Object> but not the other way around.

{http://www.w3.org/2001/XMLSchema}IDREF is simply a reference to an XML element that is somewhere else in the XML document. {http://www.w3.org/2001/XMLSchema}IDREFS is simply an enumeration of multiple {http://www.w3.org/2001/XMLSchema}IDREF. The point is that the "thing" they refer to still has to exist somewhere else in the document where most likely the document context defines the "type" of the "thing" with reference to the originating schema.


If I understand your situation correctly you seem to have a distributed system that uses Set<Object> and List<Object> as "generic" Data Transfer Objects.

In XML the equivalent would be an XML document that could have any number of child elements, each containing the root element of a separate "document".

In Axis2 the Set<Object>/List<Object> would be replaced with an org.apache.axiom.om.OMElement as for example in axis2/samples/userguide/src/userguide/example1/MyService.java.

Given that Axis2 gives you org.apache.axis2.util.XMLUtils.toOM(org.w3c.dom.Element) and org.apache.axis2.util.XMLUtils.toDOM(org.apache.axiom.om.OMElement), you have an integration point or seam with JAXB.

Get all your objects that may appear in your Set<Object>/List<Object> together and bind them with JAXB using your preferred method, with one single ObjectFactory

When you need to send a Set<Object>/List<Object>:

create an OMElement to act as the root container (The name of this element could easily imply whether it is a Set or a List).

Iterate through the Objects in the Set<Object>/List<Object>

For each object use JAXB to marshal it as a W3C DOM representation and then retrieve the root org.w3c.dom.Document.Element with org.w3c.dom.Document.getDocumentElement()

Convert the root org.w3c.dom.Document.Element to a org.apache.axiom.om.OMElement with XMLUtils.html.toOM()

Add the resulting org.apache.axiom.om.OMElement to the root container element with org.apache.axiom.om.OMElement.addChild(org.apache.axiom.om.OMNode)

Once all the objects have been added, your Set<Object>/List<Object> as a org.apache.axiom.om.OMElement is ready

When you need to reconstitute a Set<Object>/List<Object>:

Check the name (getQName() or getLocalName()) of the org.apache.axiom.om.OMElement to determine whether you are creating a Set<Object> or List<Object> and create it.

Iterate over the children (getChildren()) of the org.apache.axiom.om.OMElement

Convert each of them with XMLUtils.html.toDOM() to an org.w3c.dom.Document.Element

Use JAXB to unmarshal the org.w3c.dom.Document.Element back to its object form

Add the resulting object to the Set<Object>/List<Object>.

Once you iterated through all the children you should have your Set<Object>/List<Object> back.

[vinoth subramaniam]

Thank you very much for your valuable ideas..

Let me try to explain my context

i need to make webservices for BookSearchWebServices.java.. and it contains

 public class BookSearchWebServices{
	public List<Books> retrieveBooksList(BookParam ParameterBean){
		List<Books> booksList=new Search().retrieveBooksList(ParameterBean);
		return booksList;
	}
}
   

Book.java is (which is having an object of Author.java as one of its attributes)

 public class Books{
	
	.
	.
	.
	.
	private Author author;
	.
	.
	.
	.
	public Author getAuthor() {
		return author;
	}

	public void setAuthor(Author author) {
		this.author = author;
	}

}

   

Author.java is (which is having Set<books> as one of its attributes)

public class Author{
	.
	.
	.
	.	
	.
	Set<Books> books = new HashSet<Books>();
	.
	.
	.
	.
	.
	public Set<Books> getBooks() {
		Books booksObj = new Books();
		booksObj.setAuthor(this);
		return books;
	}

	public void setBooks(Set<Books> books) {
		this.books = books;
	}

}    

How can i pass them ?

[Peer Reynders]

vinoth subramaniam wrote:How can i pass them ?

You've got bigger problems. Not only are you trying to return "A list of books" - you are trying to return an entire object graph and to make things worse, an object graph with cycles. XML is notoriously bad at representing graphs (and the cycles don't help either) because XML is hierarchical in nature - so it is necessary to restructure the information to make it more XML-friendly. In most cases the "listed" object is simply stripped down to its bare essentials so that no object-graph remains.

If it is necessary to retain all the information in the object-graph then a different approach is required. The XML document has to represent all the instances of any type that appears in the entire graph and any relationships are realized through {http://www.w3.org/2001/XMLSchema}IDREF and {http://www.w3.org/2001/XMLSchema}ID types. So in the case of the Book/Author example the document needs three sub-sequences:

a books sequence. This sequence contains all the books in the graph - not just the ones that belong to the List<Book>. Each book can reference multiple authors.

an authors sequence. This sequence contains all the authors in the graph. Each author can reference multiple books.

a list sequence. This sequence simply contains references to the books that are actually in the List<Book>.

The {http://idref.jaxws.coderanch.com/}bookList in the following schema realizes this structure

<?xml version="1.0" encoding="UTF-8"?>
<!-- BookSearch.xsd -->
<xsd:schema 
    elementFormDefault="qualified"
    version="1.0" 
    targetNamespace="http://idref.jaxws.coderanch.com/"
    xmlns:tns="http://idref.jaxws.coderanch.com/"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  >
  <xsd:element name="bookSearchRequest" type="tns:BookSearchRequest"/>
  <xsd:element name="bookList"  type="tns:BookList" />

  <xsd:complexType name="BookSearchRequest">
    <xsd:sequence>
      <xsd:element name="query" type="xsd:string" />
    </xsd:sequence>
  </xsd:complexType>
      
  <xsd:complexType name="AuthorRef">
    <xsd:sequence/>
    <xsd:attribute name="ref" type="xsd:IDREF" use="required"/>
  </xsd:complexType>

  <xsd:complexType name="BookRef">
    <xsd:sequence />
    <xsd:attribute name="ref" type="xsd:IDREF" use="required"/>
  </xsd:complexType>

   <xsd:complexType name="Author">
    <xsd:sequence>
      <xsd:element name="lastName" type="xsd:string"/>
      <xsd:element name="firstName" type="xsd:string" minOccurs="0"/>
      <xsd:element name="bookRefs" nillable="true" minOccurs="0">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="bookRef" type="tns:BookRef" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="id" type="xsd:ID" use="required"/>
  </xsd:complexType>

  <xsd:complexType name="Book">
    <xsd:sequence>
      <xsd:element name="title" type="xsd:string"/>
      <xsd:element name="authorRefs" nillable="true" minOccurs="0">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="authorRef" type="tns:AuthorRef" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
    <xsd:attribute name="isbn13" type="xsd:ID" use="required"/>
  </xsd:complexType>

  <xsd:complexType name="BookList">
    <xsd:sequence>
      <xsd:element name="list" nillable="true" minOccurs="0">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="bookRef" type="tns:BookRef" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="books" nillable="true" minOccurs="0">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="book" type="tns:Book" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
      <xsd:element name="authors" nillable="true" minOccurs="0">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="author" type="tns:Author" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>

</xsd:schema>

The {http://idref.jaxws.coderanch.com/}BookRef uses an {http://www.w3.org/2001/XMLSchema}IDREF to refer to the isbn13 of a {http://idref.jaxws.coderanch.com/}Book. It is used by the list to identify the books in "the list" and by {http://idref.jaxws.coderanch.com/}Author to identify the author's books.

The {http://idref.jaxws.coderanch.com/}AuthorRef uses an {http://www.w3.org/2001/XMLSchema}IDREF to refer to the id of an {http://idref.jaxws.coderanch.com/}Author. It is used by {http://idref.jaxws.coderanch.com/}Book to identify a book's authors.

This schema can now be used in a web service contract

<?xml version="1.0" encoding="UTF-8"?>
<!-- BookSearch.wsdl -->
<definitions
    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
    xmlns:tns="http://idref.jaxws.coderanch.com/" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns="http://schemas.xmlsoap.org/wsdl/"
    targetNamespace="http://idref.jaxws.coderanch.com/" 
    name="BookSearch"
    >

  <types>
    <xsd:schema>
      <xsd:import namespace="http://idref.jaxws.coderanch.com/" schemaLocation="./BookSearch.xsd" />
    </xsd:schema>
  </types>
  
  <message name="search">
    <part name="request" element="tns:bookSearchRequest" />
  </message>
  <message name="searchResponse">
    <part name="response" element="tns:bookList" />
  </message>
  
  <portType name="BookSearch">
    <operation name="search">
      <input message="tns:search" />
      <output message="tns:searchResponse" />
    </operation>
  </portType>
  
  <binding name="BookSearchPortBinding" type="tns:BookSearch">
    <soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document" />
    <operation name="search">
      <soap:operation soapAction="" />
      <input>
        <soap:body use="literal" />
      </input>
      <output>
        <soap:body use="literal" />
      </output>
    </operation>
  </binding>
  
  <service name="BookSearch">
    <port name="BookSearchPort" binding="tns:BookSearchPortBinding">
      <soap:address location="http://localhost:8080/wsdemo/booksearch" />
    </port>
  </service>
  
</definitions>

To keep things simple I'm going to proceed with JDK 6 tools only (i.e. JAX-WS & JAXB - which I believe are supported by JBoss 5).

A JAX-WS binding file

<?xml version="1.0" encoding="UTF-8"?>
<!-- BookSearch.xml -->
<bindings
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    wsdlLocation="./BookSearch.wsdl"
    xmlns="http://java.sun.com/xml/ns/jaxws"
  >
  <package name="com.coderanch.jaxws.idref.ws"/>
  <enableWrapperStyle>true</enableWrapperStyle>
  <enableAsyncMapping>false</enableAsyncMapping>
</bindings>

which maps the Java web service artifacts to the com.coderanch.jaxws.idref.ws package.

A JAXB external binding customization file

<?xml version="1.0" encoding="UTF-8"?>
<!-- BookSearch.xjb -->
<jxb:bindings
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
    version="1.0">
  <jxb:bindings schemaLocation="./BookSearch.xsd" node="/xsd:schema">
    <jxb:globalBindings
         generateElementProperty="false" />
    <!-- 
      generateElementProperty="false" suppresses the wrapping
      JAXBElement when minOccurs="0" and nillable="true"
      occur together.
    -->
         
    <jxb:schemaBindings>
      <jxb:package name="com.coderanch.jaxws.idref.dto"/>
    </jxb:schemaBindings>
        
    <jxb:bindings node="//xsd:complexType[@name='AuthorRef']"> 
      <jxb:class name="AuthorHolder" />
          
      <jxb:bindings node=".//xsd:attribute[@name='ref']">
        <jxb:property name="authorDto" >
          <jxb:baseType name="AuthorDto" />
          <!-- basetype strongly types the IDREF to AuthorDto-->
        </jxb:property>
      </jxb:bindings>
    </jxb:bindings>

    <jxb:bindings node="//xsd:complexType[@name='BookRef']"> 
      <jxb:class name="BookHolder" />
          
      <jxb:bindings node=".//xsd:attribute[@name='ref']">
        <jxb:property name="bookDto" >
          <jxb:baseType name="BookDto" />
          <!-- basetype strongly types the IDREF to BookDto-->
        </jxb:property>
      </jxb:bindings>
    </jxb:bindings>

    <jxb:bindings node="//xsd:complexType[@name='Book']"> 
      <jxb:class name="BookDto" />
      <jxb:bindings node=".//xsd:element[@name='authorRefs']">
        <jxb:property name="authors" />
        <jxb:bindings node="./xsd:complexType">
          <jxb:class name="Authors" />
          <jxb:bindings node=".//xsd:element[@name='authorRef']">
            <jxb:property name="holders" />
          </jxb:bindings>
        </jxb:bindings>
      </jxb:bindings>
    </jxb:bindings>
        
    <jxb:bindings node="//xsd:complexType[@name='Author']"> 
      <jxb:class name="AuthorDto" />
      <jxb:bindings node=".//xsd:element[@name='bookRefs']">
        <jxb:property name="books" />
        <jxb:bindings node="./xsd:complexType">
          <jxb:class name="Books" />
          <jxb:bindings node=".//xsd:element[@name='bookRef']">
            <jxb:property name="holders" />
          </jxb:bindings>
        </jxb:bindings>
      </jxb:bindings>
    </jxb:bindings>
        
    <jxb:bindings node="//xsd:complexType[@name='BookList']">
    
      <jxb:bindings node=".//xsd:element[@name='list']">
        <jxb:bindings node=".//xsd:element[@name='bookRef']">
          <jxb:property name="holders" />
        </jxb:bindings>
      </jxb:bindings>

      <jxb:bindings node=".//xsd:element[@name='books']">
        <jxb:bindings node=".//xsd:element[@name='book']">
          <jxb:property name="bookDtos" />
        </jxb:bindings>
      </jxb:bindings>

      <jxb:bindings node=".//xsd:element[@name='authors']">
        <jxb:bindings node=".//xsd:element[@name='author']">
          <jxb:property name="authorDtos" />
        </jxb:bindings>
      </jxb:bindings>
    </jxb:bindings>

  </jxb:bindings>
  
</jxb:bindings>

which maps the JAXB artifacts to the com.coderanch.jaxws.idref.dto package. The main reason for using the customization is to force strong typing on the IDREF links and to suppress the use of JAXBElement wrappers. Of course many of the names for the Java classes are customized as well.
wsimport BookSearch.wsdl -b BookSearch.xml -b BookSearch.xjb -s src
is then used to generate the Java artifacts:

com.coderanch.jaxws.idref.ws.BookSearch - the endpoint interface

com.coderanch.jaxws.idref.ws.BookSearch_Service - the web service client proxy

com.coderanch.jaxws.idref.dto.AuthorDto class to represent {http://idref.jaxws.coderanch.com/}Author.

com.coderanch.jaxws.idref.dto.AuthorHolder class to represent {http://idref.jaxws.coderanch.com/}AuthorRef.

com.coderanch.jaxws.idref.dto.BookDto class to represent {http://idref.jaxws.coderanch.com/}Book.

com.coderanch.jaxws.idref.dto.BookHolder class to represent {http://idref.jaxws.coderanch.com/}BookRef.

com.coderanch.jaxws.idref.dto.BookList class to represent {http://idref.jaxws.coderanch.com/}BookList.

com.coderanch.jaxws.idref.dto.BookSearchRequest class to represent {http://idref.jaxws.coderanch.com/}BookSearchRequest.

com.coderanch.jaxws.idref.dto.ObjectFactory - the JAXB ObjectFactory.

package-info.java containing the JAXB package level annotations.

At this point the building blocks for the web service are in place. Of course some domain objects are necessary. The Book, Author, and the Repository class that returns them.

package com.coderanch.jaxws.idref.domain;
// Book.java
import java.util.Set;

public class Book {
  
    private String      isbn13;
    private String      title;
    private Set<Author> authors;

    public Book(
        String isbn13,
        String title
    ){
        this.isbn13  = isbn13;
        this.title   = title;
    }

    public String getIsbn13(){
        return isbn13;
    }
    public String getTitle(){
        return title;
    }
    public void setAuthors(Set<Author> set){
        authors = set ;
    }
    public Set<Author> getAuthors(){
        return authors;
    }
    
    public boolean equals(Object obj){
        if(this == null) return false;

        if(this == obj)  return true;
          
        if( obj.getClass() != this.getClass() ) return false;
          
        return this.isbn13.equals(((Book)obj).isbn13);
	  }

    public int hashCode(){ return this.isbn13.hashCode(); }
}

package com.coderanch.jaxws.idref.domain;
// Author.java
import java.util.Set;

public class Author {
  
    private String    id;
    private String    lastName;
    private String    firstName;
    private Set<Book> books;

    public Author(
        String id,
        String lastName,
        String firstName
    ){
        this.id        = id;
        this.lastName  = lastName;
        this.firstName = firstName;
    }

    public String getId(){
        return id;
    }
    public String getLastName(){
        return lastName;
    }
    public String getFirstName(){
        return firstName;
    }

    public void setBooks(Set<Book> set){
        books = set ;
    }
    public Set<Book> getBooks(){
        return books;
    }
    
    public boolean equals(Object obj){
        if(this == null) return false;

        if(this == obj)  return true;
          
        if( obj.getClass() != this.getClass() ) return false;
          
        return this.id.equals(((Author)obj).id);
	  }

    public int hashCode(){ return this.id.hashCode(); }
}

package com.coderanch.jaxws.idref.domain;
// Repository.java
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;

public class Repository {
  
    public List<Book> find(String query) {
      if (! query.equals( "essential resource service orientation" ) ) 
          return new ArrayList<Book>();
      
      return makeResultList();
    }

    private List<Book> makeResultList() {
        
        Author      author,author2;
        Book        book;
        Set<Author> authorSet;
        Set<Book>   bookSet;
      
        // Erl's Books
        authorSet = new HashSet<Author>();
        author    = addNewAuthor(authorSet,"s1","Erl", "Thomas" );

        bookSet = new HashSet<Book>();
        Book serviceDesign = 
            addNewBook( bookSet, authorSet, "9780132344821", "SOA Principles of Service Design" );
        addNewBook( bookSet, authorSet, "9780136135166", "SOA Design Patterns" );
        addNewBook( bookSet, authorSet, "9780136135173", "Web Service Contract Design and Versioning for SOA" );
        addNewBook( bookSet, authorSet, "9780131858589", "Service-Oriented Architecture (SOA): Concepts, Technology, and Design" );
        addNewBook( bookSet, authorSet, "9780131428980", "Service-Oriented Architecture: A Field Guide to Integrating XML and Web Services" );

        author.setBooks(bookSet);
      
      
        // Author/Book: SOA in Practice
        authorSet = new HashSet<Author>();
        author    = addNewAuthor(authorSet,"s2","Josuttis", "Nicolai" );
        
        bookSet = new HashSet<Book>();
        Book soaInPractice = 
            addNewBook( bookSet, authorSet, "9780596529550", "SOA in Practice: The Art of Distributed System Design" );
        
        author.setBooks(bookSet);


        // Authors/Book: RESTful Web Services
        authorSet = new HashSet<Author>();
        author    = addNewAuthor(authorSet, "r1","Richardson", "Leonard" );
        author2   = addNewAuthor(authorSet, "r2","Ruby", "Sam" );

        bookSet = new HashSet<Book>();
        Book restfulWebServices = 
            addNewBook( bookSet, authorSet, "9780596529260", "RESTful Web Services" );
        
        author.setBooks(bookSet);
        author2.setBooks(bookSet);

        // Assemble the actual result set
        List<Book>  results   = new ArrayList<Book>();
        results.add(restfulWebServices);
        results.add(soaInPractice);
        results.add(serviceDesign);
        
        return results;
    }
    
    private Author addNewAuthor(
        Set<Author> authorSet, 
        String      id, 
        String      lastName, 
        String      firstName
    ){
        Author author = new Author( id, lastName, firstName );
        authorSet.add(author);
        return author;
    }

    private Book addNewBook(
        Set<Book>   bookSet, 
        Set<Author> authorSet, 
        String      isbn, 
        String      title
    ){
        Book book = new Book( isbn, title );
        book.setAuthors(authorSet);
        bookSet.add(book);
        return book;
    }
}

As you may notice the Repository returns a List<Book> while the generated service endpoint interface returns a com.coderanch.jaxws.idref.dto.BookList, so for the conversion we need an adapter:

package com.coderanch.jaxws.idref.util;
// BookListAdapter.java
import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;

import com.coderanch.jaxws.idref.dto.AuthorDto;
import com.coderanch.jaxws.idref.dto.AuthorHolder;
import com.coderanch.jaxws.idref.dto.BookList;
import com.coderanch.jaxws.idref.dto.BookDto;
import com.coderanch.jaxws.idref.dto.BookHolder;
import com.coderanch.jaxws.idref.dto.ObjectFactory;

import com.coderanch.jaxws.idref.domain.Book;
import com.coderanch.jaxws.idref.domain.Author;


public class BookListAdapter extends XmlAdapter<BookList,List><Book>> {
  
    private ObjectFactory factory = new ObjectFactory();
  
    
    public BookList marshal( List<Book> list ){

        BookList bookList = factory.createBookList();
        if( list == null || list.isEmpty())
            return bookList;

        Map<String,BookHolder>   bookMap   = 
            new HashMap<String,BookHolder>();
        Map<String,AuthorHolder> authorMap = 
            new HashMap<String,AuthorHolder>();
        
        initBookList(bookList);
        List<BookHolder>  newList = bookList.getList().getHolders();
        for (Book book : list ) {
            newList.add(
                processBook( book, bookMap, authorMap )
            );
        }
        addAuthors( bookList, authorMap.values() );
        addBooks(   bookList, bookMap.values() );
        
        return bookList;
    }
    
    public List<Book> unmarshal( BookList bookList ){
        int capacity = 0;
        
        if( bookList != null 
                && bookList.getList() != null 
                && bookList.getList().getHolders().size() > 0) {
            capacity = bookList.getList().getHolders().size();
        }
      
        List<Book> list = new ArrayList<Book>(capacity);
        if ( capacity == 0) 
          return list; // nothing to do

        Map<String,Book>   bookMap   = 
            new HashMap<String,Book>( bookList.getBooks().getBookDtos().size() );
        Map<String,Author> authorMap = 
            new HashMap<String,Author>( bookList.getAuthors().getAuthorDtos().size() );
        
        // Convert all the BookDto/AuthorDto objects to Book/Author objects
        for( BookDto dto : bookList.getBooks().getBookDtos() ) {
            processBookDto( dto, bookMap, authorMap );
        }
        
        // collect the books that are directly in the "the List"
        addBooks( list, bookList.getList().getHolders(), bookMap);
          
        return list;
    }
    
    /* 
        marshal support methods 
     */
    
    private void initBookList( BookList bookList ){
       bookList.setList(    factory.createBookListList()    );
       bookList.setAuthors( factory.createBookListAuthors() );
       bookList.setBooks(   factory.createBookListBooks()   );
    }

    private void addAuthors(BookList bookList, Collection<AuthorHolder> holders){
       ArrayList<AuthorDto> dtos = (ArrayList<AuthorDto>)bookList.getAuthors().getAuthorDtos();
      
       dtos.ensureCapacity( holders.size() );
       for(AuthorHolder holder: holders)
          dtos.add( holder.getAuthorDto() );
    }

    private void addBooks(BookList bookList, Collection<BookHolder> holders){
       ArrayList<BookDto> dtos = (ArrayList<BookDto>)bookList.getBooks().getBookDtos();
      
       dtos.ensureCapacity( holders.size() );
       for(BookHolder holder: holders)
          dtos.add( holder.getBookDto() );
    }

    private BookHolder processBook(
        Book                     book,
        Map<String,BookHolder>   bookMap,
        Map<String,AuthorHolder> authorMap
    ){
        BookHolder bookHolder = bookMap.get( book.getIsbn13() );
        if( bookHolder != null ) 
            return bookHolder; // already processed
        
        bookHolder = makeBookDto( book );
        bookMap.put( book.getIsbn13(), bookHolder );

        /*  Compile the list of Book's Authors,
            processing them at the same time
         */
        List<AuthorHolder> bookAuthors = 
            bookHolder.getBookDto().getAuthors().getHolders();
        for (Author author : book.getAuthors() ) {
            bookAuthors.add(
                processAuthor( author, bookMap, authorMap )
            );
        }
        
        return bookHolder;
    }
    
    private AuthorHolder processAuthor(
        Author                   author,
        Map<String,BookHolder>   bookMap,
        Map<String,AuthorHolder> authorMap
    ){
        AuthorHolder authorHolder = authorMap.get( author.getId() );
        if( authorHolder != null ) 
            return authorHolder; // already processed
        
        authorHolder = makeAuthorDto( author );
        authorMap.put( author.getId(), authorHolder );
        
        /*  Compile the list of Author's Books, 
            processing them at the same time 
         */
        List<BookHolder> authorBooks = 
            authorHolder.getAuthorDto().getBooks().getHolders();
        for (Book book : author.getBooks() ) {
            authorBooks.add(
                processBook( book, bookMap, authorMap )
            );
        }

        return authorHolder;
    }

    private BookHolder makeBookDto(Book book) {

        // Create the actual BookDto
        BookDto dto = factory.createBookDto();
        dto.setIsbn13(book.getIsbn13());
        dto.setTitle(book.getTitle());
      
        //Initialize the Book's Authors
        dto.setAuthors(factory.createBookDtoAuthors());
        ArrayList<AuthorHolder> holders = 
            (ArrayList<AuthorHolder>)(dto.getAuthors().getHolders());
        holders.ensureCapacity( book.getAuthors().size() );

        // Place the BookDto in a holder
        BookHolder holder = factory.createBookHolder();
        holder.setBookDto( dto );

        return holder;
    }

    private AuthorHolder makeAuthorDto(Author author) {
        // Create actual AuthorDto
        AuthorDto dto = factory.createAuthorDto();
        dto.setId(author.getId());
        dto.setLastName(author.getLastName());
        dto.setFirstName(author.getFirstName());
      
        //Initialize Author's Books
        dto.setBooks(factory.createAuthorDtoBooks());
        ArrayList<BookHolder> holders = 
            (ArrayList<BookHolder>)(dto.getBooks().getHolders());
        holders.ensureCapacity( author.getBooks().size() );
      
        // Place the AuthorDto in a holder
        AuthorHolder holder = factory.createAuthorHolder();
        holder.setAuthorDto( dto );

        return holder;
    }

    /* 
        unmarshal support methods 
     */
    
    private void addBooks(
        List<Book>         list,
        List<BookHolder>   bookHolders,
        Map<String,Book>   bookMap
    ){
        for(BookHolder holder : bookHolders) { 
            Book book = bookMap.get( holder.getBookDto().getIsbn13() );
            if(book != null) 
                list.add( book );
        }
    }
    
    private Author processAuthorDto(
        AuthorDto          dto,
        Map<String,Book>   bookMap,
        Map<String,Author> authorMap
    ){
        Author author = authorMap.get( dto.getId() );
        if( author != null ) 
            return author; // already processed
        
        author = makeAuthor( dto );
        authorMap.put( author.getId(), author );

        /*  Compile the list of Book's Authors,
            processing them at the same time
         */
        Set<Book> authorBooks = author.getBooks();
        for (BookHolder holder : dto.getBooks().getHolders() ) {
            authorBooks.add(
                processBookDto( holder.getBookDto(), bookMap, authorMap )
            );
        }

        return author;
    }

    private Book processBookDto(
        BookDto            dto,
        Map<String,Book>   bookMap,
        Map<String,Author> authorMap
    ){
        Book book = bookMap.get( dto.getIsbn13() );
        if( book != null ) 
            return book; // already processed
        
        book = makeBook( dto );
        bookMap.put( book.getIsbn13(), book );

        /*  Compile the list of Book's Authors,
            processing them at the same time
         */
        Set<Author> bookAuthors = book.getAuthors();
        for (AuthorHolder holder : dto.getAuthors().getHolders() ) {
            bookAuthors.add(
                processAuthorDto( holder.getAuthorDto(), bookMap, authorMap )
            );
        }

        return book;
    }
    
    private Author makeAuthor(AuthorDto dto) {

        // Create the author
        Author author = new Author( 
            dto.getId(), 
            dto.getLastName() ,
            dto.getFirstName()
        );
      
        //Initialize the Book's Authors
        author.setBooks(new HashSet<Book>( dto.getBooks().getHolders().size() ));

        return author;
    }

    private Book makeBook(BookDto dto) {

        // Create the book
        Book book = new Book( dto.getIsbn13(), dto.getTitle() );
      
        //Initialize the Book's Authors
        book.setAuthors(new HashSet<Author>( dto.getAuthors().getHolders().size() ));

        return book;
    }

} // end class BookListAdapter

Finally we can put together the web service implementation.

package com.coderanch.jaxws.idref.provider;
// BookSearchImpl.java
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;
import javax.xml.bind.annotation.XmlSeeAlso;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.util.List;

import com.coderanch.jaxws.idref.domain.Repository;
import com.coderanch.jaxws.idref.domain.Book;
import com.coderanch.jaxws.idref.dto.BookList;
import com.coderanch.jaxws.idref.dto.BookSearchRequest;
import com.coderanch.jaxws.idref.dto.ObjectFactory;
import com.coderanch.jaxws.idref.util.BookListAdapter;

/*
   "Implementing" com.coderanch.jaxws.idref.ws.BookSearch
 */
 
@WebService(name = "BookSearch", targetNamespace = "http://idref.jaxws.coderanch.com/")
@SOAPBinding(parameterStyle = SOAPBinding.ParameterStyle.BARE)
@XmlSeeAlso({
    ObjectFactory.class
})
public class BookSearchImpl {
  
    @WebMethod
    @WebResult(name = "bookList", targetNamespace = "http://idref.jaxws.coderanch.com/", partName = "response")
    public BookList search(
        @WebParam(name = "bookSearchRequest", targetNamespace = "http://idref.jaxws.coderanch.com/", partName = "request")
        BookSearchRequest request 
    ) {
        BookListAdapter adapter = new BookListAdapter();

        Repository repos = new Repository();
        List<Book> list  = repos.find( request.getQuery() );
      
        return adapter.marshal( list );
    } // end method search
} // end class BookSearchImpl

And the code to host the endpoint

package com.coderanch.jaxws.idref.provider;

import javax.xml.ws.Endpoint;
import javax.xml.namespace.QName;
import java.util.Map;

class Main {
    public static void main(String[] args) {
      
        Endpoint endpoint = Endpoint.create( new BookSearchImpl() );
      
        Map<String,Object> properties = endpoint.getProperties();    
        properties.put(
          Endpoint.WSDL_SERVICE,
          new QName("http://idref.jaxws.coderanch.com/", "BookSearch" ) 
        ); 
        properties.put(
          Endpoint.WSDL_PORT,
          new QName("http://idref.jaxws.coderanch.com/", "BookSearchPort" ) 
        ); 
        endpoint.setProperties(properties);

        endpoint.publish( "http://localhost:8080/wsdemo/booksearch" );
    }
}

To compile everything:
javac -d . src\com\coderanch\jaxws\idref\domain\*.java
javac -d . src\com\coderanch\jaxws\idref\util\BookListAdapter.java
javac -d . src\com\coderanch\jaxws\idref\provider\*.java
wsgen -cp . com.coderanch.jaxws.idref.provider.BookSearchImpl

Start the web service with:
java com.coderanch.jaxws.idref.provider.Main

If you point a browser to http://localhost:8080/wsdemo/booksearch?wsdl you should see the JAX-WS generated WSDL.

Open a separate console window to work on the web service consumer.

package com.coderanch.jaxws.idref.consumer;
// BookSearchClient.java
import com.coderanch.jaxws.idref.ws.BookSearch_Service;
import com.coderanch.jaxws.idref.ws.BookSearch;
import com.coderanch.jaxws.idref.dto.ObjectFactory;
import com.coderanch.jaxws.idref.dto.BookSearchRequest;
import com.coderanch.jaxws.idref.dto.BookList;

import com.coderanch.jaxws.idref.util.BookListAdapter;
import com.coderanch.jaxws.idref.domain.Author;
import com.coderanch.jaxws.idref.domain.Book;

import java.net.MalformedURLException;
import java.net.URL;
import javax.xml.namespace.QName;
import java.util.List;


class BookSearchClient {
  
    private static URL   wsdlLocation;
    private static QName serviceName;

    static {
        serviceName = new QName("http://idref.jaxws.coderanch.com/", "BookSearch");
        URL url     = null;
        try {
            url = new URL("http://localhost:8080/wsdemo/booksearch?wsdl");
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        wsdlLocation = url;
    }

  
    public static void main(String[] args) {
      
        ObjectFactory factory = new ObjectFactory();
        BookSearchRequest request = factory.createBookSearchRequest();
        request.setQuery("essential resource service orientation");
      
        BookSearch_Service locator = new BookSearch_Service(wsdlLocation,serviceName);
        BookSearch         port    = locator.getBookSearchPort();
      
        BookList bookList = port.search(request);
        List<Book> list = null;
      
        if( bookList.getList() != null ) {
            BookListAdapter adapter = new BookListAdapter();
            list = adapter.unmarshal( bookList );
        }
        
        showBooks( list );
    }
  
    private static void showBooks(List<Book> list) {
        if (list == null || list.size() < 1) {
            System.out.println( "--- Empty" );
            return;
        }
        
        for(Book book : list) {
            System.out.println( book.getIsbn13() );
            for(Author author : book.getAuthors() ) {
                System.out.println( "    " 
                    + author.getFirstName() + " " 
                    + author.getLastName() );
                for( Book authorBook : author.getBooks() ){
                    System.out.println( "        " + authorBook.getIsbn13() );
                    System.out.println( "        " + authorBook.getTitle() );
                } // end for all books from the author
            } // end for all authors of the book
        } // end for all books in the list
        
    } // end showBooks
    
} // end class BookSearchClient

And compile it with
javac -d . src\com\coderanch\jaxws\idref\consumer\BookSearchClient.java
and run it with
java com.coderanch.jaxws.idref.consumer.BookSearchClient
The SOAP request for the {http://idref.jaxws.coderanch.com/}bookList would look like this:

POST /wsdemo/booksearch HTTP/1.1
SOAPAction: ""
Accept: text/xml, multipart/related, text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-Type: text/xml; charset=utf-8
User-Agent: Java/1.6.0_11
Host: localhost:8080
Connection: keep-alive
Content-Length: 250

<?xml version="1.0" ?>
  <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
    <S:Body>
      <bookSearchRequest xmlns="http://idref.jaxws.coderanch.com/">
        <query>essential resource service orientation</query>
      </bookSearchRequest>
    </S:Body>
</S:Envelope>

Notice how there is no "search" method in the request. That is a characteristic of the document/literal messaging mode. An operation can only receive one parameter, the "input document". The type of the "input document" determines which method is executed. In this case the payload is of the {http://idref.jaxws.coderanch.com/}BookSearchRequest type, so the payload is processed by the "search" WebMethod.

The response carries all the result information. The "list" holds the references to the books that are part of the result set; "books" holds all the books that are in the object graph, each book having one or more author references; "authors" holds all the authors that are in the object graph, each author having one or more book references.

HTTP/1.1 200 OK
Transfer-encoding: chunked
Content-type: text/xml; charset=utf-8

<?xml version="1.0" ?>
<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
  <S:Body>
    <bookList xmlns="http://idref.jaxws.coderanch.com/">
      <list>
        <bookRef ref="9780596529260"/>
        <bookRef ref="9780596529550"/>
        <bookRef ref="9780132344821"/>
      </list>
      <books>
        <book isbn13="9780596529550">
          <title>SOA in Practice: The Art of Distributed System Design</title>
          <authorRefs>
            <authorRef ref="s2"/>
          </authorRefs>
        </book>
        <book isbn13="9780132344821">
          <title>SOA Principles of Service Design</title>
          <authorRefs>
            <authorRef ref="s1"/>
          </authorRefs>
        </book>
        <book isbn13="9780136135173">
          <title>Web Service Contract Design and Versioning for SOA</title>
          <authorRefs>
            <authorRef ref="s1"/>
          </authorRefs>
        </book>
        <book isbn13="9780131428980">
          <title>Service-Oriented Architecture: A Field Guide to Integrating XML and Web Services</title>
          <authorRefs>
            <authorRef ref="s1"/>
          </authorRefs>
        </book>
        <book isbn13="9780136135166">
          <title>SOA Design Patterns</title>
          <authorRefs>
            <authorRef ref="s1"/>
          </authorRefs>
        </book>
        <book isbn13="9780131858589">
          <title>Service-Oriented Architecture (SOA): Concepts, Technology, and Design</title>
          <authorRefs>
            <authorRef ref="s1"/>
          </authorRefs>
        </book>
        <book isbn13="9780596529260">
          <title>RESTful Web Services</title>
          <authorRefs>
            <authorRef ref="r1"/>
            <authorRef ref="r2"/>
          </authorRefs>
        </book>
      </books>
      <authors>
        <author id="s2">
          <lastName>Josuttis</lastName>
          <firstName>Nicolai</firstName>
          <bookRefs>
            <bookRef ref="9780596529550"/>
          </bookRefs>
        </author>
        <author id="s1">
          <lastName>Erl</lastName>
          <firstName>Thomas</firstName>
          <bookRefs>
            <bookRef ref="9780132344821"/>
            <bookRef ref="9780136135173"/>
            <bookRef ref="9780131428980"/>
            <bookRef ref="9780131858589"/>
            <bookRef ref="9780136135166"/>
          </bookRefs>
        </author>
        <author id="r1">
          <lastName>Richardson</lastName>
          <firstName>Leonard</firstName>
          <bookRefs>
            <bookRef ref="9780596529260"/>
          </bookRefs>
        </author>
        <author id="r2">
          <lastName>Ruby</lastName>
          <firstName>Sam</firstName>
          <bookRefs>
            <bookRef ref="9780596529260"/>
          </bookRefs>
        </author>
      </authors>
    </bookList>
  </S:Body>
</S:Envelope>

(linebreaks and whitespace added, chunking lengths removed for readability)

An example of an empty {http://idref.jaxws.coderanch.com/}bookList:

HTTP/1.1 200 OK
Transfer-encoding: chunked
Content-type: text/xml; charset=utf-8

<?xml version="1.0" ?>
  <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
    <S:Body>
      <bookList xmlns="http://idref.jaxws.coderanch.com/">
        <list xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>
        <books xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>
        <authors xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>
      </bookList>
    </S:Body>
</S:Envelope>

The "list", "books", and "authors" elements are simply "nil" elements.

So all this is basically an example of how a List<Book> is converted to a BookList on the provider side and then reconstituted to a List<Book> on the consumer side.

[Balaji Loganathan]

Cool answer.
Very nice of Peer.