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 :
- SOAP ;
- UDDI ;
- 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 :
- Contract First Web Services ;
- 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 :
- Data Contracts ;
- 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 :
<?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>
<?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>
<?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.
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;
}
}
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.
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
(
);
}
}
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.
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 :
<?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>
<?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.