RCP et Guice

Pour orienter vers du SOA mon application RCP j’ai choisi Guice. C’est simple et rapide à implémenter.
Pour appeler un service on fait :

Guice.createInjector().getInstance(aClass);

aClass n’est pas le service en lui-même mais un objet qui va utiliser des services qu’on lui injectera. De ce fait on ne peut créer un ViewPart qui inclut des services auto-injectés, nous devons utiliser une classe intermédiare : un controleur.
Prenons un exemple avec les classes suivantes : une ViewPart (MissionViewPart), un controleur (MissionViewController), un service (MissionService). Les déclarations ressembleront à :

– MissionService :

@ImplementedBy(MissionServiceImpl.class)
public interface MissionService {
...
}

en créant un singleton MissionServiceImpl qui implémente MissionService
– MissionServiceImpl :

@Singleton
public class MissionServiceImpl implements MissionService {
    public MissionServiceImpl() {
	...
	}
...
}

– MissionViewController (dans laquelle le service est injecté) :

public class MissionViewController {
    MissionService service;

    @Inject
    public MissionViewController(MissionService service) {
        this.service = service;
    }
...
}

– MissionViewPart

 public class MissionView extends ViewPart {
    public static final String ID = "ResUrgencesSMUR.missionView";
    MissionViewController controller;

    public MissionView() {
        controller = Controllers.getInstance(MissionViewController.class);
    }
...
}

J’utilise la classe Controllers car le Guice User’s Guide dit :

Your code should deal directly with the Injector as little as possible. Instead,
you want to bootstrap your application by injecting one root object. The container
can further inject dependencies into the root object’s dependencies, and so on
recursively. In the end, your application should ideally have one class (if that
many) which knows about the Injector, and every other class should expect to
have dependencies injected.

– Controllers :

public class Controllers {
    static Injector injector = Guice.createInjector();
    static Map controllers = new HashMap();
    public static  T getInstance(Class type) {
        T controller = (T)controllers.get(type);
        if (controller == null) {
            controller = injector.getInstance(type);
            controllers.put(type, controller);
        }
        return controller;
    }
}

Soit maintenant la vue appelle le controleur, pour créer l’interface utilisateur, faire le binding, etc… et les services sont automatiquement injectés. Pour utiliser différentes implementations vous devez utiliser le concept de Module ,en le déclarant au départ, ce qui permet de définir quelle implémentation correspond pour chaque service, la clé @implementedKey ne définit que l’implementation par défaut.
C’est une manière simple d’utiliser l’injection mais si l’application est complexe et volumineuse, et surtout fait interagir beaucoup de service entre eux ainsi que d’autres technologies il est plus judicieux de s’orienter vers des frameworks SOA fait pour cela (Improve Foundations, Spring).