
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--

    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<html>
  <head>

<link type="text/css" rel="stylesheet" href="/resources/site.css">
<script src='/resources/space.js'></script>

<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
<meta name="keywords" content="business integration, EAI, SOA, Service Oriented Architecture, web services, SOAP, JBI, JMS, WSDL, XML, EDI, Electronic Data Interchange, standards support, integration standards, application integration, middleware, software, solutions, services, CXF, open source">
<meta name="description" content="Apache CXF, Services Framework - Resources and Articles">




    <title>
Apache CXF -- Resources and Articles
    </title>
  </head>
<body onload="init()">


<table width="100%" cellpadding="0" cellspacing="0">
  <tr>
    <td id="cell-0-0" colspan="2">&nbsp;</td>
    <td id="cell-0-1">&nbsp;</td>
    <td id="cell-0-2" colspan="2">&nbsp;</td>
  </tr>
  <tr>
    <td id="cell-1-0">&nbsp;</td>
    <td id="cell-1-1">&nbsp;</td>
    <td id="cell-1-2">
      <!-- Banner -->
<div class="banner" id="banner"><div><table border="0" cellpadding="0" cellspacing="0" width="100%"><tr><td align="left" colspan="1" nowrap>
<a shape="rect" href="http://cxf.apache.org/" title="Apache CXF"><span style="font-weight: bold; font-size: 170%; color: white">Apache CXF</span></a>
</td><td align="right" colspan="1" nowrap>
<a shape="rect" href="http://www.apache.org/" title="The Apache Software Foundation"><img width="214px" height="88" border="0" alt="ASF Logo" src="https://apache.org/img/asf_logo.png"></a>
</td></tr></table></div></div>
      <!-- Banner -->
      <div id="top-menu">
        <table border="0" cellpadding="1" cellspacing="0" width="100%">
          <tr>
            <td>
              <div align="left">
                <!-- Breadcrumbs -->
<a href="resources-and-articles.html">Resources and Articles</a>
                <!-- Breadcrumbs -->
              </div>
            </td>
            <td>
              <div align="right">
                <!-- Quicklinks -->
<div id="quicklinks"><p><a shape="rect" href="download.html">Download</a> | <a shape="rect" href="http://cxf.apache.org/docs/index.html">Documentation</a></p></div>
                <!-- Quicklinks -->
              </div>
            </td>
          </tr>
        </table>
      </div>
    </td>
    <td id="cell-1-3">&nbsp;</td>
    <td id="cell-1-4">&nbsp;</td>
  </tr>
  <tr>
    <td id="cell-2-0" colspan="2">&nbsp;</td>
    <td id="cell-2-1">
      <table>
        <tr valign="top">
          <td height="100%">
            <div id="wrapper-menu-page-right">
              <div id="wrapper-menu-page-top">
                <div id="wrapper-menu-page-bottom">
                  <div id="menu-page">
                    <!-- NavigationBar -->
<div id="navigation"><h3 id="Navigation-ApacheCXF"><a shape="rect" href="index.html">Apache CXF</a></h3><ul class="alternate"><li><a shape="rect" href="index.html">Home</a></li><li><a shape="rect" href="download.html">Download</a></li><li><a shape="rect" href="people.html">People</a></li><li><a shape="rect" href="project-status.html">Project Status</a></li><li><a shape="rect" href="roadmap.html">Roadmap</a></li><li><a shape="rect" href="mailing-lists.html">Mailing Lists</a></li><li><a shape="rect" class="external-link" href="http://issues.apache.org/jira/browse/CXF">Issue Reporting</a></li><li><a shape="rect" href="special-thanks.html">Special Thanks</a></li><li><a shape="rect" class="external-link" href="http://www.apache.org/licenses/">License</a></li><li><a shape="rect" href="security-advisories.html">Security Advisories</a></li></ul><h3 id="Navigation-Users">Users</h3><ul class="alternate"><li><a shape="rect" href="http://cxf.apache.org/docs/index.html">User's Guide</a></li><li><a shape="rect" href="support.html">Support</a></li><li><a shape="rect" href="faq.html">FAQ</a></li><li><a shape="rect" href="resources-and-articles.html">Resources and Articles</a></li></ul><h3 id="Navigation-Search">Search</h3><form enctype="application/x-www-form-urlencoded" method="get" id="cse-search-box" action="http://www.google.com/cse"><div> <input type="hidden" name="cx" value="002890367768291051730:o99qiwa09y4"> <input type="hidden" name="ie" value="UTF-8"> <input type="text" name="q" size="21"> <input type="submit" name="sa" value="Search"> </div> </form> <script type="text/javascript" src="http://www.google.com/cse/brand?form=cse-search-box&amp;lang=en"></script> <h3 id="Navigation-Developers">Developers</h3><ul class="alternate"><li><a shape="rect" href="http://cxf.apache.org/docs/cxf-architecture.html">Architecture Guide</a></li><li><a shape="rect" href="source-repository.html">Source Repository</a></li><li><a shape="rect" href="building.html">Building</a></li><li><a shape="rect" href="automated-builds.html">Automated Builds</a></li><li><a shape="rect" href="testing-debugging.html">Testing-Debugging</a></li><li><a shape="rect" href="coding-guidelines.html">Coding Guidelines</a></li><li><a shape="rect" href="getting-involved.html">Getting Involved</a></li><li><a shape="rect" href="release-management.html">Release Management</a></li></ul><h3 id="Navigation-Subprojects">Subprojects</h3><ul class="alternate"><li><a shape="rect" href="distributed-osgi.html">Distributed OSGi</a></li><li><a shape="rect" href="xjc-utils.html">XJC Utils</a></li><li><a shape="rect" href="build-utils.html">Build Utils</a></li><li><a shape="rect" href="fediz.html">Fediz</a></li></ul><h3 id="Navigation-ASF"><a shape="rect" class="external-link" href="http://www.apache.org">ASF</a></h3><ul class="alternate"><li><a shape="rect" class="external-link" href="http://www.apache.org/foundation/how-it-works.html">How Apache Works</a></li><li><a shape="rect" class="external-link" href="http://www.apache.org/foundation/">Foundation</a></li><li><a shape="rect" class="external-link" href="http://www.apache.org/foundation/sponsorship.html">Sponsor Apache</a></li><li><a shape="rect" class="external-link" href="http://www.apache.org/foundation/thanks.html">Thanks</a></li><li><a shape="rect" class="external-link" href="http://www.apache.org/security/">Security</a></li></ul><p>&#160;</p><p><a shape="rect" class="external-link" href="http://www.apache.org/events/current-event.html"><span class="confluence-embedded-file-wrapper"><img class="confluence-embedded-image confluence-external-resource" src="http://www.apache.org/events/current-event-125x125.png" data-image-src="http://www.apache.org/events/current-event-125x125.png"></span></a></p></div>
                    <!-- NavigationBar -->
                  </div>
              </div>
            </div>
          </div>
         </td>
         <td height="100%">
           <!-- Content -->
           <div class="wiki-content">
<div id="ConfluenceContent"><p>This page captures resources and articles outside the CXF project which may assist your development. Please add any new resources that you come across by clicking the edit link at the bottom of the page. If you do this, please make sure to attach a date to the article as well so users are aware of how recent it is.</p><h3 id="ResourcesandArticles-ArchivedWebinarsandScreencasts">Archived Webinars and Screencasts</h3><ul><li><a shape="rect" class="external-link" href="http://java.dzone.com/announcements/servicemix-activemq-cxf-and" rel="nofollow">ServiceMix, ActiveMQ, CXF and Camel Training Videos </a> - DZone/JavaLobby Article (February 2009)</li><li><a shape="rect" class="external-link" href="http://fusesource.com/resources/video-archived-webinars/" rel="nofollow">FuseSource Webinars</a> - Upcoming and archived webinars on Apache CXF and other related Apache products.</li><li><a shape="rect" class="external-link" href="http://fusesource.com/resources/fuse-tv/" rel="nofollow">FuseSource TV</a> - FuseSource You Tube Channel with webcasts about Apache CXF and related Apache projects.</li><li><a shape="rect" class="external-link" href="https://www.talend.com/resources/" rel="nofollow">Talend Webinars</a> - Webinars on Talend products and on Apache CXF and other Apache projects (in the Application Integration section).</li><li><a shape="rect" class="external-link" href="http://briefingsdirect.blogspot.com/2008/06/apache-cxf-where-its-been-and-what.html" rel="nofollow">BriefingsDirect interview with Dan Kulp and Benson Marguiles</a> <em>by Dana Gardner</em> (June 2008)</li></ul><h3 id="ResourcesandArticles-Articles">Articles</h3><p>Articles are divided into several sections. As the lists grow, further sectioning refinements may be necessary.</p><h4 id="ResourcesandArticles-GeneralArticles">General Articles</h4><ul><li><a shape="rect" class="external-link" href="http://ashakirin.blogspot.de/2012/09/cxf-performance-on-sun-solaris-platform.html" rel="nofollow">CXF performance benchmarks on SPARC Solaris 11</a> <em>by Andrei Shakirin</em> (September 2012)</li><li><a shape="rect" class="external-link" href="http://ashakirin.blogspot.com/2012/02/scalable-cxf-applications-using-jms.html" rel="nofollow">Scalable CXF applications using JMS transport </a> <em>by Andrei Shakirin</em> (August 2011)</li><li><a shape="rect" class="external-link" href="http://testablejava.blogspot.com/2011/07/testing-cxf-based-soap-webservice.html" rel="nofollow">Testing CXF based SOAP webservice outside a web container</a> <em>by Testable Java</em> (July 2011)</li><li><a shape="rect" class="external-link" href="http://www.liquid-reality.de/x/WoBZ" rel="nofollow">How fast is CXF ? - Measuring CXF performance on http, https and jms</a> <em>by Christian Schneider</em> (June 2011)</li><li><a shape="rect" class="external-link" href="http://nurkiewicz.blogspot.com/2011/05/enabling-load-balancing-and-failover-in.html" rel="nofollow">Enabling load balancing and failover in Apache CXF </a> Tomasz Nurkiewicz's blog (May 2011)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws12.html" rel="nofollow">Java Web services: Introducing CXF</a> <em>by Dennis Sosnoski</em> (February 2010)</li><li><a shape="rect" class="external-link" href="http://aruld.info/sakila-restful-search-using-cxf-fiql/" rel="nofollow">Sakila Restful Search using CXF FIQL </a> <em>by Arul Dhesiaseelan</em></li><li><a shape="rect" class="external-link" href="http://wiki.nanthrax.net/NanthraxWiki/Wiki.jsp?page=Main" rel="nofollow">Programmatically generate a WSDL from a POJO/Interface using CXF</a> <em>Jean-Baptiste Onofr&#233;'s blog</em> (See entry dated 2009-08-04)</li><li><a shape="rect" class="external-link" href="http://logicsector.wordpress.com/2008/10/19/how-to-create-a-wsdl-first-soap-client-in-java-with-cxf-and-maven/" rel="nofollow">How to create a WSDL-first SOAP client in Java with CXF and Maven </a> <em>by Justin Morgan</em> (October 2008)</li><li><a shape="rect" class="external-link" href="http://www.liquid-reality.de/display/liquid/2008/08/20/Defining+Contract+first+webservices+by+generating+wsdl+from+java" rel="nofollow">Defining Contract first webservices by generating wsdl from java</a> <em>Christian Schneider&#180;s Blog</em> (August 2008)</li><li><a shape="rect" class="external-link" href="http://www.liquid-reality.de/display/liquid/2008/08/25/Better+JMS+Transport+for+CXF+Webservice+using+Apache+Camel" rel="nofollow">Better JMS Transport for CXF Webservice using Apache Camel</a> <em>Christian Schneider&#180;s Blog</em> (August 2008)</li><li><a shape="rect" class="external-link" href="http://aruld.info/programming-ssl-for-jetty-based-cxf-services/" rel="nofollow">Programming SSL for Jetty based CXF services</a> <em>by Arul Dhesiaseelan</em> (July 2008)</li><li><a shape="rect" class="external-link" href="http://wiki.netbeans.org/ApacheCXFonNetBeans" rel="nofollow">Developing a loan processing application using Apache CXF and JPA in NetBeans 6.1</a> <em>by Arulazi Dhesiaseelan</em> (April 2008)</li><li><a shape="rect" class="external-link" href="http://www.lumidant.com/blog/web-services-tutorial-with-apache-cxf/" rel="nofollow">Web Services Tutorial with Apache CXF </a> <em>Lumidant Blog</em> (February 2008)</li><li><a shape="rect" class="external-link" href="https://glenmazza.net/blog/entry/blog-index" rel="nofollow">Glen Mazza's Blog - Article Index</a> - Contains many how-to articles for CXF covering JAX-WS basics, security, debugging/testing, and several other web service topics.</li><li><a shape="rect" class="external-link" href="http://techpolesen.blogspot.com/2007/08/jax-ws-dynamic-dispatch-with-cxf.html" rel="nofollow">JAX-WS Dynamic Dispatch with CXF </a> - Per Olesen's blog (August 2007)&#160;</li><li><a shape="rect" class="external-link" href="http://sites.google.com/site/apachecxfnetbeans/loanproc" rel="nofollow">Developing a loan processing application using Apache CXF &amp; JPA in NetBeans 6.8</a> <em>by Arulazi Dhesiaseelan</em></li><li><a shape="rect" class="external-link" href="https://access.redhat.com/documentation/en-US/Fuse_ESB/4.4.1/html/Writing_WSDL_Contracts/files/front.html" rel="nofollow">Writing WSDL Contracts</a> - Fuse ESB guide</li></ul><h4 id="ResourcesandArticles-CXFandJAX-RS">CXF and JAX-RS</h4><ul><li><a shape="rect" class="external-link" href="http://jee-bpel-soa.blogspot.com/2009/04/developing-restful-web-services-using.html" rel="nofollow">Preparing for SCDJWS Part 13: REST, JSON, JAX-RS (and CXF)</a> <em>by &#321;ukasz Gda&#324;sk</em> (April 2009)</li><li><a shape="rect" class="external-link" href="http://dhruba.name/2008/12/08/rest-service-example-using-cxf-22-jax-rs-10-jaxb-and-spring/" rel="nofollow">REST service example using CXF 2.2, JAX-RS 1.0, JAXB and Spring</a> <em>Dhruba Bandopadhyay</em> (December 2008)</li><li><a shape="rect" class="external-link" href="http://www.insaneprogramming.be/?p=140" rel="nofollow">Creating a REST service with CXF and Spring in 10 minutes</a> <em>INSANE PROGRAMMING</em></li><li><a shape="rect" class="external-link" href="http://www.theserverside.com/news/thread.tss?thread_id=58458" rel="nofollow">Java REST Frameworks: Jersey and CXF</a> <em>www.theserverside.com</em></li></ul><h4 id="ResourcesandArticles-CXFandOSGi">CXF and OSGi</h4><ul><li><a shape="rect" class="external-link" href="http://www.liquid-reality.de/x/D4C" rel="nofollow">Karaf Tutorial Part 8 - Distributed OSGi</a></li><li><a shape="rect" class="external-link" href="http://www.liquid-reality.de/x/EoBk" rel="nofollow">Karaf Tutorial Part 4 - CXF Services in OSGi</a></li><li><a shape="rect" class="external-link" href="http://osgi.dzone.com/articles/turning-ordinary-osgi-services" rel="nofollow">Turning Ordinary OSGi Services Into Remote OSGi Services</a> - Mitch Pronschinske's article published on DZone about CXF Distributed OSGi (December 2009)</li><li><a shape="rect" class="external-link" href="http://www.infoq.com/articles/newcomer-distributed-osgi" rel="nofollow">Why Do We Need Distributed OSGi? </a> <em>by Eric Newcomer</em> (February 2009)</li><li><a shape="rect" class="external-link" href="http://coderthoughts.blogspot.com/2009/02/distributed-osgi-simple-example.html" rel="nofollow">Distributed OSGi - A Simple Example</a> - first in a series of Distributed OSGi tutorials on David Bosschaert's blog</li></ul><h4 id="ResourcesandArticles-CXFandSpring">CXF and Spring</h4><ul><li><a shape="rect" class="external-link" href="http://jubyvictor.blogspot.com/2008/09/build-contract-first-web-services-using.html" rel="nofollow">Build contract first web services using CXF+JAXWS+JAXB &amp; Spring </a> <em>Juby Victor's Blog</em> (September 2008)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/webservices/library/ws-pojo-springcxf/index.html?ca=drs-" rel="nofollow">Design and implement POJO Web services using Spring and Apache CXF, Part I</a> <em>by Rajeev Hathi and Naveen Balani</em> (July 2008)</li><li><a shape="rect" class="external-link" href="http://wheelersoftware.com/articles/spring-cxf-consuming-web-services.html" rel="nofollow">Make Web Services Transparent with Spring 2.5 and Apache CXF 2.0</a> <em>by Willie Wheeler</em> (March 2008)</li><li><a shape="rect" class="external-link" href="http://wheelersoftware.com/articles/spring-cxf-web-services.html" rel="nofollow">Web Services with Spring 2.5 and Apache CXF 2.0</a> - <em>by Willie Wheeler</em> (February 2008)</li><li><a shape="rect" class="external-link" href="http://www.khanspot.com/2008/01/01/pox-plain-old-xml-jax-ws-service-using-cxf-and-spring-configuration/" rel="nofollow">POX (Plain Old XML) JAX-WS service using CXF and Spring Configuration </a> - <em>Atif Khan's Blog</em> (January 2008)</li><li><a shape="rect" class="external-link" href="http://naveenbalani.com/index.php/2010/05/cxf-and-spring-tutorial/" rel="nofollow">CXF and Spring tutorial</a> <em>by Naveen Balani</em> (May 2010)</li></ul><h4 id="ResourcesandArticles-CXFandSecurityArticles">CXF and Security Articles</h4><ul><li><a shape="rect" class="external-link" href="http://owulff.blogspot.com/2012/02/saml-tokens-and-ws-trust-security-token.html" rel="nofollow">Clarification on SAML and WS-Trust usage</a> <em>by Oliver Wulff</em> (February 2012)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws19/index.html" rel="nofollow">Java Web services: The state of web service security</a> <em>by Dennis Sosnoski</em> (December 2010)</li><li><a shape="rect" class="external-link" href="http://davidvaleri.wordpress.com/2010/12/16/using-nss-for-fips-140-2-compliant-message-security-in-cxf/" rel="nofollow">Using NSS for FIPS 140-2 compliant message (WS-S) security in CXF</a> <em>by David Valeri</em> (December 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws18/index.html" rel="nofollow">Java Web services: Understanding WS-Policy</a> <em>by Dennis Sosnoski</em> (November 2010)</li><li><a shape="rect" class="external-link" href="http://davidvaleri.wordpress.com/2010/10/19/using-nss-for-fips-140-2-compliant-transport-security-in-cxf/" rel="nofollow">Using NSS for FIPS 140-2 compliant transport security in CXF</a> <em>by David Valeri</em> (October 2010)</li><li><a shape="rect" class="external-link" href="http://davidvaleri.wordpress.com/2010/09/15/signing-ws-addressing-headers-in-apache-cxf/" rel="nofollow">Signing WS-Addressing headers in Apache CXF</a> <em>by David Valeri</em> (September 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws17/index.html" rel="nofollow">Java Web services: WS-Security without client certificates</a> <em>by Dennis Sosnoski</em> (August 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws16/index.html" rel="nofollow">Java Web services: WS-SecureConversation performance</a> <em>by Dennis Sosnoski</em> (June 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws13.html" rel="nofollow">Java Web services: WS-Security with CXF</a> <em>by Dennis Sosnoski</em> (March 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws15/index.html" rel="nofollow">Java Web services: WS-Trust and WS-SecureConversation</a> <em>by Dennis Sosnoski</em> (May 2010)</li><li><a shape="rect" class="external-link" href="http://www.lumidant.com/blog/apache-cxf-tutorial-ws-security-with-spring/" rel="nofollow">Apache CXF Tutorial - WS-Security with Spring </a> Lumidant Blog (February 2008)</li><li><a shape="rect" class="external-link" href="http://coheigea.blogspot.com/" rel="nofollow">Security enhancements for CXF 2.4.x</a> <em>by Colm O hEigeartaigh's</em> blog has a bunch of articles and information about the new WS-Security stuff in CXF 2.4.x and WSS4J 1.6.x.</li><li><a shape="rect" class="external-link" href="http://groovyjava-tom.blogspot.com/2012/01/cxf-and-ms-crm-2011.html" rel="nofollow">CXF and CRM 2011</a> <em>by Tom Schneider</em> (January 2012)</li></ul><h4 id="ResourcesandArticles-StackComparison">Stack Comparison</h4><ul><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws19/index.html" rel="nofollow">Java Web services: The state of web service security</a> <em>by Dennis Sosnoski</em> (December 2010)</li><li><a shape="rect" class="external-link" href="http://wiki.apache.org/ws/StackComparison">WS Wiki, Stack Comparison</a> (January 2010)</li><li><a shape="rect" class="external-link" href="http://www.ibm.com/developerworks/java/library/j-jws14/index.html" rel="nofollow">Java Web services: CXF performance comparison</a> <em>by Dennis Sosnoski</em> (April 2010)</li><li><a shape="rect" class="external-link" href="http://www.predic8.com/axis2-cxf-jax-ws-comparison.htm" rel="nofollow">Apache Axis2, CXF and Sun JAX-WS RI in comparison </a> <em>by Thomas Bayer</em> (October 2010)</li><li><a shape="rect" class="external-link" href="http://naveenbalani.com/index.php/2010/05/evaluating-web-service-frameworks/" rel="nofollow">Evaluating Web service frameworks</a> <em>by Naveen Balani</em> (May 2010)</li><li><a shape="rect" class="external-link" href="http://stackoverflow.com/questions/297033/which-framework-is-better-cxf-or-spring-ws" rel="nofollow">Which framework is better CXF or Spring-WS? </a> <em>stackoverflow</em></li><li><a shape="rect" class="external-link" href="http://stackoverflow.com/questions/1243247/difference-between-apache-cxf-and-axis" rel="nofollow">Difference between Apache CXF and Axis</a> <em>stackoverflow</em></li></ul><h3 id="ResourcesandArticles-Books">Books</h3><ul><li><a shape="rect" class="external-link" href="http://www.itbuzzpress.com/ebooks/advanced-jax-ws-web-services" rel="nofollow">Advanced JAX-WS Web Services</a> by Alessio Soldano (ItBuzzPress.com, September 2014): Apache CXF integration in WildFly</li><li><a shape="rect" class="external-link" href="http://naveenbalani.com/index.php/2010/05/apache-cxf-web-service-book/" rel="nofollow">Apache CXF Web Service Development</a><em> by Naveen Balani and Rajeev Hathi</em> (<a shape="rect" class="external-link" href="http://www.packtpub.com/apache-cxf-web-service-development/book?utm_source=cwiki.apache.org&amp;utm_medium=link&amp;utm_content=pod&amp;utm_campaign=mdb_002233" rel="nofollow">PACKT</a>, December 2009)</li><li><a shape="rect" class="external-link" href="http://agileskills2.org/DWSAA/" rel="nofollow">Developing Web Services with Apache CXF and Axis2 (3rd edition)</a><em> by Kent Ka Iok Tong</em> (Lulu, March 2001) - <a shape="rect" class="external-link" href="http://agileskills2.org/DWSAA/Chapters1-2.pdf" rel="nofollow">first two chapters</a></li></ul><h3 id="ResourcesandArticles-TrainingCourses">Training Courses</h3><ul><li><a shape="rect" class="external-link" href="http://pluralsight.com/training/Courses/TableOfContents/building-jax-ws-web-services-apache-cxf" rel="nofollow">Building JAX-WS Web Services with Apache CXF</a></li></ul><h3 id="ResourcesandArticles-AdditionalResources">Additional Resources</h3><ul><li><a shape="rect" class="external-link" href="http://svn.apache.org/repos/asf/cxf/trunk/etc/survey/SurveySummary.pdf">Apache CXF Survey</a> (August, 2010)</li><li><a shape="rect" class="external-link" href="http://docs.codehaus.org/display/GROOVY/GroovyWS" rel="nofollow">WSGroovy - CXF plugin for Groovy </a> - Guillaume Alleon</li><li><a shape="rect" class="external-link" href="http://wiki.eclipse.org/JAXWS" rel="nofollow">JAX-WS Tools for Eclipse </a> - a project at Eclipse.org that is using CXF as the example runtime for JAX-WS service development, including POJO and WSDL approaches. <a shape="rect" class="external-link" href="http://repo.fusesource.com/videos/service-creation/" rel="nofollow">Some tutorial videos for same </a>.</li><li><a shape="rect" class="external-link" href="http://confluence.highsource.org/display/HJ3/Home" rel="nofollow">Hyperjaxb3</a> - open source project which provides relational persistence for JAXB objects. See <a shape="rect" class="external-link" href="http://confluence.highsource.org/display/HJ3/Apache+CXF+Tutorial+-+Building+JAX-WS%2C+JAXB+and+JPA-based+web+service+with+Apache+CXF%2C+Spring+and+Hyperjaxb3" rel="nofollow">Apache CXF and Hyperjaxb3 tutorial</a>.</li><li><a shape="rect" class="external-link" href="http://fusesource.com/docs/framework" rel="nofollow">FuseSource Commercial Documentation </a> - FuseSource provides documentation for its distribution of CXF.</li><li><a shape="rect" class="external-link" href="http://sxc.codehaus.org" rel="nofollow">SXC</a> - Runtime accelerator for JAXB databinding.</li></ul></div>
           </div>
           <!-- Content -->
         </td>
        </tr>
      </table>
   </td>
   <td id="cell-2-2" colspan="2">&nbsp;</td>
  </tr>
  <tr>
   <td id="cell-3-0">&nbsp;</td>
   <td id="cell-3-1">&nbsp;</td>
   <td id="cell-3-2">
     <div id="footer">
       <!-- Footer -->
       <div id="site-footer">
         <a href="http://cxf.apache.org/privacy-policy.html">Privacy Policy</a> - 
         (<a href="https://cwiki.apache.org/confluence/pages/editpage.action?pageId=65110">edit page</a>) 
	 (<a href="https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=65110&amp;showComments=true&amp;showCommentArea=true#addcomment">add comment</a>)<br>
	Apache CXF, CXF, Apache, the Apache feather logo are trademarks of The Apache Software Foundation.<br>
        All other marks mentioned may be trademarks or registered trademarks of their respective owners.
       </div>
       <!-- Footer -->
     </div>
   </td>
   <td id="cell-3-3">&nbsp;</td>
   <td id="cell-3-4">&nbsp;</td>
  </tr>
  <tr>
    <td id="cell-4-0" colspan="2">&nbsp;</td>
    <td id="cell-4-1">&nbsp;</td>
    <td id="cell-4-2" colspan="2">&nbsp;</td>
  </tr>
</table>

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript">
try {
var pageTracker = _gat._getTracker("UA-4458903-1");
pageTracker._trackPageview();
} catch(err) {}</script>

</body>
</html>

