[CONF] Apache CXF Documentation > Writing a service with Spring

confluence Tue, 29 Nov 2011 10:32:24 -0800

     Writing a service with Spring
    Page edited by             Glen Mazza
    
        
        Comment:
        updated page per updates made to underlying java-first sample.

    
        

                         Changes (9)
                                 
    

                    
    
            ...

            * Set up the HTTP transport 
 

            This example corresponds to the spring_http java_first_spring_support example in the CXF distribution. 

             
h1. Setting up your build 

            ...

            h1. Writing your Service 
First we'll write our service interface. It will have one operation called "sayHello" which says "Hello" to whoever submits their name. 

            {snippet:id=service|lang=java|url="" class="diff-added-chars"style="background-color: #dfd;">main/java/demo/spring/service/HelloWorld.java?revision=HEAD} 

             
Our implementation will then look like this: 

            {snippet:id=service|lang=java|url="" class="diff-added-chars"style="background-color: #dfd;">main/java/demo/spring/service/HelloWorldImpl.java?revision=HEAD} 

             
The {{@WebService}} annotation on the implementation class lets CXF know which interface to use when creating WSDL. In this case its simply our HelloWorld interface. 

            ...

            CXF contains support for "nice XML" within Spring 2.0. For the JAX-WS side of things, we have a <jaxws:endpoint> bean which sets up a server side endpoint. 
 

            Lets create a "beans.xml" "cxf-servlet.xml" file in our WEB-INF directory which declares an endpoint bean: 

            {snippet:id=beans|lang=java|url=""> {snippet:id=beans|lang=java|url=""> 

             
If you want to reference a spring managed-bean, you can write like this: 

            ...

             
h1. Setting up the Servlet 

            We'll need to add two things to our web.xml file: 
# the Spring {{ContextLoaderLister}}. This starts Spring and loads our beans.xml file. We can specify where our file is via a {{context-param}} element. 
# the CXF Servlet 
{snippet:id=webxml|lang=java|url="" 

            Since we're relying on the default "cxf-servlet.xml" file the [default web.xml|http://svn.apache.org/viewvc/cxf/trunk/distribution/src/main/release/etc/web.xml?revision=HEAD] referenced by many samples can be used. 

             

            Alternatively, for arbitrarily named configuration files such as beans.xml, application-context.xml, etc. we can add the following elements: 
# the Spring {{ContextLoaderLister}}. This starts Spring and explicitly loads the configuration file. We can specify where our file is via a {{context-param}} element. 
 
An example: 
{code:java} 
<web-app ...> 
... 
   <context-param> 
      <param-name>contextConfigLocation</param-name> 
      <param-value>WEB-INF/beans.xml</param-value> 
   </context-param> 
 
   <listener> 
      <listener-class> 
         org.springframework.web.context.ContextLoaderListener 
      </listener-class> 
   </listener> 
</web-app> 
{code} 
 

            It is important to note that the address that you chose for your endpoint bean must be one your servlet listens on. For instance, if my Servlet was register for "/some-services/*" but my address was "/more-services/HelloWorld", there is no way CXF could receive a request.  
 

            ...

            {code:java} 
ApplicationContext context = ...; // your Spring ApplicationContext 

            HelloWorld client = (HelloWorld) context.getBean("client"); 

            {code} 
 

            ...

    
            
    
                            Full Content
                    
        This example will lead you through creating your first service with Spring. You'll learn how to:

	Set up your build for CXF
	Writing a simple JAX-WS service
	Set up the HTTP transport



This example corresponds to the java_first_spring_support example in the CXF distribution. 

Setting up your build
Open up your favorite IDE and create a new project. The first thing we need to do is add the necessary CXF dependencies to the project. You can find these dependencies in the CXF distribution in the lib directory.


commons-logging-1.1.1.jar
geronimo-activation_1.1_spec-1.0-M1.jar (or Sun's Activation jar)
geronimo-annotation_1.0_spec-1.1.jar (JSR 250)
geronimo-javamail_1.4_spec-1.7.1.jar (or Sun's JavaMail jar)
geronimo-servlet_3.0_spec-1.0.jar (or Sun's Servlet jar)
geronimo-ws-metadata_2.0_spec-1.1.1.jar (JSR 181)
jaxb-api-2.1.jar
jaxb-impl-2.1.13.jar
jaxws-api-2.1.jar
neethi-3.0.0.jar
saaj-api-1.3.jar
saaj-impl-1.3.jar
stax-api-1.0.1.jar
stax2-api-3.1.1.jar
wsdl4j-1.6.2.jar
woodstox-core-asl-4.0.8.jar
xmlschema-core-2.0.jar
xml-resolver-1.2.jar


The Spring jars:

aopalliance-1.0.jar
spring-core-3.0.5.RELEASE.jar
spring-beans-3.0.5.RELEASE.jar
spring-context-3.0.5.RELEASE.jar
spring-web-3.0.5.RELEASE.jar



And the CXF jar:

cxf-2.4.0.jar



Writing your Service
First we'll write our service interface. It will have one operation called "sayHello" which says "Hello" to whoever submits their name.

package demo.spring.service;

import javax.jws.WebService;

@WebService
public interface HelloWorld {
    String sayHi(String text);
}



Our implementation will then look like this:

package demo.spring.service;

import javax.jws.WebService;

@WebService(endpointInterface = "demo.spring.service.HelloWorld")
public class HelloWorldImpl implements HelloWorld {

    public String sayHi(String text) {
        System.out.println("sayHi called");
        return "Hello " + text;
    }
}



The @WebService annotation on the implementation class lets CXF know which interface to use when creating WSDL. In this case its simply our HelloWorld interface.

Declaring your server beans
CXF contains support for "nice XML" within Spring 2.0. For the JAX-WS side of things, we have a <jaxws:endpoint> bean which sets up a server side endpoint.

Lets create a "cxf-servlet.xml" file in our WEB-INF directory which declares an endpoint bean:

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:jaxws="http://cxf.apache.org/jaxws"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

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

	<jaxws:endpoint 
	  id="helloWorld" 
	  implementor="demo.spring.service.HelloWorldImpl" 
	  address="/HelloWorld" />
	  
</beans>



If you want to reference a spring managed-bean, you can write like this:


<bean id="hello" class="demo.spring.HelloWorldImpl" />

<jaxws:endpoint id="helloWorld" implementor="#hello" address="/HelloWorld" />


The bean uses the following properties:

	id specifies the id of the bean in the Spring context.
	implementor specifies the implementation class.
	address specifies the location the service will be hosted. This should just be a related path. This is because CXF can't know the war name and the servlet container's listening port, CXF will update the endpoint address with the request url at the runtime.



To provide a bean name instead of a classname as an implementor, simply supply the bean-name prepended with "#", e.g. implementor="#myBean".

You can also do more sophisticated things with the <jaxws:endpoint> element like add nested tags to attach JAX-WS Handlers or CXF Interceptors to the service.  For more on this see JAX-WS Configuration.

Setting up the Servlet
Since we're relying on the default "cxf-servlet.xml" file the default web.xml referenced by many samples can be used.

Alternatively, for arbitrarily named configuration files such as beans.xml, application-context.xml, etc. we can add the following elements:

	the Spring ContextLoaderLister. This starts Spring and explicitly loads the configuration file. We can specify where our file is via a context-param element.



An example:

<web-app ...>
...
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>WEB-INF/beans.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
</web-app>



It is important to note that the address that you chose for your endpoint bean must be one your servlet listens on. For instance, if my Servlet was register for "/some-services/*" but my address was "/more-services/HelloWorld", there is no way CXF could receive a request. 

Create a Client (Easy Way)
Just like the <jaxws:endpoint> used on the server side, there is a <jaxws:client> that can be used on the client side.  You'll give it a bean name, the service interface, and the service URL, and it will create a bean with the specified name, implementing the service interface, and invoking the remote SOAP service under the covers:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

    <jaxws:client id="helloClient"
                  serviceClass="demo.spring.HelloWorld"
                  address="http://localhost:9002/HelloWorld" />
</beans>


You can now inject that "helloClient" bean into any other Spring bean, or look it up from the Spring application context manually with code like this:


ApplicationContext context = ...; // your Spring ApplicationContext
HellWorld client = (HelloWorld) context.getBean("helloClient");



You can also do more sophisticated things with the <jaxws:client> element like add nested tags to attach JAX-WS Handlers or CXF Interceptors to the client.  For more on this see JAX-WS Configuration.

Create a Client (More Manual Way)
CXF includes a JaxWsProxyFactory bean which create a client for you from your service interface. You simply need to tell it what your service class is (the HelloWorld interface in this case) and the URL of your service. You can then create a client bean via the JaxWsProxyFactory bean by calling it's create() method.

Here's an example:
Error formatting macro: snippet: java.lang.IndexOutOfBoundsException: Index: 20, Size: 20 

If you were going to access your client you could now simply pull it out of the Spring context (or better yet, inject it into your application using Spring!):

ApplicationContext context = ...; // your Spring ApplicationContext
HelloWorld client = (HelloWorld) context.getBean("client");



client code at 
http://svn.apache.org/repos/asf/cxf/trunk/distribution/src/main/release/samples/java_first_spring_support/src/demo/spring/client/Client.java

Some usage scenarios will require more extensive configuration (and this is not the case with the <jaxws:client> syntax described above).  For more information, see JAX-WS Configuration.

Advanced Steps
For more information on using Spring you may want to read the Configuration and Spring sections of the User's Guide.
    
        
        
            Change Notification Preferences
        
        View Online
        |
        View Changes
                |
        Add Comment
 ...
 * Set up the HTTP transport
 This example corresponds to the spring_http java_first_spring_support example in the CXF distribution.
 h1. Setting up your build
 ...
 h1. Writing your Service 
First we'll write our service interface. It will have one operation called "sayHello" which says "Hello" to whoever submits their name.
 {snippet:id=service|lang=java|url="" class="diff-added-chars"style="background-color: #dfd;">main/java/demo/spring/service/HelloWorld.java?revision=HEAD}
 Our implementation will then look like this:
 {snippet:id=service|lang=java|url="" class="diff-added-chars"style="background-color: #dfd;">main/java/demo/spring/service/HelloWorldImpl.java?revision=HEAD}
 The {{@WebService}} annotation on the implementation class lets CXF know which interface to use when creating WSDL. In this case its simply our HelloWorld interface.
 ...
 CXF contains support for "nice XML" within Spring 2.0. For the JAX-WS side of things, we have a <jaxws:endpoint> bean which sets up a server side endpoint.
 Lets create a "beans.xml" "cxf-servlet.xml" file in our WEB-INF directory which declares an endpoint bean:
 {snippet:id=beans|lang=java|url=""> {snippet:id=beans|lang=java|url="">
 If you want to reference a spring managed-bean, you can write like this:
 ...
 h1. Setting up the Servlet
-We'll need to add two things to our web.xml file: 
# the Spring {{ContextLoaderLister}}. This starts Spring and loads our beans.xml file. We can specify where our file is via a {{context-param}} element. 
# the CXF Servlet 
{snippet:id=webxml|lang=java|url=""
+Since we're relying on the default "cxf-servlet.xml" file the [default web.xml|http://svn.apache.org/viewvc/cxf/trunk/distribution/src/main/release/etc/web.xml?revision=HEAD] referenced by many samples can be used.
+Alternatively, for arbitrarily named configuration files such as beans.xml, application-context.xml, etc. we can add the following elements: 
# the Spring {{ContextLoaderLister}}. This starts Spring and explicitly loads the configuration file. We can specify where our file is via a {{context-param}} element. 
 
An example: 
{code:java} 
<web-app ...> 
... 
   <context-param> 
      <param-name>contextConfigLocation</param-name> 
      <param-value>WEB-INF/beans.xml</param-value> 
   </context-param> 
 
   <listener> 
      <listener-class> 
         org.springframework.web.context.ContextLoaderListener 
      </listener-class> 
   </listener> 
</web-app> 
{code}
 It is important to note that the address that you chose for your endpoint bean must be one your servlet listens on. For instance, if my Servlet was register for "/some-services/*" but my address was "/more-services/HelloWorld", there is no way CXF could receive a request.
 ...
 {code:java} 
ApplicationContext context = ...; // your Spring ApplicationContext
 HelloWorld client = (HelloWorld) context.getBean("client");
 {code}
 ...
 Some usage scenarios will require more extensive configuration (and this is not the case with the <jaxws:client> syntax described above).  For more information, see JAX-WS Configuration.

[CONF] Apache CXF Documentation > Writing a service with Spring

Writing a service with Spring

Page edited by Glen Mazza

Changes (9)

Full Content

Setting up your build

Writing your Service

Declaring your server beans

Setting up the Servlet

Create a Client (Easy Way)

Create a Client (More Manual Way)

Advanced Steps

Reply via email to