Quelle est la bonne façon de modéliser un objet qui fournit de nombreux services?

Question

Fondamentalement j'ai une entité (appelée session) qui fournira de nombreux services. Chaque service peut être activé ou désactivé sélectivement par l'utilisateur (connexion ou déconnexion). Je ne suis pas sûr de ce qui est le meilleur design pour représenter cela. Voir UML

Du point de vue de l'utilisation de la programmation de cas, les interactions avec une instance de session:

Session session = new Session("1234"); // 1234 is the userid 
session.start(); 

session.serviceSignIn(ServiceType.DELICIOUS); 
.... do stuff ... 
session.serviceSignOut(ServiceType.DELICIOUS); 

session.serviceSignIn(ServiceType.MAGNOLIA); 
.... do stuff ... 
session.serviceSignOut(ServiceType.MAGNOLIA); 

Une autre conception possible:

session.delicious().signIn(); 
.... do stuff ... 
session.delicious().signOut(); 

session.magnolia().signIn(); 
.... do stuff ... 
session.magnolia().signOut(); 

Que dois-je préfère? Quelles erreurs fais-je?

Answer 1

Pourquoi nommer explicitement les services? Vraisemblablement, cela va être connecté à une interface graphique ou une autre interface correcte? Probablement assez pour se référer à eux par des chaînes comme "délicieux". Aussi, pourquoi ne pas faire de chaque service une classe qui puisse le signer soi-même?

interface Service { 
    String getName(); 
    void signin(); 
    void signout(); 
    State getState(); // state could be signed in signed out or signing in perhaps 
} 

class Services { 
    void addService(Service service); 
    void removeService(Service service); 
    Service getService(String serviceName); 

    ... 
} 

Vous devez également faire en sorte que l'interface de service ait des opérations pour effectuer des opérations avec le service, telles que l'ajout de signets.

Answer 2

Je pense que la première approche que vous n'êtes pas laçant dans la conception de quelque façon. Vous pouvez charger des services de façon dynamique, et d'ajouter facilement de nouveaux services à l'avenir (car il n'y a pas de code liaison au type de service exact - comme dans la deuxième méthode).

Answer 3

Je pense que le facteur déterminant dans cette décision devraient être les services réels fournis par délicieux et magnolias. Sont-ils le même service? Si la seule chose qu'ils ont en commun est le comportement signin/de signout, alors je vais pour la deuxième approche, probablement avec une fonction signin/de signout comme une sorte d'interface/mixin.

Answer 4

Pour moi, il ressemble à un modèle classique de façade, vous parlez de services est-ce pour une implémentation SOA? peut-être jeter un oeil à Service Facade. Je chercherais à utiliser un point d'entrée unique comme vous l'avez décrit (Façade) avec les paramètres conduisant une usine à retourner l'implémentation spécifique. L'exemple suivant vous permet d'ajouter des services supplémentaires sans modifier l'implémentation.

interface ISessionFacade 
{ 
    void ServicesSignIn(string serviceType); 

    void ServiesSignOut(string serviceType); 
} 

interface ISessionService 
{ 
    void ServicesSignIn(); 

    void ServiesSignOut(); 
} 

class ServiceFactory 
{ 
    public static ISessionService CreateService(string serviceType) 
    { 
     ISessionService sessionService = null; 

     // TODO: Configuration lookup of serviceType, returning a fully qualified class name to load 

     // TODO: Dynamically load class, perhaps this should be a singleton? 

     return sessionService; 
    } 
} 

class Session : ISessionFacade 
{ 
    public void ServicesSignIn(string serviceType) 
    { 
     ISessionService serviceSession = ServiceFactory.CreateService(serviceType); 
     serviceSession.ServicesSignIn(); 
    } 

    public void ServiesSignOut(string serviceType) 
    { 
     ISessionService serviceSession = ServiceFactory.CreateService(serviceType); 
     serviceSession.ServiesSignOut(); 
    } 
}