Nouveau look pour le site de Spring

Ok, une chose est sûre : l’ancien site était moche. mais le nouveau design (depuis aujourd’hui), n’est pas une foudre de beauté non plus X-D …

Si j’aime (presque) bien l’entête, je crois que les bulles à gauche et à droite sont complètement ratés et semblent plus être une sorte de champignons sauvages qui poussent à tout-va sur mon écran :D
J’exagère un peu, mais l’idée est là !

=> http://www.springframework.org/node/731

—-

Développez votre première application multi-bundles avec S2AP

Suite à ce billet : Vos premiers pas avec SpringSource Application Platform et eclipse où j’avais montré comment configurer le tooling STS avec Eclipse ainsi que la création et le déploiement d’une application exemple, je vais montrer dans ce billet comment développer une application multi-tiers s’étalant sur plusieurs bundles.

Read more of this post

Application exemple (JPA managé par Spring)

Suite à ce billet que j’ai rédigé pour montrer comment mettre en place JPA/Hibernate en mode managé avec Spring, on m’a à maintes reprises demandé de fournir une application exemple pour montrer en pratique ces concepts.

Read more of this post

[Eclipse][Java][Spring] Wicket sur S2AP : ça marche enfin

Voilà, tout est dans le titre: je suis enfin arrivé à créer et à deployer mon premier bundle (et non pas war) utilisant Wicket sur SpringSource Application Platform (S2AP), chose qui était non faisable jusqu’à la beta 5 de S2AP qui apporte la pièce manquante: les fragments web.xml.

[Suite:]

SpringSource voulait initialement fournir une nouvelle méthode pour la configuration d’une application web, qui utilise le manifest au lieu de l’habituel web.xml.

Seulement, dans les premières versions (et même jusqu’à la plus récente), les paramètres de configuration étaient limités comparé à ceux offerts par web.xml, ce qui a fait que plusieurs frameworks webs ne pouvaient pas être utilisés dans un bundle web de S2AP.

Pour Wicket, ce qui manquait avant, c’était:

  1. La possibilité de déclarer une servlet/filtre dans le manifest des bundles. Ce point a été adressé (quoi que partiellement) en donnant la possibilité de spécifer des servlets dans le manifest (mais pas les filtres, utilisés par Wicket depuis la version 1.3).
  2. Mais surtout la possibilité de spécifier les init-params des servlets/filtres depuis le manifest.
  3. enfin, les méta-données OSGi dans la distribution wicket.

S2AP beta 5 a donc résolu les deux premiers points en donnant la possibilité d’utiliser le bon vieux web.xml dans les bundles, ce qui nous permet donc de déclarer le filtre de Wicket, son mapping ainsi que l’init-paramapplicationClassName“.

Le dernier point a lui été adressé par l’équipe de Wicket qui ont inclus ledits méta-données OSGi dans les manifest des jars de Wicket 1.4 (disponible actuellement en version “Milestone 2“).

Bon, en réalité, il y’avaient quelques problèmes dans ces méta-données comme ici par exemple ou encore ici, mais l’équipe Wicket est suffisamment réactive et rapide pour que ces détails soient réglées en quelques jours.

remarque aussi que l’équipe de S2AP est en train d’OSGi’fier la distribution actuelle de Wicket (1.3.3) (suivi ici).

Voici maintenant comment créer un bundle Wicket-powered:

Serveur

Assurez vous que vous avez S2AP beta 5 qui soit installée sur votre disque (“/home/djo/Java/servers/springsource-ap-1.0.0.beta5/” dans mon cas).

Installer les jars OSGi’fiés de Wicket

Téléchargez ensuite la distribtion Wicket 1.4 M2 (téléchargeable ici) et décompressez la. Copiez le fichier “wicket-1.4-m2.jar” du dossier lib vers le dossier “repository/bundles/usr” de S2AP (“/home/djo/Java/servers/springsource-ap-1.0.0.beta5/repository/bundles/usr” dans mon cas).

Installer les jars OSGi’fiés de SLF4J (enfin presque)

Il nous faut aussi Slf4j, donc, normalement, il faut se rendre dans le respository de SpringSource pour récupérer les jars OSGI’fiés de Slf4j et “Slf4j log4j binding” et les copier dans le dossier “repository/bundles/usr“, mais je vais montrer une autre façon beaucoup plus pratique pour le faire.

Installer le tooling eclipse

Dans eclipse, assurez vous que le tooling de SpringSource (ainsi que Spring IDE) est mis en place comme montré ici.

Installer les jars OSGi’fiés de SLF4J (pour de vrai)

Dans la vue Servers, double cliquez sur le serveur S2AP et dans la fenêtre qui s’affiche, activer l’onglet repository.
Cette vue (éditeur en fait) permet de rechercher et récupérer des jars depuis le repository S2, le tout depuis eclipse.
Effectuez une recherche sur slf4j, cochez SLF4J API et SLF4J LOG4J Binding et cliquez sur download => Et hop, ils seront ajoutés dans le repository de S2AP.

eclipse STS

Le manifest

Créez un nouveau bundle (nommé “djo.s2ap.wicket” dans mon cas) et modifiez son manifest comme ceci:

Manifest-Version: 1.0 
Bundle-Version: 1.0.0 
Bundle-Name: Wick Bundle 
Bundle-ManifestVersion: 2 
Web-ContextPath: wicket 
Bundle-SymbolicName: djo.s2ap.wicket 
Platform-ModuleType: Web 
Import-Package:  
 org.apache.wicket, 
 org.apache.wicket.markup.html, 
 org.apache.wicket.markup.html.basic, 
 org.apache.wicket.model, 
 org.apache.wicket.protocol.http, 
 org.apache.wicket.behavior, 
 org.apache.wicket.ajax, 
 org.apache.wicket.util.time, 
 org.slf4j

Le fragment de web.xml

Créez ensuite un dossier WEB-INF dans le dossier src du bundle, et un fichier web.xml ladedans avec ce contenu:

<?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"> 
  <display-name>wicket</display-name> 
  <filter> 
    <filter-name>WicketApplication</filter-name> 
    <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class> 
    <init-param> 
      <param-name>applicationClassName</param-name> 
      <param-value>djo.s2ap.wicket.MyApp</param-value> 
    </init-param> 
  </filter> 
  <filter-mapping> 
    <filter-name>WicketApplication</filter-name> 
    <url-pattern>/*</url-pattern> 
  </filter-mapping> 
</web-app>

L’infrastructure Wicket

Créez un package “djo.s2ap.wicket”. dans ce package, on crée comme d’habitude pour Wicket une classe pour l’application, une classe et une page html pour la page d’accueil.

Classe de la page d’accueil

package djo.s2ap.wicket; 
 
import java.text.DateFormat; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
 
import org.apache.wicket.ajax.AjaxSelfUpdatingTimerBehavior; 
import org.apache.wicket.markup.html.WebPage; 
import org.apache.wicket.markup.html.basic.Label; 
import org.apache.wicket.model.LoadableDetachableModel; 
import org.apache.wicket.util.time.Duration; 
 
public class MainPage extends WebPage<MainPage> { 
  private static final DateFormat df = new SimpleDateFormat("HH:mm:ss"); 
 
  public MainPage() { 
 
    final Label<String> currentTime = new Label<String>("time", 
        new LoadableDetachableModel<String>() { 
          @Override 
          protected String load() { 
            return df.format(new Date()); 
          } 
 
        }); 
    currentTime.add(new AjaxSelfUpdatingTimerBehavior(Duration.ONE_SECOND)); 
    add(currentTime); 
  } 
}

Page HTML de la page d’accueil (MainPage.html)

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE html PUBLIC "-W3CDTD XHTML 1.0 TransitionalEN" "http:www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> 
<title>Test</title> 
 
</head> 
<body> 
<span wicket:id="time">...</span> 
</body> 
</html>

Classe de l’application

package djo.s2ap.wicket; 
 
import org.apache.wicket.protocol.http.WebApplication; 
 
public class MyApp extends WebApplication { 
 
  @Override 
  public Class getHomePage() { 
    return MainPage.class; 
  } 
 
}

Déploiement et test

Et voilà : reste plus qu’à deployer et tester la chose.

En ce qui me concerne, j’arrive pas à lancer un bundle depuis eclipse, donc je procède manuellement en exportant le projet du bundle en jar (via le wizard standard d’eclipse). Il faut juste faire attention à utiliser le manifest du projet comme manifest du jar.

Je place ensuite le jar généré dans le dossier pickup de s2AP (/home/djo/Java/servers/springsource-ap-1.0.0.beta5/pickup) et je démarres le serveur (depuis eclipse ou via bin/startup.sh).
Tapez ensuite l’adresse suivante dans le navigateur:

http://localhost:8080/wicket/

et hop, j’ai une page qui affiche le temps courant en temps réel (enfin presque, rafraichissement ajax chaque seconde).

Sources

Le jar en question (ainsi que les sources) peuvent être téléchargées ici.

TODO

Dans un futur billet, je vais montrer comment utiliser Spring avec Wicket pour retrouver un service OSGi exporté par un autre bundle.

—-

[Eclipse][Java][Spring] Vos premiers pas avec Springsource

Dans ce billet, je vais présenter les taches d’installation de SpringSource Application Platform (S2AP) ainsi que le tooling Spring sur eclipse, ce qui permet de simplifier énormément le développement d’applications OSGi.

[Suite:]

1.Préparation de l’environnement

1.1. Téléchargement et installation du serveur S2AP

Le serveur S2AP peut être téléchargé ici moyennant l’inscription dans le programme Beta de SpringSource (rien d’effrayant: juste un un petit formulaire à remplir, et hop).
Notez que la plateforme est divisée en deux paquetages (à cause d’histoires de licences):
– springsource-ap-1.0.0.beta2.zip
– springsource-ap-epl-1.0.0.beta2.zip

Téléchargez les deux paquetages, et à moins que vous ne soyez sur Gnome 2.22 (comme je le suis) qui offre une fonctionnalité de merge super-utile, l’installation va être un peu ennuyante:
– Extraire les deux archives (ils portent le même nom, donc, il faut les extraire dans des dossiers séparés)
– Déplacer tous les fichiers du second paquetage dans l’emplacement adéquat à l’intérieur du dossier d’extraction du premier paquetage.
– Voilà. Le User guide de S2AP indique qu’il faut renseigner une variable d’environnement PLATFORM_HOME mais je ne l’ai pas fait, et ça tourne sans problèmes …

Pour tester si tout s’est bien passé, allez au dossier d’installation puis au sous dossier bin et lancez startup.sh (ou .bat, selon votre plateforme). Vous devriez avoir dans la console un log similaire à celui-ci:

[2008-05-12 14:38:41.654] main                     <SPKB0001I> Platform starting. 
[2008-05-12 14:38:46.198] main             <SPKE0000I> Boot subsystems installed. 
[2008-05-12 14:38:47.441] main             <SPKE0001I> Base subsystems installed. 
[2008-05-12 14:38:50.554] platform-dm-14   <SPPM0000I> Installing profile 'web'. 
[2008-05-12 14:38:53.787] platform-dm-14   <SPPM0001I> Installed profile 'web'. 
[2008-05-12 14:38:54.222] platform-dm-1    <SPSC0001I> Starting ServletContainer on port 8080 and SSL port 8443. 
[2008-05-12 14:38:55.083] platform-dm-9    <SPPM0002I> Platform open for business with profile 'web'. 
[2008-05-12 14:38:56.329] fs-watcher      <SPSC1000I> Creating web application '/'. 
[2008-05-12 14:38:56.448] async-delivery-thread-1  <SPSC1001I> Starting web application '/'. 
[2008-05-12 14:38:56.872] fs-watcher               <SPDE0010I> Deployment of 'platform.admin.splash- 
1.0.0.beta2.war' version '0' completed. 
[2008-05-12 14:38:58.281] fs-watcher               <SPSC1000I> Creating web application '/admin'. 
[2008-05-12 14:38:58.579] async-delivery-thread-1  <SPSC1001I> Starting web application '/admin'. 
[2008-05-12 14:38:59.405] fs-watcher               <SPDE0010I> Deployment of 'platform.admin.web- 
1.0.0.beta2.war' version '0' completed. 

Lancez ensuite le navigateur avec l’adress localhost:8080, et vous devriez avoir un belle page avec le logo SpringSource.

Arretez le serveur si c’est bon (Ctrl+C ou encore en lancant shutdown.sh (ou .bat)), sinon, essayez de ragarder dans le JIRA de S2AP ou encore dans le forum de S2AP (qui ne sont accessibles qu’après enregistrement dans ledit programme beta) s’il n’y a pas de problème similaires.

1.2. Mise en place du tooling eclipse

Le tooling eclipse relatif à S2AP consiste en:

Vérifiez ensuite que vous avez les wizards suivants dans New:

Wizards relatifs à Spring

Il faut ensuite ajouter le serveur S2AP dans la liste des serveurs connus d’eclipse.
Pour ce faire, dans eclipse, allez dans Window, Preferences, Server, Installed Runtimes, et cliquez sur le bouton Add

Dans la fenêtre qui s’affiche, vous trouverez un section SpringSource ainsi qu’un type de serveur (adpater) SpringSource AP v1.0. Sélectionnez ce type et cliquez sur “Next”:

Add Server 2

Dans la page suivante, localisez l’emplacement de S2AP et validez.

Add Server 3

2. Développement d’applications pour S2AP

2.1. Création d’un bundle:

Dans eclipse, Sélectionnez File, New, Other. Dans la liste, localisez la section SpringSource AP et sélectionnez “Bundle Project” puis “Next” :

New Bundle

Saisissez un nom pour le projet et cliquez sur “Next”:

New Bundle

Dans la dernière page, veuillez juste à sélectionner le serveur qu’on vient de créer dans le drop down “Target Runtime” et validez.

New Bundle

Le projet généré ainsi contient d’office un dossier META-INF et un fichier manifest avec une configuration minimale:

New Bundle

2.2. Déploiement du bundle:

Pour déployer le bundle sur le serveur, il faut localiser le serveur S2AP (qu’on vient de créer) dans la vue Servers:

S2AP

Dans son menu contexuel, choisissez “Add and Remove Projects”, ce qui affiche une double liste:

Add remove projects

qui permet de deployer ou de undeployer les bundles.

2.3. Contrôle du serveur:

Comme pour tous les autres serveurs sous eclipse, S2AP se contrôle comme d’habitude (via les boutons Start, Stop, etc.) de la vue Servers:

Controler S2AP

—-

[Java][Spring] Sortie de la seconde Beta de SpringSource

SpringSource vient d’annoncer (il y’a une heure) la sortie de la seconde beta de sa plateforme SpringSource Application Platform (S2AP) avec son lot de bugs corrigés.

A noter qu’il faut s’enregistrer dans leur programme Beta pour pouvoir télécharger la chose.

—-

[Java][Spring] Nouvelle génération de serveurs Java

SpringSource vient tout juste de publier la version beta de ce qu’ils appèlenet Application Platform, un serveur Java EE de nouvelle génération, basé sur l’OSGi et sur Spring. D’ailleurs, le noyeau de ce serveur est développé avec Spring Dynamic Modules.

=> Annonce ici

Plus de détails dans des billets ultérieurs.

—-

Non mais lisez moi ça !

Je vais juste donner le titre et le lien:
Why use Spring… if you have a HashMap at hand?

Et posté sur dzone en plus …

—-

Microsoft acquiert SpringSource: Un poisson d’avril ?

Dans une surprise totale, j’ai lu ce matin une annonce sur InfoQ que SpringSource et Microsoft se sont mis d’accord pour l’acquisition de la première par Microsoft, ce qui aurait comme conséquences l’accord d’une plus grande importance à la branche .net de Spring, que ce soit pour l’IoC ou pour WebFlow qui deviendrait la fondation d’ASP.NET.

=> L’Annonce sur InfoQ

Sans donner plus de détails ni exprimer clairement ce que j’en pense, je dirais simplement ceci: J’espère sincèrement que c’est un poisson d’Avril ! Dieu, faites qu’il en soit ainsi.

—-

De la DI avec Spring 2.5 sans XML (Java SE)

Spring En continuité du post précédent, je vais proposer ici une version modifiée de l’Injector qui ne nécéssite pas de fichier XML pour faire de la DI (Dependancy Injection) dans un environnment SE.

[Suite:]

Il faut passer par les annotations bien sûr, et ceci marche avec spring 2.5 (je ne sais pas si ça l’est avec Spring 2) (Suite à la remarque d’evenisse, ceci ne fonctionne qu’avec Spring 2.5.2).

Voici maintenant le code de la classe Injector:

package spring.di.in.se.can.be.easy; 
 
public class Injector { 
  private static ApplicationContext applicationContext; 
 
  public static void init(String... basePackages) { 
    GenericApplicationContext context = new GenericApplicationContext(); 
    ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner( 
        context); 
    scanner.scan(basePackages); 
    context.refresh(); 
    context.registerShutdownHook(); 
    applicationContext = context; 
    
  } 
 
  public static void configure(Object object) { 
    applicationContext.getAutowireCapableBeanFactory().autowireBean(object); 
  } 
} 

En supposant disposer des même classes du billet précédent (TestDao, TestService et TestConsumer), il est possible de récupérer une instance configurée de TestConsumer comme-ceci:

public class Test { 
 
  public static void main(String[] args) {    
    Injector.init("model"); 
    TestConsumer cl = new TestConsumer(); 
    System.out.println(cl.getValue()); 
  } 
}

(Il faut toujours appeler Injector.configure(this) dans le constructeur de TestConsumer).

La méthode Injector.init prend maintenant une liste de noms de packages à scanner pour les composants Spring, ici seulement le package model (il n’est pas nécesssaire d’annoter TestConsumer comme composant Spring, il suffit juste de déclarer ses dépendances), et hop, ça marche ;)

—-

Follow

Get every new post delivered to your Inbox.