A simple JAX-WS service

http://cxf.apache.org/docs/a-simple-jax-ws-service.html

 

This example will lead you through creating your first service with doing "code first" development with JAX-WS.

• Setting up your build
• Writing your Service
• Publishing your service
• Accessing your service

This example corresponds to the hello_world_code_first example in the CXF distribution. IMPORTANT : This sample is only in CXF 2.0.1+!

Setting up your build

If you're using Maven to build your project have a look at this page .

Otherwise, 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. (note: the version numbers on these jars may be different if versions have changed)

commons-logging-1.1.1.jar
geronimo-activation_1.1_spec-1.0.2.jar (or Sun's Activation jar)
geronimo-annotation_1.0_spec-1.1.1.jar (JSR 250)
geronimo-javamail_1.4_spec-1.6.jar (or Sun's JavaMail jar)
geronimo-servlet_2.5_spec-1.2.jar (or Sun's Servlet jar)
geronimo-ws-metadata_2.0_spec-1.1.2.jar (JSR 181)
geronimo-jaxws_2.1_spec-1.0.jar (or Sun's jaxws-api-2.1.jar)
geronimo-stax-api_1.0_spec-1.0.1.jar (or other stax-api jar)
jaxb-api-2.1.jar
jaxb-impl-2.1.12.jar
jetty-6.1.21.jar
jetty-util-6.1.21.jar
neethi-2.0.4.jar
saaj-api-1.3.jar
saaj-impl-1.3.2.jar
wsdl4j-1.6.2.jar
wstx-asl-3.2.8.jar
XmlSchema-1.4.5.jar
xml-resolver-1.2.jar

The Spring jars (optional - for XML Configuration support):

aopalliance-1.0.jar
spring-core-2.5.5.jar
spring-beans-2.5.5.jar
spring-context-2.5.5.jar
spring-web-2.5.5.jar

And the CXF jar:

cxf-2.2.3.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.

@WebService
public

 interface

 HelloWorld {

    String

 sayHi(String

 text);


    /* Advanced usecase of passing an Interface in.  JAX-WS/JAXB does not
     * support interfaces directly.  Special XmlAdapter classes need to
     * be written to handle them
     */
    String

 sayHiToUser(User user);


    /* Map passing
     * JAXB also does not support Maps.  It handles Lists great, but Maps are
     * not supported directly.  They also require use of a XmlAdapter to map
     * the maps into beans that JAXB can use. 
     */
    @XmlJavaTypeAdapter(IntegerUserMapAdapter.class)
    Map<Integer

, User> getUsers();
}

To make sure your parameter is named correctly in the xml you should use:

@WebService
public

 interface

 HelloWorld {
    String

 sayHi(@WebParam(name="text"

) String

 text);
}

The @WebParam annotation is necessary as java interfaces do not store the Parameter name in the .class file. So if you leave out the annotation your parameter will be named arg0.

Our implementation will then look like this:

package

 demo.hw.server;

import

 java.util.LinkedHashMap;
import

 java.util.Map;

import

 javax.jws.WebService;

@WebService(endpointInterface = "demo.hw.server.HelloWorld"

,
            serviceName = "HelloWorld"

)
public

 class HelloWorldImpl implements

 HelloWorld {
    Map<Integer

, User> users = new

 LinkedHashMap<Integer

, User>();


    public

 String

 sayHi(String

 text) {
        System

.out.println("sayHi called"

);
        return

 "Hello "

 + text;
    }

    public

 String

 sayHiToUser(User user) {
        System

.out.println("sayHiToUser called"

);
        users.put(users.size() + 1, user);
        return

 "Hello "

  + user.getName();
    }

    public

 Map<Integer

, User> getUsers() {
        System

.out.println("getUsers called"

);
        return

 users;
    }

}

The @WebService annotation on the implementation class lets CXF know which interface we want to create our WSDL with. In this case its simply our HelloWorld interface.

Publishing your service

System

.out.println("Starting Server"

);
HelloWorldImpl implementor = new

 HelloWorldImpl();
String

 address = "http://localhost:9000/helloWorld"

;


Endpoint.publish(address, implementor);

whole code at http://svn.apache.org/repos/asf/cxf/trunk/distribution/src/main/release/samples/java_first_jaxws/src/demo/hw/server/Server.java

Alternatively you can use the follwing code. This gives you more control over the behaviour. For example you can add a logging interceptor:

HelloWorldImpl implementor = new

 HelloWorldImpl();
JaxWsServerFactoryBean svrFactory = new

 JaxWsServerFactoryBean();
svrFactory.setServiceClass(HelloWorld.class);
svrFactory.setAddress("http://localhost:9000/helloWorld"

);


svrFactory.setServiceBean(implementor);
svrFactory.getInInterceptors().add(new

 LoggingInInterceptor());
svrFactory.getOutInterceptors().add(new

 LoggingOutInterceptor());
svrFactory.create();

You could leave out the ServiceClass. But it is better to use it so the server and the client are created from the same interface. If you instead only use the implementation class subtle problems may occur.

Pointing your browser at http://localhost:9000/helloWorld?wsdl will display the wsdl for this service

Accessing your service

and client code to see it working is at http://svn.apache.org/repos/asf/cxf/trunk/distribution/src/main/release/samples/java_first_jaxws/src/demo/hw/client/Client.java

For the client there is also the alternative approach that gives you more flexibility. Of course like above the logging interceptors are optional but they help a lot when starting:

JaxWsProxyFactoryBean factory = new

 JaxWsProxyFactoryBean();
factory.getInInterceptors().add(new

 LoggingInInterceptor());
factory.getOutInterceptors().add(new

 LoggingOutInterceptor());
factory.setServiceClass(HelloWorld.class);
factory.setAddress("http://localhost:9000/helloWorld"

);


HelloWorld client = (HelloWorld) factory.create();

String

 reply = client.sayHi("HI"

);
System

.out.println("Server said: "

 + reply);
System

.exit(0);