HBase : Un Système de Base de Données Orientée Colonne

                     Introduction

Vous avez sûrement entendu parler de BIG DATA ! Il s’agit d’un concept qui consiste à modéliser, stocker et traiter un ensemble de données hyper volumineuses, croissantes et hétérogènes (de trillions de données, des milliards de milliards de données). Qui parle donc de BIG DATA, parle certainement de données à stocker et à gérer…

On estime par ailleurs que 80% des données d’une entreprise sont non-structurées et inexploitées… et le volume augmente de plus en plus rapidement. De plus, les infrastructures modernes nous permettent de stocker de plus en plus de données à moindre coût. Le modèle des bases de données relationnelles a montré leur limite pour stocker ces données. Ce modèle bien que très puissant, pose le problème du passage à l’échelle.  Des sites comme Google ou Facebook, possèdent plusieurs centaines de millions d’entrées dans leurs bases de données et tout autant de visites journalières. Par conséquent, une seule machine ne peut pas gérer la base de données, de plus pour des raisons de fiabilité, ces bases de données sont dupliquées pour que le service ne soit pas interrompu en cas de panne. La méthode consiste donc à rajouter des serveurs pour dupliquer les données et ainsi augmenter les performances et résister aux pannes. Seulement, dû aux propriétés fondamentales (ACID) sur lesquelles une base de données relationnelle repose, cette approche connait des limites.

L’objectif de cet article n’est pas d’exposer les détails des limites des systèmes de gestion de base de données traditionnelle (relationnelle) mais de présenter un système de base de données permettant de gérer de données volumineuse qu’on appelle communément de NOSQL. Sachant qu’il en existe plusieurs types (document, graphe, orienté colonne, etc.), nous présentons le type orientée colonne avec comme exemple HBase. 

Base de données orientée colonne ou base de données orientée Map

Pour une base de donnée orientée colonne, la notion de colonne n'a pas réellement de sens.  Le modèle de gestion des données repose sur une notion de couple {clé, valeur}. Le nom de la colonne peut être vue comme la clé. Il y a en effet, aucune notion de colonne telle que l'on peut l'entendre dans une base de données relationnelle. Donc pour éviter toute ambigüité avec la notion de colonne pour les bases de données relationnelles, je préfère utiliser le terme de base de données orientée Map.

Les données d’une base de données orientée Map (colonne) sont identifiées par une clé unique (équivalent d’une clé primaire pour les bases de données relationnelle). Ainsi on associe à ces identifiants un ensemble de données composées d’un couple clé, valeur (d’où la notion de Map). Dans le monde relationnel, ces clés sont appelées colonne.

Bien  que les données soient organisées en tables, leur disposition est totalement différente. Ainsi alors que les colonnes d’une base de données relationnelle sont statiques et présentes pour chaque ligne, celles d’une base de données orientée colonnes (disons les clés) sont dynamiques et présentes uniquement pour les lignes concernées. En d’autres termes, il est possible d’ajouter des colonnes (clés) à une ligne à tout moment et le coût de stockage d’un null est 0.

Prenons un exemple d’une base de données relationnelle, une table est un ensemble de données organisées en colonnes dont le nombre est fixe quel que soit le nombre d’enregistrements. Lorsque l’on insère un enregistrement dans cette table, on spécifie une valeur pour chaque colonne, null étant une valeur par défaut. Voici un exemple de représentation d’une personne :

Les bases de données orientées colonnes sont pensées pour stocker des millions de colonnes, ce qui en fait des bases adaptées au stockage one-to-many. Elles sont bien adaptées par exemple pour le stockage de : messages,  posts , commentaires, etc.

Les requêtes pour accéder aux données sont généralement simples. Il est en effet possible de faire des requêtes par clé, ou ensemble de clés et d’y adjoindre un prédicat sur un intervalle de clés. Un exemple de requête typique : toutes les valeurs des clés (colonnes) de l’identifiant 15 ou toutes les valeurs des clés (colonnes) dont le nom est compris entre "aaa" et "abb" pour l’identifiant 178 ou la valeur de la clé "aaa" pour les identifiants 26 à 31.

HBase : un exemple de base de données orientée colonne

Hbase est un exemple de SGBD orienté colonne. Il a été calqué sur les travaux de BigTable de Google et se repose sur le système de fichier distribué (HDFS : hadoop distributed file system).  HDFS est caractérise par une haute tolérance aux pannes et permet un accès très rapide aux données. C'est un système de fichier adapté aux applications gérant de grands ensembles de données. HBase est particulièrement bien adaptée pour le stockage de très grandes collections et a des performances exceptionnelles pour des lectures et écritures massives de données. Elle a été conçue pour stocker de très grandes tables (des milliards d'enregistrement avec des millions de colonnes) de données.

Les données sont organisées dans des tables identifiées par une simple chaîne de caractère (le nom de la table). Une table est composée d'un ensemble de lignes appelée Row. Chaque Row (ligne) est identifiée par un identifiant unique appelé ROWKEY (Identifiant). Dans Hbase, une ROWKEY n'a pas de type spécifique (c'est un simple tableau d'octets).

Une ligne Hbase est d'une part identifiée par une ROWKEY et composée d'un ensemble de couple clé-valeur (colonne – valeur associée). Dans le jargon Hbase, la clé est appelée Column Qualifier. On pourra donc parler du couple (Column Qualifier, valeur) appelé également Cell.

L'ensemble de clé ou Column Qualifier que compose une ligne, est organisé en un groupe homogène appelé Column Family (il s'agit juste de regroupement d'un ensemble de clés). Ce regroupement permet de tracer une séparation sémantique entre les clés. Par exemple, pour une table Personne, on pourra créer 2 Column Family : - Identité composée des clés (Column Qualifier) : nom, prénom, age ; - Adresse composée : numéro de la rue, nom de la rue, code postal, ville.  Une ligne Hbase est donc composée d'un ensemble de Column Family qui est composée d'un ensemble de Cell (couple clé-valeur ou Column Qualifier, valeur). 

Les Column Family ne sont pas aussi dynamiques que Column Qualifier. Elles doivent être définies lors de la création de la table et ne doivent pratiquement pas changer en cours de route. À l’opposé, les Column Qualifier peuvent être instanciées et ajoutées aux tables (aux Column Family) à tout moment.

Parmi les concepts intéressants de HBase, on retrouve le versonning des valeurs. En effet, une clé (Column Qualifier) peut avoir plusieurs valeurs avec une version associée à chaque valeur. Les versions sont identifiées par leur timestamp (de type long). Le nombre de versions est configuré lors de la définition d'une Column Family. Par défaut, ce nombre est égal à trois. 

Exemple :

La suite de cet article est de vous présenter une introduction HBase SHELL & HBase JAVA API pour effectuer de requête ...

Maven en ligne de commande : Exécution d'une classe/méthode de test spécifique

Comment exécuter une classe de test avec maven :

maven -Dtest=ClassTest test

On peut également spécifier une méthode :

maven -Dtest=ClassTest#test_method test

JAX-RS Clients : Les différentes solutions d’un client Web Service Rest

REST (REpresentational State Transfer) : le style architectural du Web



REST (ou RESTful, l’adjectif qui qualifie une architecture de type REST) n’est pas une technologie, ni un protocole ou un standard. C’est plutôt un style architectural : notion proposée par Roy Fielding (l’un des créateurs du protocole HTTP) dans sa thèse (2000) : Architectural Styles and the Design of Network-based Software Architectures. Ce style part du principe selon lequel Internet n’est pas un ensemble de pages mais comme un ensemble de ressources accessibles à partir d’une URI (Uniform Resource Identifier). Plus précisément, REST est un ensemble de critères de conception. Une architecture répond plus à ses critères qu’une autre, mais en aucun cas, nous ne pouvons pas dire que REST est une architecture.

Java EE 6 spécifie une API REST nommée JAX-RS. Cette spécification précise ce que peut ou doit faire une implémentation. Elle est la standardisation des services REST en Java et définit un ensemble d'annotations permettant d'exposer des classes java comme service REST. L'intérêt de la standardisation est de ne pas se lier à une implémentation spécifique. Plusieurs implémentations existent : Sun Jersey, Jbosse Resteasy, Spring RestTemplate, Apache Wink, CXF …L’implémentation de référence de cette API est Jersey qui n’est ni plus ni moins qu’une servlet qui prend en charge vos classes java en fonction d’annotations que vous allez utiliser.

JAX-RS spécifie l'implémentation partie serveur et ne propose rien côté client. Les implémentations fournissent généralement une API client permettant d'appeler des services REST respectant le standard JAX-RS.

Nous allons voir dans cet article les différentes solutions pour implémenter un client JAX-RS. Pour chaque client, j’énumère les dépendances maven nécessaires pour son implémentation ainsi qu’un exemple minimum de code source.



Afin de simplifier le code, chaque client implémente une interface commune : NotificationClientService












package com.larbotech.ws.domain.com.larbotech.ws.notification.service;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;

/**
 * Created by mlarbo on 18/10/14.
 */
public interface NotificationClientService {
    public static final String BASE_URL = "http://localhost:9090/larbotech-notification-service";
    public static final String NOTIFICATION_URI = BASE_URL + "/notification/{id}";
    public static final String NOTIFICATION_POST_URI = BASE_URL + "/notification";
    public static final String NOTIFICATIONS_URI = BASE_URL + "/notifications";
    public static final int connectionTimeoutMillis = 2000;
    public static final int socketTimeoutMillis = 3000;

     void deleteNotification(long id);

     Notification addNotification(Notification notification) ;

     Notification getNotification(long id);

     NotificationList getAll();

}


  



Création d'un service Rest

Supposons que nous voulons réaliser un serveur REST pour gérer des notifications d’un système d’information. L’objectif est de pouvoir notifier des événements via un objet notification. Cet objet (notification) représente la ressource. Nous devons donc pouvoir ajouter (POST), modifier (PUT), Lire (GET) et Supprimer (DELETE) des notifications.

Je commence par implémenter un service Rest de notification et le déployer sur un serveur tomcat grâce au plugin tomcat7 de maven. Ce service sera ensuite utilisé par nos différents clients. L’API REST s’appuie sur le principe des ressources. Pour implémenter un service REST, il suffit donc d’implémenter une classe (le controller) qui contient des méthodes capables de traiter requêtes HTTP. Selon le type de méthode HTTP (GET, POST, PUT ou DELETE), la méthode peut prendre un ou plusieurs paramètres de type quelconque ! L’objectif de cet article est de vous montrer comment créer de client mais pas comment créer un service Rest. Nous nous focalisons donc sur le code de clients. 

Voici le code source du Controller de notre service Rest de notification :

package com.larbotech.ws.notification.controller;

import javax.annotation.Resource;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import com.larbotech.ws.notification.service.NotificationWebService;


;

/**
 * REST service provider
 */
@Controller
@RequestMapping("/")
public class NotificationController {
    private static Logger logger = Logger.getLogger(NotificationController.class);

    @Resource(name = "notificationWebService")
    private NotificationWebService notificationWebService;

    @RequestMapping(value = "/notifications",
            method = RequestMethod.GET,
            headers = "Accept=application/xml, application/json")
    @ResponseBody
    public NotificationList getNotifications() {
        logger.debug("Provider has received request to get all notifications");
        // Call service here
        NotificationList result = new NotificationList();
        result.setData(notificationWebService.getNotifications());
        return result;
    }

    @RequestMapping(value = "/notification/{id}",
            method = RequestMethod.GET,
            headers = "Accept=application/xml, application/json")

    @ResponseBody
    public Notification getNotification(@PathVariable("id") Long id) {
        logger.debug("Provider has received request to get notification with id: " + id);

        // Call service here
        return notificationWebService.getNotification(id);
    }

    @RequestMapping(value = "/notification",
            method = RequestMethod.POST,
            headers = "Accept=application/xml, application/json")
    @ResponseBody
    public Notification addNotification(@RequestBody Notification notification) {
        logger.debug("Provider has received request to add new notification");

        // Call service to here
        return notificationWebService.toSaveNotification(notification);
    }

    @RequestMapping(value = "/notification/{id}",
            method = RequestMethod.DELETE,
            headers = "Accept=application/xml, application/json")
    @ResponseBody
    public String deleteNotification(@PathVariable("id") Long id) {
        logger.debug("Provider has received request to delete notification with id: " + id);
        // Call service here
        return String.valueOf(notificationWebService.toDeleteNotification(id));
    }

}

Client Sun Jeresey

Dépendance maven :

     <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.18.1</version>
        </dependency>
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-json</artifactId>
            <version>1.18.1</version>
        </dependency>

La classe de configuration du client :

package com.larbotech.ws.notification.client;

import static java.lang.Integer.valueOf;

import com.sun.jersey.api.client.config.DefaultClientConfig;

/**
 * Created by m-toure on 21/08/2014.
 */
public class NotificationClientConfig extends DefaultClientConfig
{

 public NotificationClientConfig()
 {
/*  getProperties().put( PROPERTY_CONNECT_TIMEOUT, valueOf( 2000 ) );// 2 seconds for connection
  getProperties().put( PROPERTY_READ_TIMEOUT, valueOf( 2000 ) );// 2 seconds read timeout*/
       getProperties().put( PROPERTY_CONNECT_TIMEOUT, valueOf( 30000 ) );// 30 seconds for connection
        getProperties().put( PROPERTY_READ_TIMEOUT, valueOf( 30000 ) );// 30 seconds read timeout
 }

}

La classe d'appel au service rest :

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import com.larbotech.ws.domain.com.larbotech.ws.notification.service.NotificationClientService;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.WebResource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriBuilder;
import java.net.URI;

/**
 * Created by mlarbo on 18/10/14.
 */
public class SunJereseyClient implements NotificationClientService{
    private static Logger logger = LoggerFactory.getLogger(NotificationClientService.class);

    private final Client clientObject = Client.create( new NotificationClientConfig() );
    private WebResource notificationResource;

    public static void main(String[] args) {
        SunJereseyClient sunJereseyClient = new SunJereseyClient();
        Notification notification = sunJereseyClient.getNotification(4);
        logger.info(notification.toString());
        sunJereseyClient.deleteNotification(4);
        notification = sunJereseyClient.addNotification(notification);
        logger.info(notification.toString());
        NotificationList notificationList = sunJereseyClient.getAll();
        for (Notification notification1:notificationList.getData()){
            logger.info(notification1.toString());
        }
    }
    public WebResource getNotificationResource() {
        if ( notificationResource == null )
        {
            URI uriObject = UriBuilder.fromUri(BASE_URL).build();
            notificationResource = clientObject.resource( uriObject );
        }
        return notificationResource;
    }

    @Override
    public void deleteNotification(long id) {
        WebResource innerResource = getNotificationResource().path( "notification" ).path(String.valueOf(id));
        WebResource.Builder builderObject = innerResource.accept( MediaType.APPLICATION_XML );
         builderObject.delete();
    }

    @Override
    public Notification addNotification(Notification notification) {
        WebResource innerResource = getNotificationResource().path("notification");
        WebResource.Builder builderObject = innerResource.accept( MediaType.APPLICATION_XML );
        return builderObject.post(Notification.class, notification);
    }

    @Override
    public Notification getNotification(long id) {
        WebResource innerResource = getNotificationResource().path( "notification" ).path( String.valueOf( id ) );
        WebResource.Builder builderObject = innerResource.accept( MediaType.APPLICATION_XML );
        return builderObject.get( Notification.class );
    }

    @Override
    public NotificationList getAll() {
        WebResource innerResource = getNotificationResource().path( "notifications" );
        WebResource.Builder builderObject = innerResource.accept( MediaType.APPLICATION_XML );
        return builderObject.get( NotificationList.class );
    }
}

Spring RestTemplate

Dépnedance maven :
 

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.3.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.5</version>
            <scope>compile</scope>
        </dependency>

La classe du client RestTemplate

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import com.larbotech.ws.domain.com.larbotech.ws.notification.service.NotificationClientService;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.HttpClientBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.util.Collections;

/**
 * Created by mlarbo on 17/10/14.
 */
public class SpringClient implements NotificationClientService{
    private static Logger logger = LoggerFactory.getLogger(SpringClient.class);
    private RestTemplate template;

    public static void main(String[] args) {
        SpringClient springClient = new SpringClient();
        Notification notification = springClient.getNotification(4);
        logger.info(notification.toString());
        springClient.deleteNotification(4);
        notification = springClient.addNotification(notification);
        logger.info(notification.toString());
        NotificationList notificationList = springClient.getAll();
        for (Notification notification1:notificationList.getData()){
            logger.info(notification1.toString());
        }
    }
    public SpringClient() {
        ClientHttpRequestFactory requestFactory
                = new HttpComponentsClientHttpRequestFactory(initHttpClient());
        template = new RestTemplate(requestFactory);
        template.setErrorHandler(new ErrorHandler());
    }

    @Override
    public void deleteNotification(long id){
        template.delete(NOTIFICATION_URI, Collections.singletonMap("id", String.valueOf(id)));
    }

    @Override
    public Notification addNotification(Notification notification) {
        return template.postForObject(NOTIFICATION_POST_URI, notification, Notification.class);
    }

    @Override
    public Notification getNotification(long id) {
        return template.getForObject(NOTIFICATION_URI, Notification.class,
                Collections.singletonMap("id", String.valueOf(id)));
    }

    @Override
    public NotificationList getAll() {
        return template.getForObject(NOTIFICATIONS_URI, NotificationList.class);
    }

    private static final class ErrorHandler implements ResponseErrorHandler {
        @Override
        public boolean hasError(ClientHttpResponse response) throws IOException {
            if (response.getStatusCode().series().compareTo(HttpStatus.Series.SUCCESSFUL) == 0) {
                return false;
            }
            return true;
        }

        @Override
        public void handleError(ClientHttpResponse response) throws IOException {
            if (response.getStatusCode().equals(HttpStatus.NOT_FOUND)) {
                throw new IOException("Notification Not Found");
            } else if (response.getStatusCode().equals(HttpStatus.BAD_REQUEST)) {
                throw new IOException("Error validating notification");
            } else {
                throw new IOException("Unexpected error:" + response.getStatusText());
            }
        }
    }

    private static HttpClient initHttpClient() {
        RequestConfig requestConfig = RequestConfig.custom().
                setConnectionRequestTimeout(1000).setConnectTimeout(connectionTimeoutMillis).setSocketTimeout(socketTimeoutMillis).build();
        HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig);
        return builder.build();
    }
}

Client Jboss Resteasy :

Dépendance maven :

 <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jaxrs</artifactId>
        <version>2.3.1.GA</version>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jackson-provider</artifactId>
        <version>2.3.1.GA</version>
        <exclusions>
            <exclusion>
                <artifactId>jackson-core-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-mapper-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jettison-provider</artifactId>
        <version>2.3.1.GA</version>
    </dependency>

Des classes utilités pour simplifier le code :

 1) Configuration du client  

package com.larbotech.ws.notification.client;


import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.jboss.resteasy.client.core.executors.ApacheHttpClient4Executor;

/**
 * Created by m-toure on 17/10/2014.
 */
public class ClientExecutor extends ApacheHttpClient4Executor
{

    private static final int connectionTimeoutMillis = 2000;
    private static final int socketTimeoutMillis = 3000;

    public ClientExecutor()
    {
        super( initHttpClient() );
    }

    private static DefaultHttpClient initHttpClient()
    {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpParams params = httpClient.getParams();
        HttpConnectionParams.setConnectionTimeout(params, connectionTimeoutMillis);
        HttpConnectionParams.setSoTimeout( params, socketTimeoutMillis );
        return httpClient;
    }
}

2) La classe factoy qui crée de proxy en fonction de l'interface proxy fournie en paramètre généric :

package com.larbotech.ws.notification.client;

import org.jboss.resteasy.client.ProxyFactory;

/**
 * Created by m-toure on 17/10/2014.
 */
public class ClientFactory {

    private ClientExecutor executor = new ClientExecutor();

    public <T> T create( Class<T> clazz, String  baseUri)
    {
        //executor.getHttpClient().getParams().e
        return ProxyFactory.create(clazz, baseUri, executor);
    }
}

3) L'interface proxy avec des annoatation JAX-RS : A ne pas confondre avec l'interface commune aux clients. Cette dernière est facultative; c'est juste pour simplifier le code de clients. Cependant, l'interface proxy est obligatoire pour implémenter un client Jboss Resteasy :

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;

import javax.ws.rs.*;


/**
 * RESTEasy Client Proxies
 *
 * Created by m-toure on 17/10/2014.
 */
@Consumes(value = "application/xml")
public interface NotificationServiceProxy {

    @GET
    @Path( "/notification/{id}" )
    @Produces( "application/xml")
            //@QueryParam si  c'est du paramètre du type /notification?id=x,v=valeur
    Notification getNotification( @PathParam( "id" ) long id );

    @DELETE
    @Path( "/notification/{id}" )
    @Produces( "application/xml")
    String remove( @PathParam( "id" ) long id );

    @POST
    @Path( "/notification" )
    @Produces("application/xml" )
    Notification addNotification( Notification notification );

    @GET
    @Path( "/notifications" )
    @Produces( "application/xml")
    NotificationList getNotifications();
}

Enfin la classe du client :

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import com.larbotech.ws.domain.com.larbotech.ws.notification.service.NotificationClientService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by m-toure on 17/10/2014.
 */
public class JbossResteasyClient implements NotificationClientService {

    private static Logger logger = LoggerFactory.getLogger(JbossResteasyClient.class);
    private ClientFactory clientFactory = new ClientFactory();
    //psvm + tab
    public static void main(String[] args) {
        JbossResteasyClient jbossResteasyClient = new JbossResteasyClient();
        Notification notification = jbossResteasyClient.getNotification(4);
        logger.info(notification.toString());
        jbossResteasyClient.deleteNotification(4);
        notification = jbossResteasyClient.addNotification(notification);
        logger.info(notification.toString());
        NotificationList notificationList = jbossResteasyClient.getAll();
        for (Notification notification1:notificationList.getData()){
            logger.info(notification1.toString());
        }
    }


    @Override
    public void deleteNotification(long id) {
        clientFactory.create( NotificationServiceProxy.class,  BASE_URL).remove(id);
    }

    @Override
    public Notification addNotification(Notification notification) {
       return clientFactory.create( NotificationServiceProxy.class,  BASE_URL).addNotification(notification);
    }

    @Override
    public Notification getNotification(long id) {
        return clientFactory.create( NotificationServiceProxy.class,  BASE_URL).getNotification(id);
    }

    @Override
    public NotificationList getAll() {
        return clientFactory.create( NotificationServiceProxy.class,  BASE_URL).getNotifications();
    }
}

CXF client

Dépendance maven :

      <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxrs</artifactId>
            <version>2.7.13</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

Classe du client (on utilise ici la même interface proxy que pour le client Jboss Resteasy)

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import com.larbotech.ws.domain.com.larbotech.ws.notification.service.NotificationClientService;
import org.apache.cxf.jaxrs.client.JAXRSClientFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by mlarbo on 18/10/14.
 */
public class CXFClient implements NotificationClientService {
    private static Logger logger = LoggerFactory.getLogger(CXFClient.class);


    public static void main(String[] args) {
        CXFClient cxfClient = new CXFClient();
        Notification notification = cxfClient.getNotification(4);
        logger.info(notification.toString());
        cxfClient.deleteNotification(4);
        notification = cxfClient.addNotification(notification);
        logger.info(notification.toString());
        NotificationList notificationList = cxfClient.getAll();
        for (Notification notification1:notificationList.getData()){
            logger.info(notification1.toString());
        }
    }

    @Override
    public void deleteNotification(long id) {
       JAXRSClientFactory.create(BASE_URL, NotificationServiceProxy.class).remove(id);
    }

    @Override
    public Notification addNotification(Notification notification) {
        return JAXRSClientFactory.create(BASE_URL, NotificationServiceProxy.class).addNotification(notification);
    }

    @Override
    public Notification getNotification(long id) {
        return JAXRSClientFactory.create(BASE_URL, NotificationServiceProxy.class).getNotification(id);
    }

    @Override
    public NotificationList getAll() {
        return JAXRSClientFactory.create(BASE_URL, NotificationServiceProxy.class).getNotifications();
    }
}

Apache Wink

Dépendance maven :

 <dependency>
            <groupId>org.apache.wink</groupId>
            <artifactId>wink-client-apache-httpclient</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-httpclient</groupId>
            <artifactId>commons-httpclient</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.3.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.5</version>
            <scope>compile</scope>
        </dependency>

La classe du client :

package com.larbotech.ws.notification.client;

import com.larbotech.ws.domain.Notification;
import com.larbotech.ws.domain.NotificationList;
import com.larbotech.ws.domain.com.larbotech.ws.notification.service.NotificationClientService;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.wink.client.ClientConfig;
import org.apache.wink.client.ClientResponse;
import org.apache.wink.client.RestClient;
import org.apache.wink.client.httpclient.ApacheHttpClientConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriBuilder;

/**
 * Created by mlarbo on 18/10/14.
 */
public class ApacheWinkClient implements NotificationClientService{
    private static Logger logger = LoggerFactory.getLogger(ApacheWinkClient.class);
    private final RestClient restClient;

    public static void main(String[] args) {
        ApacheWinkClient apacheWinkClient = new ApacheWinkClient();
        Notification notification = apacheWinkClient.getNotification(4);
        logger.info(notification.toString());
        apacheWinkClient.deleteNotification(4);
        notification = apacheWinkClient.addNotification(notification);
        logger.info(notification.toString());
        NotificationList notificationList = apacheWinkClient.getAll();
        for (Notification notification1:notificationList.getData()){
            logger.info(notification1.toString());
        }
    }
    public ApacheWinkClient() {
        ClientConfig config = new ApacheHttpClientConfig(initHttpClient());
        // Exception handler
        //config.handlers(your exception handler);
        restClient = new RestClient(config);
    }

    private static HttpClient initHttpClient() {
        RequestConfig requestConfig = RequestConfig.custom().
                setConnectionRequestTimeout(1000).setConnectTimeout(connectionTimeoutMillis).setSocketTimeout(socketTimeoutMillis).build();
        HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(requestConfig);
        return builder.build();
    }

    @Override
    public void deleteNotification(long id){
        ClientResponse response = restClient.resource(
                UriBuilder.fromUri(BASE_URL).path("/notification/").path("{id}").build(String.valueOf(id))).accept(
                MediaType.APPLICATION_XML).delete();
          // return response.getEntity(String.class);
         }

    @Override
    public Notification addNotification(Notification notification) {
        return restClient.resource(UriBuilder.fromUri(BASE_URL).path("/notification/").build())
                .contentType(MediaType.APPLICATION_XML).accept(MediaType.APPLICATION_XML).post(
                        Notification.class, notification);
    }

    @Override
    public Notification getNotification(long id) {
        return restClient.resource(
                UriBuilder.fromUri(BASE_URL).path("/notification/").path("{id}").build(String.valueOf(id))).accept(
                MediaType.APPLICATION_XML).get(Notification.class);
    }

    @Override
    public NotificationList getAll() {
        return restClient.resource(
                UriBuilder.fromUri(BASE_URL).path("/notifications/").build()).accept(
                MediaType.APPLICATION_XML).get(NotificationList.class);
    }
}

Erreurs éventuelles :

java.lang.AbstractMethodError: javax.ws.rs.core.UriBuilder.uri(Ljava/lang/String;)Ljavax/ws/rs/core/UriBuilder;
	at javax.ws.rs.core.UriBuilder.fromUri(UriBuilder.java:119)

Il suffit de chercher et d'exclure la lib javax.ws.rs-api (commande mvn dependancy:tree) :

<exclusion>

    <artifactId>javax.ws.rs-api</artifactId>					

    <groupId>javax.ws.rs</groupId>
</exclusion>