Implémentation de plusieurs interfaces génériques en java

J'ai besoin d'une interface qui m'assure qu'une certaine méthode, y compris une signature spécifique, est disponible. Jusqu'à présent, c'est ce que j'ai:

public interface Mappable<M> {
    M mapTo(M mappableEntity);
}

Le problème se pose lorsqu'une classe doit être mappable à plusieurs autres entités. Le cas idéal serait celui-ci (pas java):

public class Something implements Mappable<A>, Mappable<B> {
    public A mapTo(A someObject) {...}
    public B mapTo(B someOtherObject) {...}
}

Quelle serait la meilleure façon de parvenir à ce que cela reste aussi «générique» que possible?

Bien sûr, ce n'est pas quelque chose que vous pouvez faire en raison de l' effacement de type . Au moment de l'exécution, vous disposez de deux méthodes public Object mapTo(Object), qui ne peuvent évidemment pas coexister.

Malheureusement, ce que vous essayez de faire est simplement au-delà du système de type Java.

En supposant que votre type générique est toujours un type de première classe, et non lui-même générique, vous pouvez obtenir un comportement extérieur similaire en ayant la méthode mapTo(Object, Class), qui vous permettrait de faire une inspection d'exécution de la classe donnée et de décider quel comportement utiliser. Évidemment, cela est assez inélégant - et nécessitera une conversion manuelle de la valeur de retour - mais je pense que c'est le mieux que vous puissiez faire. Si vos types génériques sont eux-mêmes génériques, leurs paramètres génériques seront également effacés et leurs classes seront égales, donc cette méthode ne fonctionnera pas.

Cependant, je pointerais également vers la réponse de @ Joachim, cela peut être un cas où vous pouvez diviser le comportement en composants séparés et contourner le problème.

Comme vous l'avez vu, vous ne pouvez pas implémenter la même interface deux fois avec des paramètres de type différents (à cause de l'effacement: au moment de l'exécution, ce sont les mêmes interfaces).

De plus, cette approche viole le principe de la responsabilité unique: votre classe doit se concentrer sur le fait d'être Something(quoi que cela signifie) et ne doit pas faire la correspondance avec Aou B en plus de cette tâche.

Il semble que vous devriez vraiment avoir un Mapper<Something,A>et un Mapper<Something,B>. De cette façon, chaque classe a une seule responsabilité clairement définie et vous ne rencontrez pas le problème d'implémenter la même interface deux fois.

Étant donné que cela n'est pas autorisé à implémenter plusieurs interfaces, vous pouvez envisager l'utilisation de l'encapsulation. (exemple utilisant java8 +)

// Mappable.java
public interface Mappable<M> {
    M mapTo(M mappableEntity);
}

// TwoMappables.java
public interface TwoMappables {
    default Mappable<A> mapableA() {
         return new MappableA();
    }

    default Mappable<B> mapableB() {
         return new MappableB();
    }

    class MappableA implements Mappable<A> {}
    class MappableB implements Mappable<B> {}
}

// Something.java
public class Something implements TwoMappables {
    // ... business logic ...
    mapableA().mapTo(A);
    mapableB().mapTo(B);
}

Veuillez vérifier ici pour plus d'informations et d'autres exemples: Comment créer une classe Java qui implémente une interface avec deux types génériques? .

public interface IMappable<S, T> {
    T MapFrom(S source);
}

// T - target
// S - source

Si vous souhaitez mapper User à UserDTO et mapper User à UserViewModel, vous aurez besoin de deux implémentations distinctes. N'empilez pas toute cette logique dans une seule classe - cela n'a pas de sens de le faire.

Mise à jour pour garder Joachim heureux

public interface ITypeConverter<TSource, TDestination>
{
    TDestination Convert(TSource source);
}

Mais maintenant, nous sommes dans le domaine Automapper ( http://automapper.codeplex.com/wikipage?title=Custom%20Type%20Converters )