Tutoriel sur l'utilisation de Spring Web Services

Jérémy Jeanne

Cet article s'intéresse aux services Web avec Spring Web Services ainsi qu'aux concepts relatifs aux services Web.

Pour réagir au contenu de cet article, un espace de dialogue vous est proposé sur le forum. Commentez .

- Titre : Tutoriel sur l'utilisation de Spring Web Services

- Auteur : Jérémy Jeanne

- Parution : 19 février 2015

- Mise à jour : 20 février 2020

- Licence : Copyright ® 2014 Jeremy Jeanne. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Qu'est-ce qu'un service Web ?

- II-A. Le protocole SOAP

- II-B. UDDI

- II-C. WSDL

- III. Les Web services avec Spring Web Service

- III-A. Développer un Contract First Web Services avec Spring

- III-A-1. Data Contract

- III-A-2. Service Contract

- III-B. Création automatique des classes avec JAXB

- III-B-1. Création de la base de données

- III-B-2. Création d'un projet avec Spring Web Service dans Eclipse utilisant Maven

- III-B-2-a. Création d'un simple projet Maven dans Eclipse

- III-B-2-b. Création des fichiers xsd

- III-B-2-c. Création des classes Endpoint, Service et de la couche Dao

- III-B-2-d. Création des fichiers spring-configurations et web.xml

- III-C. Lancement du projet

- IV. Remerciements

I - Introduction

Dans cet article, nous aborderons les services Web avec Spring Web Services ainsi que les concepts relatifs aux services Web. Nous traiterons également les questions suivantes :

- quelle est la définition d'un service Web ?

- qu'est-ce qu'un contrat ? Qu'est-ce qu'un WSDL ?

- qu'est-ce qu'un XSD et quelle est la différence entre « Contract First » et « Contract Last » ?

II - Qu'est-ce qu'un service Web ?

Les services Web sont des composants Web basés sur le protocole HTTP et ils respectent un format spécifique ( XML).

Ils permettent aux applications de faire appel à des fonctionnalités à distance en simplifiant l'échange de données et de dialoguer à travers le réseau indépendamment de :

- leur plateforme d'exécution ;

- leur langage d'implémentation.

Le cœur des services Web est une combinaison de XML et du protocole HTTP. XML est utilisé comme un langage pour la communication entre les différentes plateformes et les langages de programmation. HTTP est communément utilisé comme un protocole pour transférer les données entre le client et le serveur.

Les services Web s'articulent autour des trois concepts suivant :

1. SOAP ;

2. UDDI ;

3. WSDL.

II-A - Le protocole SOAP

SOAP signifie Simple Object Access Protocol, c'est un protocole basé sur XML qui permet aux applications de communiquer via HTTP. SOAP est un standard w3c indépendant de la plateforme et du langage pour envoyer et recevoir des messages. Pour en savoir plus, je vous renvoie vers la SOAP Documentation.

II-B - UDDI

UDDI signifie « Universal Description, Discovery and Integration », normalise une solution d'annuaires distribués pour les Web services. Il permet à la fois la publication et l'exploration de Web services. Il se comporte lui même comme un Web service dont les méthodes sont appelées par le protocole SOAP. Pour en savoir plus, je vous renvoie vers la UUID Documentation.

II-C - WSDL

WSDL est un acronyme pour « Web Services Description Language ». C'est un simple document XML qui décrit un Web service et spécifie le point d'accès (URL) et les opérations ou méthodes qu'un Web service expose. Pour en savoir plus, je vous renvoie vers la WSDL Documentation.

III - Les Web services avec Spring Web Service

Quand vient le moment de développer un Web service, on constate qu'il existe deux approches principales pour le faire :

1. Contract First Web Services ;

2. Contract Last Web Services.

Dans les Web services « Contract first », le Contract (WSDL), XML et les Endpoints sont développés avant d'écrire le code du service. L'important est le contrat du service, l'implémentation étant secondaire.La première étape est donc de définir son propre WSDL : types, messages, ports, binding, services. Une connaissance de XML, de SOAP et du WSDL est donc absolument nécessaire.

Dans les Web services « Contract last », le principe est de créer le service sous forme de classes (et d'interfaces) Java, et d'utiliser un outil (généralement inclus dans l'API utilisé) qui permet de générer automatiquement le WDSL correspondant. Cette manière de procéder ne nécessite pas spécialement une grande connaissance de SOAP, des WSDL, voire de XML. De plus, le déploiement d'un tel service peut être très rapide : une classe, quelques annotations, un serveur JEE compatible et voilà un service Web tout fait.

Les sources de ce projet sont disponibles sur mon GitHub à l'adresse suivante : https://github.com/jyjeanne/spring-server-final

III-A - Développer un Contract First Web Services avec Spring

L'approche Contract First est conseillée pour créer un Web service dans Spring. Elle commence avec un fichier XML appelé WSDL(Contrat) et le code Java correspondant. Un contrat est un fichier XML qui décrit le format de la requête et la réponse, l'emplacement du endpoint et d'autres choses très utiles.

Il y a deux types de contrats dans Spring Web Services :

1. Data Contracts ;

2. Service Contracts.

III-A-1 - Data Contract

Le Data Contract est un fichier XML qui définit le format du message que nous acceptons. Il y a beaucoup d'approches pour définir le Data Contract comme DTD's , RELAX NG, Schematron et XSD. La manière la plus simple pour créer un XSD est d'utiliser un XSD existant et de l'adapter à vos besoins. Ces fichiers sont sauvegardés avec l'extension .xsd. Voici un exemple de fichier XSD :

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://beingjavaguys.spring.com"
targetNamespace=" http://beingjavaguys.spring.com " elementFormDefault="qualified"
attributeFormDefault="unqualified">

<xs:element name="User" type="User" />
<xs:complexType name="User">
<xs:sequence>
<xs:element name="UserId" type="xs:string" />
<xs:element name="UserName" type="xs:string" />
<xs:element name="UserGender" type="xs:string" />
<xs:element name="UserCity" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>

III-A-2 - Service Contract

Le Service Contract est représenté par un fichier WSDL. Dans Spring, il n'y a pas besoin d'écrire un fichier WSDL manuellement, il peut être généré automatiquement à partir du fichier XSD. Un fichier Service Contract ou WSDL ressemble à ceci :

<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:sch0="http://com/javaguys/accountservice" xmlns:sch1="http://com/javaguys/accountservice"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://com/javaguys/accountservice"
targetNamespace="http://com/javaguys/accountservice">

<wsdl:types>
<xsd:schema xmlns="http://com/javaguys/accountservice"
xmlns:user="http://com/javaguys/accountservice" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
attributeFormDefault="unqualified" elementFormDefault="qualified"
targetNamespace="http://com/javaguys/accountservice">

<xsd:import namespace="http://com/javaguys/accountservice" />

<xsd:element name="UserDetailsRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="UserId" type="xsd:string" />
<xsd:element name="UserName" type="xsd:string" />
<xsd:element name="UserGender" type="xsd:string" />
<xsd:element name="UserCity" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>

<xsd:element name="UserDetailsResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="UserId" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

<xs:schema xmlns="http://com/javaguys/accountservice"
xmlns:xs="http://www.w3.org/2001/XMLSchema" attributeFormDefault="unqualified"
elementFormDefault="qualified" targetNamespace="http://com/javaguys/accountservice">

<xs:element name="User" type="User" />
<xs:complexType name="User">
<xs:sequence>
<xs:element name="UserId" type="xs:string" />
<xs:element name="UserName" type="xs:string" />
<xs:element name="UserGender" type="xs:string" />
<xs:element name="UserCity" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>
</wsdl:types>

<wsdl:message name="UserDetailsRequest">
<wsdl:part element="tns:UserDetailsRequest" name="UserDetailsRequest"></wsdl:part>
</wsdl:message>

<wsdl:message name="UserDetailsResponse">
<wsdl:part element="tns:UserDetailsResponse" name="UserDetailsResponse"></wsdl:part>
</wsdl:message>

<wsdl:portType name="AccountDetailsService">
<wsdl:operation name="UserDetails">
<wsdl:input message="tns:UserDetailsRequest" name="UserDetailsRequest"></wsdl:input>
<wsdl:output message="tns:UserDetailsResponse" name="UserDetailsResponse"></wsdl:output>
</wsdl:operation>
</wsdl:portType>

<wsdl:binding name="AccountDetailsServiceSoap11" type="tns:AccountDetailsService">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="UserDetails">
<soap:operation soapAction="" />
<wsdl:input name="UserDetailsRequest">
<soap:body use="literal" />
</wsdl:input>
<wsdl:output name="UserDetailsResponse">
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>

<wsdl:service name="AccountDetailsServices">
<wsdl:port binding="tns:AccountDetailsServiceSoap11" name="AccountDetailsServiceSoap11">
<soap:address location="http://localhost:8080/Server-FormSubmit/endpoints" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

III-B - Création automatique des classes avec JAXB

Pour illustrer cet article, rien de mieux que de créer une application Web avec Maven dans Eclipse avec les dépendances dans le fichier pom.xml et de configurer pour obtenir nos classes Java à partir du fichier XSD. Ce mini projet contiendra deux Web services. Le premier pour obtenir le détail d'un utilisateur avec son id et le second pour sauvegarder les informations d'un utilisateur dans une base de données MySQL.

III-B-1 - Création de la base de données

Avant de commencer à écrire le code de notre application, nous allons créer la base de données avec le script SQL suivant :

-- Dumping database structure for userdb
CREATE DATABASE IF NOT EXISTS `userdb` /*!40100 DEFAULT CHARACTER SET latin1 */;
USE `userdb`;

-- Dumping structure for table userdb.user
CREATE TABLE IF NOT EXISTS `user` (
`id` varchar(10) DEFAULT NULL,
`name` varchar(10) DEFAULT NULL,
`gender` varchar(10) DEFAULT NULL,
`status` varchar(10) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

III-B-2 - Création d'un projet avec Spring Web Service dans Eclipse utilisant Maven

Nous allons créer le projet en quatre étapes.

Étape 1 : créez un simple projet Maven dans Eclipse et ajoutez les goal entries et les dépendances dans le fichier pom.xml.

Étape 2 : création des fichiers xsd que le Web service utilisera. Ajoutez-les au projet (ex. /WEB-INF/schemas/..), et générez les classes en utilisant Maven.

Étape 3 : Créez le Endpoint du service et les classes de la couche DAO de l'application.

Étape 4 : création de la spring-configurations et test des Web services.

Voici en détail le contenu de chacune de ces étapes :

III-B-2-a - Création d'un simple projet Maven dans Eclipse

Étape 1 : créez un simple projet Maven dans Eclipse et ajoutez les goal entries et les dépendances dans le fichier pom.xml.

Créez un projet Maven dans eclipse (File > New > Project > Maven Project), renseignez le Group Id et l'Artifact Id comme « spring-server-final » et remplacez le contenu de votre pom.xml par les informations suivantes :

<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<artifactId>spring-server-final</artifactId>
<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>
<groupId>spring-server-final</groupId>
<version>1.0-SNAPSHOT</version>
<name>spring-server-final</name>
<url>http://maven.apache.org</url>
<repositories>
<repository>
<id>spring-maven-milestone</id>
<name>Springframework Maven Repository</name>
<url>http://maven.springframework.org/milestone</url>
</repository>
</repositories>

<properties>
<spring.version>3.2.2.RELEASE</spring.version>
<spring.ws.version>2.0.0.RELEASE</spring.ws.version>
<log4j.version>1.2.16</log4j.version>
<context.path>spring-server</context.path>
</properties>

<dependencies>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.2.5</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.2.5</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.ws</groupId>
<artifactId>spring-ws-core</artifactId>
<version>${spring.ws.version}</version>
</dependency>
<dependency>
<groupId>org.apache.ws.commons.schema</groupId>
<artifactId>XmlSchema</artifactId>
<version>1.4.3</version>
</dependency>
</dependencies>

<build>
<finalName>spring-server-final</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<!-- JAXB xjc plugin that invokes the xjc compiler to compile XML schema
into Java classes. -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>jaxb2-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>xjc</goal>
</goals>
</execution>
</executions>
<configuration>
<!-- The schema directory or xsd files. -->
<schemaDirectory>${basedir}/src/main/webapp/schemas</schemaDirectory>
<!-- The working directory to create the generated java source files. -->
<outputDirectory>${basedir}/src/main/java</outputDirectory>
</configuration>
</plugin>
</plugins>
</build>
</project>

III-B-2-b - Création des fichiers xsd

Étape 2 : Création des fichiers xsd que le Web service utilisera. Ajoutez-les au projet (ex. /WEB-INF/schemas/..), et générez les classes en utilisant Maven.

Créez un nouveau répertoire /webapp/schemas/ sous /src/main/ et y copier les fichiers xsd suivants :

\src\main\webapp\schemas\UserDetails.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns=http://user.wayofcode.blog.com
targetNamespace="http://user.wayofcode.blog.com" elementFormDefault="qualified"
attributeFormDefault="unqualified">
<xs:element name="User" type="User" />
<xs:complexType name="User">
<xs:sequence>
<xs:element name="UserId" type="xs:string" />
<xs:element name="UserName" type="xs:string" />
<xs:element name="UserGender" type="xs:string" />
<xs:element name="UserStatus" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>

\src\main\webapp\schemas\GetUserServiceOperations.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://com/wayofcode/webservices/getUserServices" xmlns:user="http://user.wayofcode.blog.com"
targetNamespace="http://com/wayofcode/webservices/getUserServices"
elementFormDefault="qualified">
<xsd:import namespace="http://user.wayofcode.blog.com"
schemaLocation="UserDetails.xsd" />
<xsd:element name="GetUserRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="userId" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="GetUserResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="userDetails" type="user:User" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

\src\main\webapp\schemas\SaveUserServiceOperations.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns="http://com/wayofcode/webservices/saveUserServices" xmlns:user="http://user.wayofcode.blog.com"
targetNamespace="http://com/wayofcode/webservices/saveUserServices"
elementFormDefault="qualified">
<xsd:import namespace="http://user.wayofcode.blog.com"
schemaLocation="UserDetails.xsd" />
<xsd:element name="SaveUserRequest">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="userDetails" type="user:User" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="SaveUserResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="userId" type="xsd:string" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

Maintenant, utilisez la commande mvn install -Dmaven.test.skip=true, et vous obtiendrez automatiquement les classes et les répertoires.

Le répertoire src de votre projet doit ressembler à ça :

III-B-2-c - Création des classes Endpoint, Service et de la couche Dao

Étape 3 : création des classes Endpoint, Service et de la couche DAO de l'application.

\src\main\java\com\javaguys\webservices\endpoints\Endpoints.java

package com.wayofcode.webservices.endpoints;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;

import com.wayofcode.services.UserService;
import com.wayofcode.webservices.getUserServices.GetUserRequest;
import com.wayofcode.webservices.getUserServices.GetUserResponse;
import com.wayofcode.webservices.saveUserServices.SaveUserRequest;
import com.wayofcode.webservices.saveUserServices.SaveUserResponse;

@Endpoint
public class UserServiceEndpoints {

private static final String GET_TARGET_NAMESPACE = "http://com/javaguys/webservices/getUserServices";
private static final String SAVE_TARGET_NAMESPACE = "http://com/javaguys/webservices/saveUserServices";

@Autowired
private UserService userService;

@PayloadRoot(localPart = "GetUserRequest", namespace = GET_TARGET_NAMESPACE)
public @ResponsePayload
GetUserResponse getUserDetails(@RequestPayload GetUserRequest request) {
System.out.println("Get User !");
GetUserResponse response = new GetUserResponse();
response.setUserDetails(userService.getUserDetails(request.getUserId()));
return response;
}

@PayloadRoot(localPart = "SaveUserRequest", namespace = SAVE_TARGET_NAMESPACE)
public @ResponsePayload
SaveUserResponse saveUserDetails(@RequestPayload SaveUserRequest request) {
System.out.println("Save User !");
SaveUserResponse response = new SaveUserResponse();
response.setUserId(userService.saveUserDetails(request.getUserDetails()));
return response;
}

public void setUserService(UserService userService_i) {
this.userService = userService_i;
}

}

\src\main\java\com\wayofcode\dao\UserDao.java

package com.wayofcode.dao;

import com.blog.wayofcode.user.User;

public interface UserDao {
public User getUserDetails(String userId);

public String saveUserDetails(User user);
}

Nous utiliserons l'annotation @Repository, cela permet l'auto détection de la classe lors du scan du classpath. @Repository cela permet d'identifier la classe comme un Data Access Object.

\src\main\java\com\javaguys\dao\UserDaoImpl.java

package com.wayofcode.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import org.springframework.stereotype.Repository;
import com.blog.wayofcode.user.User;

@Repository
public class UserDaoImpl implements UserDao {

public User getUserDetails(String userId) {

User user = new User();
String connectionURL = "jdbc:mysql://localhost:3306/userDB";

Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection(connectionURL, "root", "root");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("select * from user where id="
+ userId);

while (rs.next()) {
user.setUserId(rs.getString("id"));
user.setUserGender(rs.getString("gender"));
user.setUserName(rs.getString("name"));
user.setUserStatus(rs.getString("status"));
}
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}

return user;
}

public String saveUserDetails(User user) {
String connectionURL = "jdbc:mysql://localhost:3306/userDB";

Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection(connectionURL, "root", "root");
Statement stmt = con.createStatement();
int i = stmt.executeUpdate("insert into user values ('"
+ user.getUserId() + "','" + user.getUserName() + "','"
+ user.getUserGender() + "','" + user.getUserStatus()
+ "')");
System.out.println("Succeded !");
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return user.getUserId();
}

}

\src\main\java\com\javaguys\services\UserService.java

package com.wayofcode.services;

import com.blog.wayofcode.user.User;

public interface UserService {
public User getUserDetails(String userId);

public String saveUserDetails(User user);
}

Maintenant, c'est le moment de coder la partie service en Java. Nous avons utilisé l'annotation @Service, cela permet d'utiliser l'auto détection.

\src\main\java\com\javaguys\services\UserServiceImpl.java

package com.wayofcode.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.blog.wayofcode.user.User;
import com.wayofcode.dao.UserDao;

@Service
public class UserServiceImpl implements UserService {

@Autowired
private UserDao userDao;

public User getUserDetails(String userId) {
return userDao.getUserDetails(userId);
}

public String saveUserDetails(User user) {
return userDao.saveUserDetails(user);
}

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

}

III-B-2-d - Création des fichiers spring-configurations et web.xml

Étape 4 : création des fichiers spring-configurations et web.xml.

Créez dans le répertoire webapp un fichier « web.xml » et un fichier « spring-config.xml » avec les informations de configuration suivantes :

\src\main\webapp\WEB-INF\web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/config/spring-config.xml
</param-value>
</context-param>

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

<servlet>
<servlet-name>webservices</servlet-name>
<servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
<init-param>
<param-name>transformWsdlLocations</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value></param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>webservices</servlet-name>
<url-pattern>*.wsdl</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>webservices</servlet-name>
<url-pattern>/endpoints/*</url-pattern>
</servlet-mapping>

</web-app>

\src\main\webapp\WEB-INF\config\spring-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:sws="http://www.springframework.org/schema/web-services"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/web-services
http://www.springframework.org/schema/web-services/web-services-2.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan
base-package="com.wayofcode.services,com.wayofcode.webservices,com.wayofcode.dao," />
<sws:annotation-driven />

<!-- Our test service bean -->
<bean id="GetUserService"
class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition"
lazy-init="true">
<property name="schemaCollection">
<bean
class="org.springframework.xml.xsd.commons.CommonsXsdSchemaCollection">
<property name="inline" value="true" />
<property name="xsds">
<list>
<value>schemas/GetUserServiceOperations.xsd</value>
</list>
</property>
</bean>
</property>
<property name="portTypeName" value="GetUserService" />
<property name="serviceName" value="GetUserService" />
<property name="locationUri" value="/endpoints" />
</bean>
<bean id="SaveUserService"
class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition"
lazy-init="true">
<property name="schemaCollection">
<bean
class="org.springframework.xml.xsd.commons.CommonsXsdSchemaCollection">
<property name="inline" value="true" />
<property name="xsds">
<list>
<value>schemas/SaveUserServiceOperations.xsd</value>
</list>
</property>
</bean>
</property>
<property name="portTypeName" value="SaveUserService" />
<property name="serviceName" value="SaveUserService" />
<property name="locationUri" value="/endpoints" />
</bean>

</beans>

III-C - Lancement du projet

Lancez le projet sur le serveur ; si vous avez bien suivi les étapes, vous devriez obtenir la page suivante :

IV - Remerciements

Cet article a été publié avec l'aimable autorisation de Jeremy Jeanne.

Nous tenons à remercier Malick SECK pour la relecture orthographique attentive de cet article et Régis Pouiller pour la mise au gabarit.