Netapsys Blog - Tag - Spring

[Spring Security] Authentification par certificat

Cyril Ducrot — Mon, 23 Jan 2012 14:23:00 +0100

Dans le cadre du projet sur lequel je travaille en ce moment j’ai dû mettre en place le framework Spring Security. Le niveau de sécurité élevé demandé par notre client nécessitait une authentification par certificat signé en SHA-256. Je vais donc vous expliquer comment mettre en place Spring Security sur un projet maven et comment configurer une authentification par certificat.

Présentation de Spring Security

Spring Security est un framework d’authentification et de contrôle d’accès.
C’est est un sous-projet de Spring, il a été lancé en 2003 sous le nom d’Acegi Secuirty. En 2007 il sera renommé Spring Security. C’est l’un des projets les plus avancés de Spring.
Liste des projets Spring : http://www.springsource.org/projects

Deux concepts clés L'authentification consiste à garantir que la personne connectée est bien celle qu'elle prétend être alors que les autorisations consistent à vérifier que la personne connectée a bien les permissions d'effectuer une action donnée ou d’accéder à une ressource. Principe de fonctionnement : authentification par certificat 1.... Lire [Spring Security] Authentification par certificat

RESTer simple avec Spring et JAXB - Partie 3 : Client REST avec RestTemplate

Vincent Durand — Sat, 05 Mar 2011 00:28:00 +0100

Ce billet marque la fin du projet portant sur REST, Spring et JAXB avec un exemple d'implémentation client-serveur. Après avoir expliquer la partie API partagée entre le client et le serveur, la partie serveur, le fin du projet démontre la simplicité avec laquelle nous allons créer un client REST avec RestTemplate.

La partie cliente de l'application se compose de deux fichiers : une implémentation cliente de l'interface RestSimpleService et un contexte Spring. Voici l'implémentation de l'interface RestSimpleService partagée par le client et le serveur : public class RestSimpleClientImpl implements RestSimpleService { private RestTemplate... Lire RESTer simple avec Spring et JAXB - Partie 3 : Client REST avec RestTemplate

[Spring] Gestion des propriétés et des messages

Benoît Cotinat — Fri, 17 Dec 2010 15:30:00 +0100

Dans ce billet je vais faire un rapide aperçu d'une des manières de gérer les messages et les propriétés d'un projet avec Spring.

Généralement, les messages sont stockés dans des fichiers properties inclus dans le projet. Il y a deux manières de déclarer les fichiers properties, selon les besoins d'utilisation des propriétés. Placeholder Il arrive souvent que des propriétés techniques aient besoin d'être injectées dans des beans par Spring. Lire [Spring] Gestion des propriétés et des messages

Spring annotations vs standards annotations: Que choisir entre @Autowired et @Resource?

Abderrazek CHINE — Sun, 07 Mar 2010 19:32:00 +0100

L'objet de ce billet, en deux parties, est de comparer l'annotation standard @Resource du package javax.annotation.Resource à celle de
spring @Autowired du package org.springframework.beans.factory.annotation.
Nous verrons les situations où nous sommes obligés de favoriser les annotations standards.

L'utilisation des annotations réduit considérablement la verbosité des fichiers de configuration de Spring.
C'est aussi le même constat pour d'autres frameworks.
En effet, le principe "convention Over configuration" participe à cette diffusion.
Certes, les "pour" et les "contre" ne manqueront pas d'arguments pour débattre.
Mais ceci n'est pas l'objet de ce billet.
L'objectif ici est de comparer ces deux types d'annotations.
Pour cela, nous nous appuyons sur un projet java simple, sans maven, que vous pouvez créer sous Eclipse en suivant les étapes décrites ci-après.
Nous écrivons d'abord un projet avec les annotations de Spring puis nous illustrons les difficultés qui nous amèneront à introduire les annotations standards.

PREMIERE PARTIE: Annotations Spring @Autowired, @Service & cie Dans cette première partie, le projet java exemple ci-après n'utilise que les annotations de Spring. Pré-requis: Le projet java standard doit avoir les librairies nécessaires suivantes : spring-2.5.6.jar, spring-test-2.5.6.jar et Junit 4.4.jar ( apache-commons-**.jar). Notez qu'il... Lire Spring annotations vs standards annotations: Que choisir entre @Autowired et @Resource?

JAX-RS web service REST avec Spring (implémentation RestEasy)

Abderrazek CHINE — Sat, 30 Jan 2010 19:54:00 +0100

L'objet de ce billet: Illustrer avec un exemple assez complet la mise en pratique du web service REST (JAX-RS) s'appuyant sur l'implémentation RestEasy de JBoss avec Spring 2.5.
L'exemple repose sur les briques (api) suivantes. Notez bien la version lorsqu'elle est mentionnée.

RestEasy: L'implémentation Jboss de jax-rs (JSR 311),
Spring 2.5 et les annotations,
Hibernate pour la partie persistence
L'api Dozer v4.0 pour les DTO (Data Transfert Objetc) ou VO((Value Object).
Junit 4.4,
HttpUnit,
XMLUnit.

Nota:La version Dozer 4.0 a renommé complètement ses packages. Certains tutos sur le web sont donc caduques.
C'est à la fin de l'étape 5 que nous détaillons l'emploi de l'api Dozer.

Quelques repères:
REST (Representational State Transfer) développé par Roy Fielding qui est l’un des fondateurs du protocol HTTP.
JSR 311 est la spec JAX-RS: Java API for RESTful Web Service. Finalisée en mars 2008.

Les CINQ principes de REST

P1: Tout est ressource, un identifiant unique à chaque ressource (http://localhost:8888/clients/2 pointe sur le client ayant id=2),
P2: Utiliser les méthodes HTTP (HEAD/GET/POST/PUT/DELETE). Et les erreurs standards HTTP,
P3: Les échanges avec plusieurs représentations ( xml,(x)html, json,..),
P4: Échanges sans état (stateless),
P5: Lier les ressources entre elles.

PRÉ-REQUIS: Java5.

Mise en pratique L'exemple ci-après a pour but d'aller plus loin que l'éternel "HelloWorld". Car je trouve que le fameux "Helloworld" ne permet pas de d'aborder les notions intéressantes. Voici donc les étapes de mise en œuvre d'un exemple assez complet. Celui-ci répond aux cas d'utilisation suivants: - Rechercher dans la base (mysql ) un ou... Lire JAX-RS web service REST avec Spring (implémentation RestEasy)

Framework de validation de Spring 2.5+ avec annotations Java 5 [1ère partie : Durée 20min]

Abderrazek CHINE — Fri, 06 Nov 2009 21:46:00 +0100

En quatre actes, nous allons illustrer la puissance du framework de validation de Spring sans écrire la moindre classe de validation.
En effet, quelques annotations dans vos beans (POJO), trois lignes de configuration et une ligne de code java; et le tour est joué! Le résultat obtenu est impressionnant!
Vos objets sont validés. De plus, la validation est faite côté serveur et client.
Nous détaillerons tout cela sur un exemple intéressant un peu plus loin.
Ma découverte du framework de validation de Spring me fait dire :
Avec Spring, la vie des développeurs (et des chefs de projet) devient un fleuve tranquille de bonnes pratiques même si l'apprentissage, lui, est loin de l'être!

Sans rentrer dans le débat sur la nécessité de valider les objets et du côté client et du côté serveur, ce framework concilie et satisfait les deux avis.

La démonstration qui va être donnée contient deux projets:
- Le premier, projet web Spring MVC avec maven, détaille comment valider, côté client et serveur, nos objets avec les meilleures pratiques.
- Le second, projet java standalone, illustre un certain nombre d'annotations du framework de validation avec peu de lignes de configuration xml.
Et, le tout avec très peu de code java et en recourant aux validateurs prédéfinis de ce framework.
Le résultat est déconcertant!
Ce framework nous épargne des dizaines de lignes de code java (sans parler du temps à consacrer à les tester/déboguer!).
La démo ci-après repose et applique les deux grands principes:

Tout est POJO,
Séparation des préoccupations.

Passons à la pratique.....
Un seul pré requis nécessaire : connaître le framework de Spring et Spring MVC.

Avertissement: Dépendances/classpath: le jar spring-modules-0.9.jar de Spring validation doit être dans le classpath car il n' est pas inclus dans les spring_xxxx.jar. Pour un projet maven, ajouter dans le pom.xml la ligne: org.springframework spring-modules... Lire Framework de validation de Spring 2.5+ avec annotations Java 5 [1ère partie : Durée 20min]

Spring-Quartz : Planifier une tâche batch java en 30 minutes

Abderrazek CHINE — Tue, 09 Jun 2009 20:14:00 +0200

L'objet de ce billet est de montrer comment planifier une tâche java avec Quartz et Spring et ce en n'ajoutant que quelques lignes de configuration xml.
Ce "QuickStart" introduisant Spring2.5+ et Quartz 1.6.5+ vous permet d'être opérationnel en 30 minutes.
Quartz est un ordonnanceur (scheduler) qui permet de planifier des tâches batch java (Job) à des intervalles spécifiés. Par exemple, réaliser des traitements lourds (génération de rapports, de statistiques) à des heures où les ressources du serveur sont suffisamment disponibles.
Quartz s’intègre assez facilement dans Spring (sauf peut être en mode Cluster, qui ne sera pas traité ici, pour lequel l'apprentissage est important!).
Afin de faciliter la mise en place de notre exemple, nous avons privilégié le mode RAMJobStore (les Jobs Quartz sont chargés en mémoire sans les persister).
Notre exemple est un projet web mais sachez qu'il est encore plus simple de prendre un projet java. Néanmoins le type de projet web est très instructif.
Nous terminerons ce billet en testant le Job exemple avec une classe JUnit4 avec Spring.
Tous les détails de configuration des dépendances Maven, de Spring et celles de Quartz dans Spring seront donnés.
Nous mentionnons, surtout à l'intérieur des codes, les explications utiles pour comprendre l'api Quartz et toutes les indications nécessaires afin d'éviter les quelques pièges de la configuration Spring-Quartz.
Un seul pré-requis nécessaire: connaître le framework Spring. La connaissance de Quartz peut s'acquérir de manière incrémentale.

SOMMAIRE: Nous développons dans ce billet les trois grandes étapes suivantes: ETAPE1: MISE EN PLACE DE L'ENVIRONNEMENT: - Création et configuration du projet Eclipse et Maven, - Configuration des dépendances maven pour Spring et Quartz: pom.xml, - Configuration du fichier web.xml, - Configuration Quartz : fichier quartz.xml, - Configuration xml... Lire Spring-Quartz : Planifier une tâche batch java en 30 minutes

Tests JUnit4 combiné avec Spring et Spring MVC en mode transactionnel

Abderrazek CHINE — Fri, 17 Apr 2009 16:18:00 +0200

Le titre de ce billet montre bien l'étendue des thèmes variés qui seront traités. Il a pour objectif d'illustrer, à l'aide d'un exemple assez complet et proche des cas réels, la mise en place des tests, en mode transactionnel, pour les différentes couches applicatives. Ainsi les vraies difficultés rencontrées par les développeurs seront évoquées.
Le billet traite JUnit4 enrichi avec les annotations de Spring 2.5+ et ses lanceurs pour exécuter facilement les tests. Des illustrations en mode transactionnel vous sont proposées à la fin de ce billet.
Le framework JUnit est l'oeuvre conjointe de Kent Beck (créateur de XP) et Erich Gamma (auteur des Design Patterns).
Avec la version 4, JUnit tente de rattraper son retard sur Testng tout en gardant la compatibilité avec JUnit3x ainsi qu'une parfaite intégration aux éditeurs Eclipse, Netbeans, ...
Avec les lanceurs de spring, les tests deviennent plus attrayants. Spring encourage ainsi à adopter l'approche TDD "Test Driven Design" ou "Test-First Developpment".
Notez que le jdk5+ est nécessaire pour certaines parties de code Java. Les commentaires dans le code java le mentionnent au bon endroit.

Le framework JUnit est l'oeuvre conjointe de Kent Beck (créateur de XP) et Erich Gamma (auteur des Design Patterns). Avec la version 4, JUnit tente de rattraper son retard sur Testng tout en gardant la compatibilité avec JUnit3x ainsi qu'une parfaite intégration aux éditeurs Eclipse, Netbeans, ... La pratique des tests unitaires est l'un des... Lire Tests JUnit4 combiné avec Spring et Spring MVC en mode transactionnel