Appeler différentes APIs de service basées sur l'objet entité dans le framework printanier

Question

Je travaille sur une application de service web conçue en utilisant le framework spring, où j'ai différentes classes d'entités (ActivityA, ActivityB, ActivityC ...) qui héritent d'une classe de base "activité"

Maintenant, j'ai écrit différentes API de service dans la couche de service pour la classe de base et toutes les classes enfants. (à name, ActivityService, ActivityAService, ActivityBService, ActivityCService ..)

Toutes les méthodes qui fonctionnent de manière similaire pour chaque activité sont mises en service api de classe de base (ActivityService) et reposent dans leurs services respectifs.

Je connais généralement l'objet sur lequel je travaille, et j'appelle le service api respectif. Mais dans un cas particulier, j'ai l'objet d'activité (je ne sais pas de quelle classe enfant il s'agit) et je dois écrire une méthode qui est différente pour tous les objets d'entité.

PROBLÈME: Est-il possible, je peux appeler différent en fonction de l'objet de l'entité de service que j'ai (l'objet que j'ai est l'entité, et non le service et je ne peux pas faire tout codage en dur pour obtenir objet Service)

Answer 1

.

Mais dans un cas particulier, j'ai l'objet d'activité (je ne sais pas de quelle classe enfant il s'agit) et je dois écrire une méthode qui est différente pour tous les objets d'entité.

Assurez la classe abstraite de base et définir une méthode abstraite que chaque classe sous doit mettre en œuvre:

public abstract class ActivityService{ 
    public abstract Foo processEntity(Entity entity); 
} 

PROBLÈME: Est-il possible, je peux appeler différent en fonction de l'entité de services objet que j'ai (l'objet que j'ai est d'entité, pas de service et je ne peux pas faire un codage dur à)

Ceci est une situation que vous devriez essayer d'éviter. Habituellement, vous devriez seulement envoyer une entité à un service qui sait quoi en faire, et non à un groupe de services, dont l'un est responsable. Mais ce que je ferais est d'utiliser un service de répartiteur qui conserve une carte des classes dont les services sont responsables. Il utilise une logique comme ceci:

private Map<Class<? extends Entity>, 
    Class<? extends ActivityService>> serviceMap = 
     new ConcurrentHashMap<Class<? extends Entity>, 
           Class<? extends ActivityService>>(); 
private ApplicationContext context; 
private ActivityService getServiceForEntity(Entity e){ 
    Class<? extends Entity> entityClass = e.getClass(); 
    Class<? extends ActivityService> serviceClass = 
     serviceMap.get(entityClass); 
    if(serviceClass==null){ 
     for(Map.Entry<Class<? extends Entity>, 
         Class<? extends ActivityService>> entry : 
      serviceMap.entrySet()){ 
      if(entry.getKey().isAssignableFrom(entityClass)){ 
       serviceClass = entry.getValue(); 
       break; 
      } 
     } 
     if(serviceClass==null){ 
      // throw a suitable exception 
     } 
     serviceMap.put(entityClass, serviceClass); 
    } 
    return context.getBean(serviceClass); 
}