Créer un Web Service avec JAX-WS, CXF et Spring sous Tomcat

A travers cet article, on verra comment créer un Web Services avec JAX-WS / CXF, Spring et Tomcat. On utilisera pour ce tutoriel :
- Eclipse pour le développement
- Maven pour la construction des dépendances
- Tomcat pour le déploiement


1. Dépendances

Créez un projet Web avec Maven sous Eclipse et ajoutez les dépendances suivantes à votre pom.xml :

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>3.1.1.RELEASE</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.1.1.RELEASE</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-api</artifactId>
<version>2.6.0</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>2.6.0</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>2.6.0</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>3.1.1.RELEASE</version>
<scope>test</scope>
</dependency>

2. Configuration

On commence par la configuration du fichier web.xml, on déclare la servlet de CXF CXFServlet et le listner de Spring ContextLoaderListener.

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/applicationContext.xml</param-value>
</context-param>

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

<servlet>
<servlet-name>CXFServlet</servlet-name>
<display-name>CXF Servlet</display-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/WS/*</url-pattern>
</servlet-mapping>

Passons à la configuration Spring :
- Importer les fichiers de CXF
- Déclarer l'implémentation du service Web

<?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:jaxws="http://cxf.apache.org/jaxws"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

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

<context:component-scan base-package="com.elmaroufy.testcxf" />

<jaxws:endpoint id="additionWS" implementor="com.elmaroufy.testcxf.AdditionWS"
address="/AdditionWS" />
</beans>

3. Les classes Java

La classe d'implémentation du service Web annoté avec l'annotation JAX-WS @WebService et l'annotation Spring @Service

package com.elmaroufy.testcxf;

import javax.jws.WebMethod;
import javax.jws.WebService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@WebService
@Service
public class AdditionWS {

@Autowired
AdditionService additionService;

@WebMethod
public int somme(int a, int b) {
return additionService.somme(a, b);
}

}

Et la classe métier

package com.elmaroufy.testcxf;

import org.springframework.stereotype.Service;

@Service
public class AdditionService {
public int somme(int a, int b) {
return a+b;
}

}

Votre WSDL généré peut être accessible via l'URL : http://serveur:port/context/WS/AdditionWS?WSDL

et voici ce que donne un Test avec SoapUI :

Créer un projet Web avec Maven sous Eclipse

Cet article vous montrera comment initialiser un projet Web avec Maven et Eclipse.

Outils utilisés :
- Eclipse
- Maven

Pour commencer,créez un projet Maven sous Eclipse :
File > New > Other...

Suivant : choisissez le chemin de votre Workspace

Puis suivant, à l'étape suivante vous devez l'archetype maven-archetype-webapp pour créer un projet Web prêt à compiler et déployer :

Renseignez le Group Id et l'Artifact Id

Finish, votre projet ressemble à l'arborescence ci-dessous :

Créer un projet Java EE 6 avec Maven sous Eclipse et GlassFish 3

Cet article vous montrera comment utiliser Maven pour créer un projet Java EE 6 (JSF2, EJB3.1, JPA2, Maven 3) sous Eclipse et GlassFish 3.

Outils utilisés :
- Eclipse
- GlassFish
- Maven
- MySQL

1. Créer un projet Web à partir du model Maven.

Pour commencer,créez un projet Maven sous Eclipse :
File > New > Other...

Suivant : choisissez le chemin de votre Workspace

Puis suivant, à l'étape suivante vous devez l'archetype maven-archetype-webapp pour créer un projet Web prêt à compiler et déployer :

Renseignez le Group Id et l'Artifact Id

Finish, votre projet ressemble à l'arborescence ci-dessous :

2. La couche présentation avec JSF.

On va maintenant se pencher sur la couche présentation.
Remplacez le contenue de votre web.xml par :

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>
<context-param>
<param-name>javax.faces.DEFAULT_SUFFIX</param-name>
<param-value>.xhtml</param-value>
</context-param>
</web-app>

Ajouter la dépendance javaee-api,entre les balises <dependencies> et </dependencies>, à votre pom.xml : Veillez à ce que le scope soit provided, votre application utilise ainsi les librairies fournies par GlassFish au moment d'exécution, et celles fournies par Maven au moment de compilation.

<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>6.0</version>
<scope>provided</scope>
</dependency>

On passe maintenant à la création d'une page JSF, supprimer la page index.jsp et créer une autre index.xhtml dans le répertoire webapp de votre projet :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:f="http://java.sun.com/jsf/core"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Test JSF Page</title>
</h:head>v <h:body>
<h:form name="monForm">
<h1>Page de test</h1>
<h:outputText value="Test outputText" />

</h:form>
</h:body>
</html>

Votre projet est prêt pour le test, déployer et tester votre application : Développons notre page JSF, supposons que nous souhaitons créer un champs texte dont le contenu sera affiché dans la page après un clique sur un bouton ...
Pour cela créer un fichier beans.xml dans le WEB-INF :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
</beans>

Créer ensuite le bean suivant :

package com.elmaroufy.testwebapp;
import javax.enterprise.context.RequestScoped;
import javax.inject.Named;
@Named
@RequestScoped
public class TestBean {
private String test;
public String getTest() {
return test;
}
public void setTest(String test) {
this.test = test;
}
public void myAction(){
}
}

Modifier également votre page index.xhtml :

<h:inputText value="#{testBean.test}" /> <h:commandButton value="Test" action="#{testBean.myAction}" /> <h:outputText value=" #{testBean.test}" />

3. l'accès au données avec JPA :

Préparer votre base de données, j'ai choisis une BDD MySL, et n'oubliez pas de copiez le connecteur Java Mysql dans le répertoire lib\ext de votre domaine GlassFish.
Avant d'intégrer JPA à votre application, vous allez créer un Pool de connexion dans votre GlassFish :
Démarrer la console GlassFish, allez dans ressources > JDBC > Pools de connexions > Nouveau ...

Cliquer sur suivant

Renseignez les paramétrés suivants :
Url : jdbc:mysql://localhost:3306/testdb
URL : jdbc:mysql://localhost:3306/testdb
User : testuser
DatabaseName : testdb
Password : password

Adapter ces valeurs à votre base de données.

Toujours dans la console, allez dans allez dans ressources > JDBC > Ressources JDBC > Nouveau ...

Nom JNDI : jndi/testdb
Nom du pool : le pool de connexion que vous venez de créer

Retournez sur Eclipse. La première chose que vous allez effectuer pour votre implémentation de la couche d'accès aux données est la création du fichier persistence.xml.
Rassurez-vous que le fichiez est crée dans le répertoire META-INF qui doit, à son rôle, figurer dans le sous répertoire \src\main\resources :

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

<persistence-unit name="testpu" transaction-type="JTA">

<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>

<jta-data-source>jndi/testdb</jta-data-source>

<class>com.elmaroufy.testwebapp.TestEntity</class>

<properties>
<property name="eclipselink.ddl-generation" value="drop-and-create-tables" />

</properties>

</persistence-unit>

</persistence>

Noter que
- On utilise ici l'implémentation de JPA qui est fournie avec GlassFish, à savoir EclipseLink ( <provider> )
- <jta-data-source> est le nom de la ressource JDBC que vous venez de créer via la console GlassFish
- <class> est la classe enity, on se contente dans cet article d'une seule classe

Passons directement à la création de la classe Entity :

package com.elmaroufy.testwebapp;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class TestEntity implements Serializable {

@Id
@GeneratedValue
private Long id;

@Column
private String label;

/* getters et setters */

}

Et la classe DAO:

package com.elmaroufy.testwebapp;

import java.io.Serializable;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@javax.ejb.Singleton
public class TestDao implements Serializable {

@PersistenceContext(unitName = "testpu")
private EntityManager em;

public void saveTestEntity(TestEntity testEntity) {
em.persist(testEntity);
}

}

Vous pouvez ainsi injecter facilement votre DAO dans une couche supérieure, ici on injecte la DAO directement dans notre bean JSF :
Voici à quoi ressemblera la classe TestBean après la modification

package com.elmaroufy.testwebapp;

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.inject.Named;

@Named
@RequestScoped
public class TestBean {

@Inject
private TestDao testDao;

private String test;

public String getTest() {
return test;
}

public void setTest(String test) {
this.test = test;
}

public void myAction(){
TestEntity testEntity = new TestEntity();
testEntity.setLabel(test);
testDao.saveTestEntity(testEntity);
}

}

Le projet est maintenant prêt pour un test opérationnel :
Vérifiez que l'insertion a bien été effectuée en BDD :


Vous pouvez compléter votre projet en :
- Utilisant Hibernate à la place de EclipseLink
- Rajouter les logs avec SLF4J
- Rajouter des JUnit