Wajdi Kharroubi: WebServices SOAP avec Apache CXF

Introduction

De manière simplifiée, SOAP permet de faire de l'appel de procédure à distance au dessus du protocole HTTP. Les données échangées sont au format XML.

Apache CXF est un framwork Java qui permet de simplifier la creation de Webservices SOAP

Architechture

L'idée est de faire un package pour le client (un jar), un package pour le serveur (un war), et un package commun (jar) aux deux qui contiendra les interfaces et les POJO échangés entre les deux services.

Cela simplifie la création d'un client en Java, mais cela n'empêche pas de créer un webservice simplement à partir du WSDL qui sera généré à la demande par CXF.

Dépendances Maven pour CXF

01<dependency>
02    <groupId>javax.servlet</groupId>
03    <artifactId>servlet-api</artifactId>
04    <version>2.5</version>
05    <scope>provided</scope>
06</dependency>
07 
08<dependency>
09    <groupId>org.apache.cxf</groupId>
10    <artifactId>cxf-rt-frontend-jaxws</artifactId>
11    <version>2.1.3</version>
12</dependency>
13 
14<dependency>
15    <groupId>org.apache.cxf</groupId>
16    <artifactId>cxf-rt-transports-http</artifactId>
17    <version>2.1.3</version>
18</dependency>

Package Commun

Tout d'abord l'interface du service

01package org.djo.example;
02 
03import javax.jws.WebParam;
04import javax.jws.WebResult;
05import javax.jws.WebService;
06 
07@WebService
08public interface MonService {
09 
10    @WebResult(name = "helloresponse")
11    Hello sayHello(@WebParam(name = "name") String name);
12 
13}

Puis une classe POJO simple pour le retour. Ce n'est pas obligatoire, on aurait pu faire un return String tout simple pour notre méthode sayHello.

01package org.djo.example;
02 
03import java.util.Date;
04 
05public class Hello {
06 
07    private Date when;
08 
09    private String hello;
10 
11    public Date getWhen() {
12        return when;
13    }
14 
15    public void setWhen(Date when) {
16        this.when = when;
17    }
18 
19    public String getHello() {
20        return hello;
21    }
22 
23    public void setHello(String hello) {
24        this.hello = hello;
25    }
26}

Package serveur

Implémentation du service

01package org.djo.example;
02 
03public class MonServiceImpl implements MonService {
04 
05    public Hello sayHello(String name) {
06        Hello response = new Hello();
07        response.setHello("Hello " + name);
08        return response;
09    }
10 
11}

WEB-INF/web.xml

01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE web-app
03    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
04    "http://java.sun.com/dtd/web-app_2_3.dtd">
05<web-app>
06    <context-param>
07        <param-name>contextConfigLocation</param-name>
08        <param-value>WEB-INF/beans.xml</param-value>
09    </context-param>
10 
11    <listener>
12        <listener-class>
13            org.springframework.web.context.ContextLoaderListener
14        </listener-class>
15    </listener>
16 
17 
18    <servlet>
19        <servlet-name>CXFServlet</servlet-name>
20        <display-name>CXF Servlet</display-name>
21        <servlet-class>
22            org.apache.cxf.transport.servlet.CXFServlet
23        </servlet-class>
24        <load-on-startup>1</load-on-startup>
25    </servlet>
26 
27 
28    <servlet-mapping>
29        <servlet-name>CXFServlet</servlet-name>
30        <url-pattern>/services/*</url-pattern>
31    </servlet-mapping>
32</web-app>

WEB-INF/beans.xml

Ce fichier va être chargé automatiquement par Spring (dont dépend CXF), afin de déclarer nos services.

01<?xml version="1.0" encoding="UTF-8"?>
02<beans xmlns="http://www.springframework.org/schema/beans"
03    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
04    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
05    http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
06 
07    <import resource="classpath:META-INF/cxf/cxf.xml" />
08    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
09    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
10 
11    <jaxws:endpoint id="MonService" implementor="org.djo.example.MonServiceImpl"
12        address="/MonService" />
13 
14</beans>

Execution

Un fois le package déployé, le WSDL du service sera disponible par exemple à l'URL http://localhost:8080/service.server/services/MonService?wsdl

Package Client

Le client aura besoin d'importer le package commun, qui contient la déclaration de l'interface et les pojo partagés. Bien sur, il est possible de générer ces pojo et cette interface à partir du WSDL, mais ce n'est pas l'objet de cet article.

Le client est alors aussi simple que cela:

01package org.djo.example;
02 
03import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
04 
05public class TestService {
06 
07    public static String address = "http://localhost:8080/service.server/services/MonService";
08 
09    public static MonService getMonService() {
10        JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();
11        factoryBean.setServiceClass(MonService.class);
12        factoryBean.setAddress(address);
13        MonService monService = (MonService) factoryBean.create();
14        return monService;
15    }
16 
17    public static void main(String[] args) {
18        Hello response = getMonService().sayHello("WAJDI");
19        System.out.println(response.getHello());
20    }
21}

Wajdi Kharroubi

jeudi 21 juin 2012

WebServices SOAP avec Apache CXF