Witam. Mam następujący problem z refactoringiem kodu wykonującego transformacje różnych niepowiązanych ze sobą typów. Obecnie wykonywane to było w mniej więcej następujący sposób:
class Container{
TargetObject1 targetObject1;
TargetObject2 targetObject2;
}
public void convert(Object o){
if(o instanceof SourceObj1){
container.targetObject1 = transformerSourceObj1.transformSourceObj1((SourceObj1) o);
} else if(o instanceof SourceObj2){
container.targetObject2 = transformerSourceObj2.transformSourceObj2((SourceObj2) o);
}
Transformery ani obiekty nie są ze sobą w żaden sposób powiązane, tzn. nie implementują wspólnego interface'u. Pierwszą rzeczą, którą chciałbym wykonać, jest ustawienie wspólnego typu dla nich. Coś w rodzaju:
public interface ITransformer<T, U> {
T transform(U source);
}
@ObjectTransformer(targetClass = SourceObj1.class)
public class TransformerAObj implements ITransformer<TargetObject1, SourceObj1> {
public TargetObject1 transform(SourceObj1 source) {
TargetObject1 targetObject1 = new TargetObject1();
targetObject1.targetField = source.sourceField + "123456789";
return targetObject1;
}
}
Kolejną sprawą jest uniknięcie długiej listy intanceof. Czy jest sposób, aby w tym przypadku użyć adnotacji, ale nie na obiekcie źródłowym, gdyż ten pochodzi z zewnętrznej biblioteki, a na obiekcie, na który następuje transformacja? Może coś jak:
@Target(ElementType.TYPE)
public @interface ObjectTransformer {
Class<?> targetClass();
}
Najlepiej byłoby, gdyby na podstawie adnotacji do określonej dynamicznej struktury(np. mapy) dodawał ITransformer, gdzie kluczem byłaby klasa obiektu źródłowego. Niestety na przeszkodzie stoi generycznośc powyższego interface'u. Czy jest możliwość uzyskania dużej płynności w dodawaniu nowych transformerów dla typów bez rozbudowywania listy if..else if najlepiej z wykorzystaniem adnotacji? Dodam także, że dość ważna jest w tym wypadku wydajność, gdyż metoda ta jest często wywoływana i użycie refleksji za każdym razem może być za bardzo obciążające.
